Refactor to call createAppleFramework with versioned: true for Darwin

Author: kraenhansen

packages/ferric/src/build.ts

@@ -31,9 +31,11 @@ import {
   ANDROID_TARGETS,
   AndroidTargetName,
   APPLE_TARGETS,
+  AppleOperatingSystem,
   AppleTargetName,
   ensureAvailableTargets,
   filterTargetsByPlatform,
+  parseAppleTargetName,
 } from "./targets.js";
 import { generateTypeScriptDeclarations } from "./napi-rs.js";
 import { getBlockComment } from "./banner.js";
@@ -299,16 +301,16 @@ export const buildCommand = new Command("build")
         }
 
         if (appleLibraries.length > 0) {
-          const libraryPaths = await combineLibraries(appleLibraries);
+          const libraries = await combineAppleLibraries(appleLibraries);
 
           const frameworkPaths = await oraPromise(
             Promise.all(
-              libraryPaths.map((libraryPath) =>
+              libraries.map((library) =>
                 limit(() =>
-                  // TODO: Pass true as `versioned` argument for -darwin targets
                   createAppleFramework({
-                    libraryPath,
+                    libraryPath: library.path,
                     bundleIdentifier: appleBundleIdentifier,
+                    versioned: library.os === "darwin",
                   }),
                 ),
               ),
@@ -389,16 +391,23 @@ export const buildCommand = new Command("build")
     ),
   );
 
-async function createUniversalAppleLibraries(libraryPathGroups: string[][]) {
+async function createUniversalAppleLibraries(
+  groups: { os: AppleOperatingSystem; paths: string[] }[],
+): Promise<{ os: AppleOperatingSystem; path: string }[]> {
   const result = await oraPromise(
     Promise.all(
-      libraryPathGroups.map(async (libraryPaths) => {
-        if (libraryPaths.length === 0) {
+      groups.map(async ({ os, paths }) => {
+        if (paths.length === 0) {
           return [];
-        } else if (libraryPaths.length === 1) {
-          return libraryPaths;
+        } else if (paths.length == 1) {
+          return [{ os, path: paths[0] }];
         } else {
-          return [await createUniversalAppleLibrary(libraryPaths)];
+          return [
+            {
+              os,
+              path: await createUniversalAppleLibrary(paths),
+            },
+          ];
         }
       }),
     ),
@@ -412,15 +421,21 @@ async function createUniversalAppleLibraries(libraryPathGroups: string[][]) {
   return result.flat();
 }
 
-async function combineLibraries(
+type CombinedAppleLibrary = {
+  path: string;
+  os: AppleOperatingSystem;
+};
+
+async function combineAppleLibraries(
   libraries: Readonly<[AppleTargetName, string]>[],
-): Promise<string[]> {
+): Promise<CombinedAppleLibrary[]> {
   const result = [];
   const darwinLibraries = [];
   const iosSimulatorLibraries = [];
   const tvosSimulatorLibraries = [];
   for (const [target, libraryPath] of libraries) {
-    if (target.endsWith("-darwin")) {
+    const { os } = parseAppleTargetName(target);
+    if (os === "darwin") {
       darwinLibraries.push(libraryPath);
     } else if (
       target === "aarch64-apple-ios-sim" ||
@@ -433,14 +448,14 @@ async function combineLibraries(
     ) {
       tvosSimulatorLibraries.push(libraryPath);
     } else {
-      result.push(libraryPath);
+      result.push({ os, path: libraryPath });
     }
   }
 
   const combinedLibraryPaths = await createUniversalAppleLibraries([
-    darwinLibraries,
-    iosSimulatorLibraries,
-    tvosSimulatorLibraries,
+    { os: "darwin", paths: darwinLibraries },
+    { os: "ios", paths: iosSimulatorLibraries },
+    { os: "tvos", paths: tvosSimulatorLibraries },
   ]);
 
   return [...result, ...combinedLibraryPaths];

packages/ferric/src/targets.ts

@@ -1,3 +1,4 @@
+import assert from "node:assert";
 import cp from "node:child_process";
 
 import { assertFixable } from "@react-native-node-api/cli-utils";
@@ -48,6 +49,65 @@ export const APPLE_TARGETS = [
 ] as const;
 export type AppleTargetName = (typeof APPLE_TARGETS)[number];
 
+const APPLE_ARCHITECTURES = [
+  "aarch64",
+  "arm64_32",
+  "arm64e",
+  "armv7",
+  "armv7s",
+  "x86_64",
+  "x86_64h",
+  "i386",
+  "i686",
+] as const;
+export type AppleArchitecture = (typeof APPLE_ARCHITECTURES)[number];
+export function isAppleArchitecture(
+  architecture: string,
+): architecture is AppleArchitecture {
+  return (APPLE_ARCHITECTURES as readonly string[]).includes(architecture);
+}
+
+const APPLE_OPERATING_SYSTEMS = [
+  "darwin",
+  "ios",
+  "tvos",
+  "visionos",
+  "watchos",
+] as const;
+export type AppleOperatingSystem = (typeof APPLE_OPERATING_SYSTEMS)[number];
+export function isAppleOperatingSystem(os: string): os is AppleOperatingSystem {
+  return (APPLE_OPERATING_SYSTEMS as readonly string[]).includes(os);
+}
+
+const APPLE_VARIANTS = ["sim", "macabi"] as const;
+export type AppleVariant = (typeof APPLE_VARIANTS)[number];
+export function isAppleVariant(variant: string): variant is AppleVariant {
+  return (APPLE_VARIANTS as readonly string[]).includes(variant);
+}
+
+export function parseAppleTargetName(target: AppleTargetName): {
+  architecture: AppleArchitecture;
+  os: AppleOperatingSystem;
+  variant?: AppleVariant;
+} {
+  const [architecture, vendor, os, variant] = target.split("-");
+  assert(vendor === "apple", "Expected vendor to be apple");
+  assert(
+    isAppleArchitecture(architecture),
+    `Unexpected architecture: ${architecture}`,
+  );
+  assert(isAppleOperatingSystem(os), `Unexpected operating system: ${os}`);
+  assert(
+    typeof variant === "undefined" || isAppleVariant(variant),
+    `Unexpected variant: ${variant}`,
+  );
+  return {
+    architecture,
+    os,
+    variant,
+  };
+}
+
 export const ALL_TARGETS = [...ANDROID_TARGETS, ...APPLE_TARGETS] as const;
 export type TargetName = (typeof ALL_TARGETS)[number];