refactor(apple): use feature flags evaluated in JS (#2431)

Author: tido64

ios/app.mjs

@@ -13,9 +13,9 @@ import {
 import { cp_r, mkdir_p, rm_r } from "../scripts/utils/filesystem.mjs";
 import { generateAssetsCatalogs } from "./assetsCatalog.mjs";
 import { generateEntitlements } from "./entitlements.mjs";
+import { isBridgelessEnabled, isNewArchEnabled } from "./features.mjs";
 import { generateInfoPlist } from "./infoPlist.mjs";
 import { generateLocalizations, getProductName } from "./localizations.mjs";
-import { isBridgelessEnabled, isNewArchEnabled } from "./newArch.mjs";
 import { generatePrivacyManifest } from "./privacyManifest.mjs";
 import { isObject, isString, projectPath, resolveResources } from "./utils.mjs";
 import {

ios/newArch.mjs ios/features.mjsios/newArch.mjs renamed to ios/features.mjs

@@ -1,14 +1,11 @@
 // @ts-check
+/** @import { JSONObject } from "../scripts/types.ts"; */
 import { v } from "../scripts/helpers.js";
 
-/**
- * @typedef {import("../scripts/types.ts").JSONObject} JSONObject;
- */
-
 /**
  * @param {number} reactNativeVersion
  */
-export function supportsNewArch(reactNativeVersion) {
+function supportsNewArch(reactNativeVersion) {
   return reactNativeVersion === 0 || reactNativeVersion >= v(0, 71, 0);
 }
 
@@ -27,7 +24,16 @@ export function isNewArchEnabled(options, reactNativeVersion) {
     return envVar !== "0";
   }
 
-  return Boolean(options["fabricEnabled"]);
+  if ("newArchEnabled" in options) {
+    return Boolean(options["newArchEnabled"]);
+  }
+
+  if ("fabricEnabled" in options) {
+    return Boolean(options["fabricEnabled"]);
+  }
+
+  // TODO: https://github.com/microsoft/react-native-test-app/issues/2321
+  return false;
 }
 
 /**

ios/pod_helpers.rb

@@ -18,13 +18,6 @@ def assert_version(pod_version)
         "#{pod_version}, expected >=1.13"
 end
 
-def bridgeless_enabled?(options, react_native_version)
-  new_architecture_enabled?(options, react_native_version) && (
-    (react_native_version >= v(0, 74, 0) && options[:bridgeless_enabled] != false) ||
-    (react_native_version >= v(0, 73, 0) && options[:bridgeless_enabled])
-  )
-end
-
 def find_file(file_name, current_dir)
   return if current_dir.expand_path.to_s == '/'
 
@@ -34,16 +27,6 @@ def find_file(file_name, current_dir)
   find_file(file_name, current_dir.parent)
 end
 
-def new_architecture_enabled?(options, react_native_version)
-  return false unless supports_new_architecture?(react_native_version)
-
-  ENV.fetch('RCT_NEW_ARCH_ENABLED', options[:fabric_enabled] ? '1' : '0') != '0'
-end
-
-def supports_new_architecture?(react_native_version)
-  react_native_version.zero? || react_native_version >= v(0, 71, 0)
-end
-
 def use_hermes?(options)
   use_hermes = ENV.fetch('USE_HERMES', nil)
   return use_hermes == '1' unless use_hermes.nil?
@@ -56,7 +39,7 @@ def use_hermes?(options)
 end
 
 def use_new_architecture!(options, react_native_version)
-  return unless new_architecture_enabled?(options, react_native_version)
+  return unless options[:use_new_arch]
 
   if react_native_version < v(0, 76, 0)
     Pod::UI.warn(
@@ -69,7 +52,7 @@ def use_new_architecture!(options, react_native_version)
   options[:fabric_enabled] = true
   options[:new_arch_enabled] = true
   ENV['RCT_NEW_ARCH_ENABLED'] = '1'
-  ENV['USE_BRIDGELESS'] = '1' if bridgeless_enabled?(options, react_native_version)
+  ENV['USE_BRIDGELESS'] = '1' if options[:use_bridgeless]
 end
 
 def v(major, minor, patch)

ios/test_app.rb

@@ -102,14 +102,18 @@ def resources_pod(project_root, platforms, resources)
   Pathname.new(app_dir).relative_path_from(project_root).to_s
 end
 
-def use_react_native!(project_root, react_native, version, options)
-  require_relative(react_native_pods(version))
+def use_react_native!(project_root, project, options)
+  require_relative(react_native_pods(project[:react_native_version]))
+
+  react_native_path = Pathname.new(project[:react_native_path])
 
   include_react_native!(**options,
                         app_path: find_file('package.json', project_root).parent.to_s,
-                        path: Pathname.new(react_native).relative_path_from(project_root).to_s,
+                        path: react_native_path.relative_path_from(project_root).to_s,
                         rta_project_root: project_root,
-                        version: version)
+                        use_new_arch: project[:use_new_arch],
+                        use_bridgeless: project[:use_bridgeless],
+                        version: project[:react_native_version])
 end
 
 def make_project!(project_root, target_platform, options)
@@ -165,6 +169,7 @@ def make_project!(project_root, target_platform, options)
     :react_native_host_path => project['reactNativeHostPath'],
     :community_autolinking_script_path => project['communityAutolinkingScriptPath'],
     :use_new_arch => project['useNewArch'],
+    :use_bridgeless => project['useBridgeless'],
     :code_sign_identity => build_settings[CODE_SIGN_IDENTITY] || '',
     :development_team => build_settings[DEVELOPMENT_TEAM] || '',
     :resources => project['resources'],
@@ -179,11 +184,9 @@ def use_test_app_internal!(target_platform, options)
   xcodeproj = 'ReactTestApp.xcodeproj'
   project_root = Pod::Config.instance.installation_root
   project_target = make_project!(project_root, target_platform, options)
-  xcodeproj_dst, platforms, react_native_path, react_native_version = project_target.values_at(
-    :xcodeproj_path, :platforms, :react_native_path, :react_native_version
-  )
+  xcodeproj_dst, platforms = project_target.values_at(:xcodeproj_path, :platforms)
 
-  if project_target[:use_new_arch] || react_native_version >= v(0, 73, 0)
+  if project_target[:use_new_arch] || project_target[:react_native_version] >= v(0, 73, 0)
     install! 'cocoapods', :deterministic_uuids => false
   end
 
@@ -205,10 +208,7 @@ def use_test_app_internal!(target_platform, options)
   react_native_post_install = nil
 
   target 'ReactTestApp' do
-    react_native_post_install = use_react_native!(project_root,
-                                                  react_native_path,
-                                                  react_native_version,
-                                                  options)
+    react_native_post_install = use_react_native!(project_root, project_target, options)
 
     pod 'ReactNativeHost', :path => project_target[:react_native_host_path]
 

test/ios/newArch.test.ts test/ios/features.test.tstest/ios/newArch.test.ts renamed to test/ios/features.test.ts

@@ -1,6 +1,6 @@
 import { ok } from "node:assert/strict";
 import { afterEach, before, describe, it } from "node:test";
-import { isBridgelessEnabled, isNewArchEnabled } from "../../ios/newArch.mjs";
+import { isBridgelessEnabled, isNewArchEnabled } from "../../ios/features.mjs";
 import { v } from "../../scripts/helpers.js";
 
 describe("isBridgelessEnabled()", () => {
@@ -69,6 +69,7 @@ describe("isNewArchEnabled()", () => {
     // New architecture is first publicly available in 0.68, but we'll require 0.71
     ok(!isNewArchEnabled({ fabricEnabled: true }, v(0, 70, 999)));
     ok(isNewArchEnabled({ fabricEnabled: true }, firstAvailableVersion));
+    ok(isNewArchEnabled({ newArchEnabled: true }, firstAvailableVersion));
   });
 
   it("returns true if `RCT_NEW_ARCH_ENABLED=1`", () => {

test/pack.test.ts

@@ -154,9 +154,9 @@ describe("npm pack", () => {
       "ios/app.mjs",
       "ios/assetsCatalog.mjs",
       "ios/entitlements.mjs",
+      "ios/features.mjs",
       "ios/infoPlist.mjs",
       "ios/localizations.mjs",
-      "ios/newArch.mjs",
       "ios/pod_helpers.rb",
       "ios/privacyManifest.mjs",
       "ios/test_app.rb",

test/test_pod_helpers.rb

@@ -17,66 +17,6 @@ def test_assert_version
     end
   end
 
-  def test_bridgeless_enabled?
-    ENV.delete('RCT_NEW_ARCH_ENABLED')
-
-    # Bridgeless mode is first publicly available in 0.73
-    available_version = v(0, 73, 0)
-
-    # Bridgeless mode is enabled by default starting with 0.74
-    default_version = v(0, 74, 0)
-
-    refute(bridgeless_enabled?({}, 0))
-    refute(bridgeless_enabled?({}, available_version))
-
-    options = { bridgeless_enabled: true, fabric_enabled: true }
-
-    refute(bridgeless_enabled?(options, v(0, 72, 999)))
-    assert(bridgeless_enabled?(options, available_version))
-
-    # Bridgeless mode is enabled by default starting with 0.74 unless opted-out of
-    assert(bridgeless_enabled?({ fabric_enabled: true }, default_version))
-    refute(bridgeless_enabled?({ bridgeless_enabled: false, fabric_enabled: true },
-                               default_version))
-
-    # `RCT_NEW_ARCH_ENABLED` does not enable bridgeless
-    ENV['RCT_NEW_ARCH_ENABLED'] = '1'
-
-    refute(bridgeless_enabled?({}, v(0, 72, 999)))
-    refute(bridgeless_enabled?({}, available_version))
-    assert(bridgeless_enabled?({}, default_version))
-    refute(bridgeless_enabled?({ bridgeless_enabled: false }, default_version))
-  end
-
-  def test_new_architecture_enabled?
-    ENV.delete('RCT_NEW_ARCH_ENABLED')
-
-    # New architecture is first publicly available in 0.68, but we'll require 0.71
-    available_version = v(0, 71, 0)
-
-    refute(new_architecture_enabled?({}, 0))
-    refute(new_architecture_enabled?({}, available_version))
-
-    # New architecture is first publicly available in 0.68, but we'll require 0.71
-    refute(new_architecture_enabled?({ fabric_enabled: true }, v(0, 70, 999)))
-    assert(new_architecture_enabled?({ fabric_enabled: true }, available_version))
-
-    # `RCT_NEW_ARCH_ENABLED` enables everything
-    ENV['RCT_NEW_ARCH_ENABLED'] = '1'
-
-    refute(new_architecture_enabled?({}, v(0, 70, 999)))
-    assert(new_architecture_enabled?({}, available_version))
-
-    # `RCT_NEW_ARCH_ENABLED` disables everything
-    ENV['RCT_NEW_ARCH_ENABLED'] = '0'
-
-    refute(new_architecture_enabled?({}, v(0, 70, 999)))
-    refute(new_architecture_enabled?({}, available_version))
-    refute(new_architecture_enabled?({ fabric_enabled: true }, available_version))
-
-    ENV.delete('RCT_NEW_ARCH_ENABLED')
-  end
-
   def test_use_hermes?
     options = { path: '../node_modules/react-native' }