Look for magic file in xcframework instead of of node-api.xcframework

Author: kraenhansen

packages/react-native-node-api-modules/.gitignore

@@ -1,2 +1,3 @@
 include/
 hermes/
+vendored-xcframeworks/

packages/react-native-node-api-modules/scripts/find-node-api-xcframeworks.rb

@@ -1,10 +1,11 @@
 def find_node_api_xcframeworks(podfile_path, podspec_path)
-  output = `npx react-native-node-api-modules print-xcframework-paths #{podfile_path}`
+  real_podspec_path = Pathname.new(podspec_path).realpath
+  output = `npx react-native-node-api-modules link-xcframework-paths #{podfile_path}`
   paths = JSON.parse(output)
 
   unless paths.is_a?(Array)
     raise "Expected a list of paths"
   end
 
-  paths.map { |path| Pathname.new(path).relative_path_from(Pathname.new(podspec_path)).to_s }
+  paths.map { |path| Pathname.new(path).relative_path_from(real_podspec_path).to_s }
 end

packages/react-native-node-api-modules/src/cli/index.ts

@@ -5,13 +5,16 @@ import { createRequire } from "node:module";
 
 import { Command } from "@commander-js/extra-typings";
 
-const XCFRAMEWORK_NAME = "node-api.xcframework";
+// Must be in all xcframeworks to be considered as Node-API modules
+const MAGIC_FILENAME = "react-native-node-api-module";
 
 /**
  * Search upwards from a directory to find a package.json and
  * return a list of the resolved paths of all dependencies of that package.
  */
-export function findPackageDependencyPaths(from: string): string[] {
+export function findPackageDependencyPaths(
+  from: string
+): Record<string, string> {
   const candidatePath = path.join(from, "package.json");
   const parentDir = path.dirname(from);
   if (fs.existsSync(candidatePath)) {
@@ -28,19 +31,22 @@ export function findPackageDependencyPaths(from: string): string[] {
       typeof json.dependencies === "object" &&
       json.dependencies !== null
     ) {
-      return Object.keys(json.dependencies)
-        .map((dependencyName) => {
-          try {
-            return path.dirname(
-              require.resolve(`${dependencyName}/package.json`)
-            );
-          } catch {
-            return undefined;
-          }
-        })
-        .filter((p) => typeof p === "string");
+      return Object.fromEntries(
+        Object.keys(json.dependencies)
+          .map((dependencyName) => {
+            try {
+              return [
+                dependencyName,
+                path.dirname(require.resolve(`${dependencyName}/package.json`)),
+              ];
+            } catch {
+              return undefined;
+            }
+          })
+          .filter((item) => typeof item !== "undefined")
+      );
     } else {
-      return [];
+      return {};
     }
   } else if (parentDir === from) {
     throw new Error("package.json not found in any parent directory");
@@ -53,32 +59,73 @@ export function findXCFrameworkPaths(dependencyPath: string): string[] {
   return fs
     .readdirSync(dependencyPath, { withFileTypes: true })
     .flatMap((file) => {
-      if (file.isDirectory()) {
-        if (file.name === XCFRAMEWORK_NAME) {
-          return [path.join(dependencyPath, file.name)];
-        } else {
-          // Traverse into the child directory
-          return findXCFrameworkPaths(path.join(dependencyPath, file.name));
-        }
-      } else {
-        return [];
+      if (
+        file.isFile() &&
+        file.name === MAGIC_FILENAME &&
+        path.extname(dependencyPath) === ".xcframework"
+      ) {
+        return [dependencyPath];
+      } else if (file.isDirectory()) {
+        // Traverse into the child directory
+        return findXCFrameworkPaths(path.join(dependencyPath, file.name));
       }
+      return [];
     });
 }
 
 export const program = new Command("react-native-node-api-modules");
 
 program
-  .command("print-xcframework-paths")
+  .command("link-xcframework-paths")
   .argument("<installation-root>", "Parent directory of the Podfile", (p) =>
     path.resolve(process.cwd(), p)
   )
   .action((installationRoot: string) => {
-    // Find the package.json of the app
-    const dependencyPaths = findPackageDependencyPaths(installationRoot);
-    const xcframeworkPaths = dependencyPaths.flatMap(findXCFrameworkPaths);
-    // Find all node-api.xcframeworks files in the dependencies
-    console.log(JSON.stringify(xcframeworkPaths, null, 2));
+    // Find the location of each dependency
+    const dependencyPathsByName = findPackageDependencyPaths(installationRoot);
+    // Find all their xcframeworks
+    const dependenciesByName = Object.fromEntries(
+      Object.entries(dependencyPathsByName)
+        .map(([dependencyName, dependencyPath]) => {
+          // Make all the xcframeworks relative to the dependency path
+          const xcframeworkPaths = findXCFrameworkPaths(dependencyPath).map(
+            (p) => path.relative(dependencyPath, p)
+          );
+          return [
+            dependencyName,
+            {
+              path: dependencyPath,
+              xcframeworkPaths,
+            },
+          ] as const;
+        })
+        // Remove any dependencies without xcframeworks
+        .filter(([, { xcframeworkPaths }]) => xcframeworkPaths.length > 0)
+    );
+    // To be able to reference the xcframeworks from the Podspec,
+    // we need them as sub-directories of the Podspec parent directory.
+    const outputPath = path.resolve(
+      __dirname,
+      "..",
+      "..",
+      "vendored-xcframeworks"
+    );
+    // Create or clean the output directory
+    fs.rmSync(outputPath, { recursive: true, force: true });
+    fs.mkdirSync(outputPath, { recursive: true });
+    // Create symbolic links for each xcframework found in dependencies
+    const linkedXcframeworkPaths = Object.entries(dependenciesByName).flatMap(
+      ([name, dependency]) => {
+        return dependency.xcframeworkPaths.map((xcframeworkPath) => {
+          const fromPath = path.join(dependency.path, xcframeworkPath);
+          const linkedPath = path.join(outputPath, name, xcframeworkPath);
+          fs.mkdirSync(path.dirname(linkedPath), { recursive: true });
+          fs.symlinkSync(fromPath, linkedPath, "dir");
+          return linkedPath;
+        });
+      }
+    );
+    console.log(JSON.stringify(linkedXcframeworkPaths, null, 2));
   });
 
 export function run(argv: string[]) {