Use Xcode to build frameworks

Author: kraenhansen

package-lock.json

@@ -26,7 +26,8 @@
   "dependencies": {
     "@react-native-node-api/cli-utils": "0.1.0",
     "cmake-file-api": "0.1.0",
-    "react-native-node-api": "0.5.2"
+    "react-native-node-api": "0.5.2",
+    "zod": "^4.1.11"
   },
   "peerDependencies": {
     "node-addon-api": "^8.3.1",

packages/cmake-rn/package.json

@@ -12,20 +12,14 @@ import {
   assertFixable,
   wrapAction,
 } from "@react-native-node-api/cli-utils";
-import { isSupportedTriplet } from "react-native-node-api";
-import * as cmakeFileApi from "cmake-file-api";
 
-import {
-  getCmakeJSVariables,
-  getWeakNodeApiVariables,
-} from "./weak-node-api.js";
 import {
   platforms,
   allTriplets as allTriplets,
   findPlatformForTriplet,
   platformHasTriplet,
 } from "./platforms.js";
-import { BaseOpts, TripletContext, Platform } from "./platforms/types.js";
+import { BaseOpts, Platform } from "./platforms/types.js";
 
 // We're attaching a lot of listeners when spawning in parallel
 EventEmitter.defaultMaxListeners = 100;
@@ -74,7 +68,9 @@ const tripletOption = new Option(
 const buildPathOption = new Option(
   "--build <path>",
   "Specify the build directory to store the configured CMake project",
-);
+)
+  .argParser((input) => path.resolve(process.cwd(), input))
+  .default(path.resolve(process.cwd(), "build"), "./build");
 
 const cleanOption = new Option(
   "--clean",
@@ -84,7 +80,7 @@ const cleanOption = new Option(
 const outPathOption = new Option(
   "--out <path>",
   "Specify the output directory to store the final build artifacts",
-).default(false, "./{build}/{configuration}");
+).default("{build}/{configuration}");
 
 const defineOption = new Option(
   "-D,--define <entry...>",
@@ -151,18 +147,33 @@ for (const platform of platforms) {
   program = platform.amendCommand(program);
 }
 
+function expandTemplate(
+  input: string,
+  values: Record<string, unknown>,
+): string {
+  return input.replaceAll(/{([^}]+)}/g, (_, key: string) =>
+    typeof values[key] === "string" ? values[key] : "",
+  );
+}
+
 program = program.action(
   wrapAction(async ({ triplet: requestedTriplets, ...baseOptions }) => {
+    const buildPath = getBuildPath(baseOptions);
+    baseOptions.out = path.resolve(
+      process.cwd(),
+      expandTemplate(baseOptions.out, baseOptions),
+    );
+    const { verbose, clean, source, out } = baseOptions;
+
     assertFixable(
-      fs.existsSync(path.join(baseOptions.source, "CMakeLists.txt")),
-      `No CMakeLists.txt found in source directory: ${chalk.dim(baseOptions.source)}`,
+      fs.existsSync(path.join(source, "CMakeLists.txt")),
+      `No CMakeLists.txt found in source directory: ${chalk.dim(source)}`,
       {
         instructions: `Change working directory into a directory with a CMakeLists.txt, create one or specify the correct source directory using --source`,
       },
     );
 
-    const buildPath = getBuildPath(baseOptions);
-    if (baseOptions.clean) {
+    if (clean) {
       await fs.promises.rm(buildPath, { recursive: true, force: true });
     }
     const triplets = new Set<string>(requestedTriplets);
@@ -197,31 +208,49 @@ program = program.action(
       }
     }
 
-    if (!baseOptions.out) {
-      baseOptions.out = path.join(buildPath, baseOptions.configuration);
-    }
-
     const tripletContexts = [...triplets].map((triplet) => {
       const platform = findPlatformForTriplet(triplet);
-      const tripletBuildPath = getTripletBuildPath(buildPath, triplet);
+
       return {
         triplet,
         platform,
-        buildPath: tripletBuildPath,
-        outputPath: path.join(tripletBuildPath, "out"),
-        options: baseOptions,
+        async spawn(command: string, args: string[], cwd?: string) {
+          await spawn(command, args, {
+            outputMode: verbose ? "inherit" : "buffered",
+            outputPrefix: verbose ? chalk.dim(`[${triplet}] `) : undefined,
+            cwd,
+          });
+        },
       };
     });
 
     // Configure every triplet project
     const tripletsSummary = chalk.dim(
       `(${getTripletsSummary(tripletContexts)})`,
     );
+
+    // Perform configure steps for each platform in sequence
     await oraPromise(
       Promise.all(
-        tripletContexts.map(({ platform, ...context }) =>
-          configureProject(platform, context, baseOptions),
-        ),
+        platforms.map(async (platform) => {
+          const relevantTriplets = tripletContexts.filter(({ triplet }) =>
+            platformHasTriplet(platform, triplet),
+          );
+          if (relevantTriplets.length > 0) {
+            await platform.configure(
+              relevantTriplets,
+              baseOptions,
+              (command, args, cwd) =>
+                spawn(command, args, {
+                  outputMode: verbose ? "inherit" : "buffered",
+                  outputPrefix: verbose
+                    ? chalk.dim(`[${platform.name}] `)
+                    : undefined,
+                  cwd,
+                }),
+            );
+          }
+        }),
       ),
       {
         text: `Configuring projects ${tripletsSummary}`,
@@ -235,13 +264,14 @@ program = program.action(
     await oraPromise(
       Promise.all(
         tripletContexts.map(async ({ platform, ...context }) => {
-          // Delete any stale build artifacts before building
-          // This is important, since we might rename the output files
-          await fs.promises.rm(context.outputPath, {
-            recursive: true,
-            force: true,
-          });
-          await buildProject(platform, context, baseOptions);
+          // TODO: Consider if this is still important 😬
+          // // Delete any stale build artifacts before building
+          // // This is important, since we might rename the output files
+          // await fs.promises.rm(context.outputPath, {
+          //   recursive: true,
+          //   force: true,
+          // });
+          await platform.build(context, baseOptions);
         }),
       ),
       {
@@ -253,20 +283,15 @@ program = program.action(
     );
 
     // Perform post-build steps for each platform in sequence
+    // console.log("📦 Writing prebuilds to:", prettyPath(out));
     for (const platform of platforms) {
       const relevantTriplets = tripletContexts.filter(({ triplet }) =>
         platformHasTriplet(platform, triplet),
       );
       if (relevantTriplets.length == 0) {
         continue;
       }
-      await platform.postBuild(
-        {
-          outputPath: baseOptions.out || baseOptions.source,
-          triplets: relevantTriplets,
-        },
-        baseOptions,
-      );
+      await platform.postBuild(out, relevantTriplets, baseOptions);
     }
   }),
 );
@@ -293,92 +318,4 @@ function getBuildPath({ build, source }: BaseOpts) {
   return path.resolve(process.cwd(), build || path.join(source, "build"));
 }
 
-/**
- * Namespaces the output path with a triplet name
- */
-function getTripletBuildPath(buildPath: string, triplet: unknown) {
-  assert(typeof triplet === "string", "Expected triplet to be a string");
-  return path.join(buildPath, triplet.replace(/;/g, "_"));
-}
-
-async function configureProject<T extends string>(
-  platform: Platform<T[], Record<string, unknown>>,
-  context: TripletContext<T>,
-  options: BaseOpts,
-) {
-  const { triplet, buildPath, outputPath } = context;
-  const { verbose, source, weakNodeApiLinkage, cmakeJs } = options;
-
-  // TODO: Make the two following definitions a part of the platform definition
-
-  const nodeApiDefinitions =
-    weakNodeApiLinkage && isSupportedTriplet(triplet)
-      ? [getWeakNodeApiVariables(triplet)]
-      : [];
-
-  const cmakeJsDefinitions =
-    cmakeJs && isSupportedTriplet(triplet)
-      ? [getCmakeJSVariables(triplet)]
-      : [];
-
-  const definitions = [
-    ...nodeApiDefinitions,
-    ...cmakeJsDefinitions,
-    ...options.define,
-    { CMAKE_LIBRARY_OUTPUT_DIRECTORY: outputPath },
-  ];
-
-  await cmakeFileApi.createSharedStatelessQuery(buildPath, "codemodel", "2");
-
-  await spawn(
-    "cmake",
-    [
-      "-S",
-      source,
-      "-B",
-      buildPath,
-      ...platform.configureArgs(context, options),
-      ...toDefineArguments(definitions),
-    ],
-    {
-      outputMode: verbose ? "inherit" : "buffered",
-      outputPrefix: verbose ? chalk.dim(`[${triplet}] `) : undefined,
-    },
-  );
-}
-
-async function buildProject<T extends string>(
-  platform: Platform<T[], Record<string, unknown>>,
-  context: TripletContext<T>,
-  options: BaseOpts,
-) {
-  const { triplet, buildPath } = context;
-  const { verbose, configuration } = options;
-  await spawn(
-    "cmake",
-    [
-      "--build",
-      buildPath,
-      "--config",
-      configuration,
-      ...(options.target.length > 0 ? ["--target", ...options.target] : []),
-      "--",
-      ...platform.buildArgs(context, options),
-    ],
-    {
-      outputMode: verbose ? "inherit" : "buffered",
-      outputPrefix: verbose ? chalk.dim(`[${triplet}] `) : undefined,
-    },
-  );
-}
-
-function toDefineArguments(declarations: Array<Record<string, string>>) {
-  return declarations.flatMap((values) =>
-    Object.entries(values).flatMap(([key, definition]) => [
-      "-D",
-      `${key}=${definition}`,
-    ]),
-  );
-}
-
 export { program };

packages/cmake-rn/src/cli.ts

@@ -0,0 +1,8 @@
+export function toDefineArguments(declarations: Array<Record<string, string>>) {
+  return declarations.flatMap((values) =>
+    Object.entries(values).flatMap(([key, definition]) => [
+      "-D",
+      `${key}=${definition}`,
+    ]),
+  );
+}