refactor(apple): move host and autolinking resolution to JS (#2428)

Author: tido64

ios/app.mjs

@@ -8,6 +8,7 @@ import {
   isMain,
   readTextFile,
   toVersionNumber,
+  v,
 } from "../scripts/helpers.js";
 import { cp_r, mkdir_p, rm_r } from "../scripts/utils/filesystem.mjs";
 import { generateAssetsCatalogs } from "./assetsCatalog.mjs";
@@ -16,7 +17,7 @@ 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 } from "./utils.mjs";
+import { isObject, isString, projectPath, resolveResources } from "./utils.mjs";
 import {
   PRODUCT_DISPLAY_NAME,
   PRODUCT_VERSION,
@@ -66,6 +67,45 @@ function exportNodeBinaryPath(projectRoot, destination, fs = nodefs) {
   );
 }
 
+/**
+ * @param {string} reactNativePath
+ * @param {number} reactNativeVersion
+ * @returns {string | undefined}
+ */
+function findCommunityAutolinkingScriptPath(
+  reactNativePath,
+  reactNativeVersion,
+  fs = nodefs
+) {
+  // As of 0.75, we should use `use_native_modules!` from `react-native` instead
+  if (reactNativeVersion < v(0, 75, 0)) {
+    const pkgPath = findFile(
+      "node_modules/@react-native-community/cli-platform-ios",
+      reactNativePath,
+      fs
+    );
+    if (pkgPath) {
+      return path.join(pkgPath, "native_modules.rb");
+    }
+  }
+
+  return undefined;
+}
+
+/**
+ * @param {string} projectRoot
+ * @returns {string}
+ */
+function findReactNativeHostPath(projectRoot, fs = nodefs) {
+  const dir = fileURLToPath(import.meta.url);
+  const rnhPath = findFile("node_modules/@rnx-kit/react-native-host", dir, fs);
+  if (!rnhPath) {
+    throw new Error("Cannot find module '@rnx-kit/react-native-host'");
+  }
+
+  return path.relative(projectRoot, rnhPath);
+}
+
 /**
  * @param {JSONValue} platformConfig
  * @param {string} projectRoot
@@ -188,11 +228,20 @@ export function generateProject(
     xcodeprojPath: path.resolve(xcodeprojDst),
     reactNativePath: path.resolve(reactNativePath),
     reactNativeVersion,
+    reactNativeHostPath: findReactNativeHostPath(projectRoot, fs),
+    communityAutolinkingScriptPath: findCommunityAutolinkingScriptPath(
+      reactNativePath,
+      reactNativeVersion,
+      fs
+    ),
     useNewArch,
     useBridgeless,
     buildSettings: {},
     testsBuildSettings: {},
     uitestsBuildSettings: {},
+    resources: resolveResources(appConfig, targetPlatform)?.filter(
+      (item) => typeof item === "string"
+    ),
   };
 
   applyBuildSettings(platformConfig, project, projectRoot, destination, fs);

ios/pod_helpers.rb

@@ -1,15 +1,5 @@
 require('json')
 
-def app_manifest(project_root)
-  @app_manifest ||= {}
-  return @app_manifest[project_root] if @app_manifest.key?(project_root)
-
-  manifest_path = find_file('app.json', project_root)
-  return if manifest_path.nil?
-
-  @app_manifest[project_root] = JSON.parse(File.read(manifest_path))
-end
-
 def assert(condition, message)
   raise message unless condition
 end
@@ -50,41 +40,10 @@ def new_architecture_enabled?(options, react_native_version)
   ENV.fetch('RCT_NEW_ARCH_ENABLED', options[:fabric_enabled] ? '1' : '0') != '0'
 end
 
-def resolve_module(request, start_dir = Pod::Config.instance.installation_root)
-  @module_cache ||= {}
-  return @module_cache[request] if @module_cache.key?(request)
-
-  @module_cache[request] = resolve_module_uncached(request, start_dir).to_s
-end
-
-def resolve_module_relative(request)
-  path = resolve_module_uncached(request, Pathname.new(__dir__))
-  path.relative_path_from(Pod::Config.instance.installation_root).to_s
-end
-
-def resolve_module_uncached(request, start_dir)
-  # Always resolve `start_dir` as it may be a symlink
-  package_json = find_file("node_modules/#{request}/package.json", start_dir.realdirpath)
-  raise "Cannot find module '#{request}'" if package_json.nil?
-
-  package_json.dirname
-end
-
-def resolve_resources(manifest, target_platform)
-  resources = manifest['resources']
-  return if !resources || resources.empty?
-
-  resources.instance_of?(Array) ? resources : resources[target_platform.to_s]
-end
-
 def supports_new_architecture?(react_native_version)
   react_native_version.zero? || react_native_version >= v(0, 71, 0)
 end
 
-def try_pod(name, podspec, project_root)
-  pod name, :podspec => podspec if File.exist?(File.join(project_root, podspec))
-end
-
 def use_hermes?(options)
   use_hermes = ENV.fetch('USE_HERMES', nil)
   return use_hermes == '1' unless use_hermes.nil?

ios/test_app.rb

@@ -14,28 +14,15 @@
 WARNING_CFLAGS = 'WARNING_CFLAGS'.freeze
 
 def apply_config_plugins(project_root, target_platform)
-  begin
-    resolve_module('@expo/config-plugins')
-  rescue StandardError
-    # Skip if `@expo/config-plugins` cannot be found
-    return
-  end
+  # Skip if `@expo/config-plugins` cannot be found
+  config_plugins_dir = find_file('node_modules/@expo/config-plugins', project_root)
+  return if config_plugins_dir.nil?
 
   apply_config_plugins = File.join(__dir__, '..', 'scripts', 'apply-config-plugins.mjs')
   result = system("node \"#{apply_config_plugins}\" \"#{project_root}\" --#{target_platform}")
   raise 'Failed to apply config plugins' unless result
 end
 
-def autolink_script_path(project_root, react_native_path, react_native_version)
-  start_dir = if react_native_version >= v(0, 76, 0)
-                project_root
-              else
-                react_native_path
-              end
-  package_path = resolve_module('@react-native-community/cli-platform-ios', start_dir)
-  File.join(package_path, 'native_modules')
-end
-
 def target_product_type(target)
   target.product_type if target.respond_to?(:product_type)
 end
@@ -79,13 +66,13 @@ def validate_resources(resources, app_dir)
   resources
 end
 
-def resources_pod(project_root, target_platform, platforms)
+def resources_pod(project_root, platforms, resources)
+  return if resources.nil? || resources.empty?
+
   app_manifest = find_file('app.json', project_root)
   return if app_manifest.nil?
 
   app_dir = File.dirname(app_manifest)
-  resources = resolve_resources(app_manifest(project_root), target_platform)
-  return if resources.nil? || resources.empty?
 
   spec = {
     'name' => 'ReactTestApp-Resources',
@@ -175,9 +162,12 @@ def make_project!(project_root, target_platform, options)
     },
     :react_native_path => project['reactNativePath'],
     :react_native_version => project['reactNativeVersion'],
+    :react_native_host_path => project['reactNativeHostPath'],
+    :community_autolinking_script_path => project['communityAutolinkingScriptPath'],
     :use_new_arch => project['useNewArch'],
     :code_sign_identity => build_settings[CODE_SIGN_IDENTITY] || '',
     :development_team => build_settings[DEVELOPMENT_TEAM] || '',
+    :resources => project['resources'],
   }
 end
 
@@ -198,8 +188,8 @@ def use_test_app_internal!(target_platform, options)
   end
 
   # As of 0.75, we should use `use_native_modules!` from `react-native` instead
-  if react_native_version < v(0, 75, 0)
-    require_relative(autolink_script_path(project_root, react_native_path, react_native_version))
+  if project_target[:community_autolinking_script_path].is_a? String
+    require_relative(project_target[:community_autolinking_script_path])
   end
 
   begin
@@ -220,9 +210,9 @@ def use_test_app_internal!(target_platform, options)
                                                   react_native_version,
                                                   options)
 
-    pod 'ReactNativeHost', :path => resolve_module_relative('@rnx-kit/react-native-host')
+    pod 'ReactNativeHost', :path => project_target[:react_native_host_path]
 
-    if (resources_pod_path = resources_pod(project_root, target_platform, platforms))
+    if (resources_pod_path = resources_pod(project_root, platforms, project_target[:resources]))
       pod 'ReactTestApp-Resources', :path => resources_pod_path
     end
 

scripts/types.ts

@@ -136,12 +136,15 @@ export type ProjectConfiguration = {
   xcodeprojPath: string;
   reactNativePath: string;
   reactNativeVersion: number;
+  reactNativeHostPath: string;
+  communityAutolinkingScriptPath?: string;
   singleApp?: string;
   useNewArch: boolean;
   useBridgeless: boolean;
   buildSettings: Record<string, string | string[]>;
   testsBuildSettings: Record<string, string>;
   uitestsBuildSettings: Record<string, string>;
+  resources?: string[];
 };
 
 export type XmlOptions = Pick<