@callstack/brownfield-cli 3.9.0 → 3.11.0

package/src/brownfield/utils/createLocalSpmPackage.ts

@@ -0,0 +1,208 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import {
+  prepareLocalSpmArtifacts,
+  SPM_ARTIFACTS_DIR_NAME,
+} from './prepareLocalSpmArtifacts.js';
+
+type CreateLocalSpmPackageOptions = {
+  packageDir: string;
+  frameworkName?: string;
+};
+
+type CreateLocalSpmPackageResult = {
+  packageManifestPath: string;
+};
+
+const RESERVED_FRAMEWORK_NAMES = new Set([
+  'hermes',
+  'hermesvm',
+  'ReactBrownfield',
+  'Brownie',
+  'BrownfieldNavigation',
+  'React',
+  'ReactNativeDependencies',
+]);
+
+function requireXcframework(packageDir: string, name: string) {
+  const xcframeworkPath = path.join(packageDir, `${name}.xcframework`);
+
+  if (!fs.existsSync(xcframeworkPath)) {
+    throw new Error(`Missing required XCFramework: ${name}.xcframework`);
+  }
+
+  return name;
+}
+
+function optionalXcframework(packageDir: string, name: string) {
+  return fs.existsSync(path.join(packageDir, `${name}.xcframework`))
+    ? name
+    : null;
+}
+
+function requireHermesXcframework(packageDir: string) {
+  return (
+    optionalXcframework(packageDir, 'hermesvm') ??
+    requireXcframework(packageDir, 'hermes')
+  );
+}
+
+function resolveAppFrameworkName(
+  packageDir: string,
+  explicitFrameworkName?: string
+) {
+  if (explicitFrameworkName) {
+    return requireXcframework(packageDir, explicitFrameworkName);
+  }
+
+  const candidates = fs
+    .readdirSync(packageDir, { withFileTypes: true })
+    .filter(
+      (entry) =>
+        entry.isDirectory() &&
+        entry.name.endsWith('.xcframework') &&
+        !RESERVED_FRAMEWORK_NAMES.has(path.basename(entry.name, '.xcframework'))
+    )
+    .map((entry) => path.basename(entry.name, '.xcframework'))
+    .sort();
+
+  if (candidates.length === 1 && candidates[0]) {
+    return candidates[0];
+  }
+
+  if (candidates.length === 0) {
+    throw new Error(
+      'Could not resolve the packaged app XCFramework automatically. Pass --scheme explicitly when packaging.'
+    );
+  }
+
+  throw new Error(
+    `Found multiple packaged app XCFramework candidates (${candidates.join(', ')}). Pass --scheme explicitly when packaging.`
+  );
+}
+
+function renderPackageSwift({
+  packageName,
+  libraryName,
+  targetNames,
+}: {
+  packageName: string;
+  libraryName: string;
+  targetNames: string[];
+}) {
+  const binaryTargets = targetNames
+    .map(
+      (targetName) =>
+        `    .binaryTarget(name: "${targetName}", path: "./${SPM_ARTIFACTS_DIR_NAME}/${targetName}.xcframework")`
+    )
+    .join(',\n');
+
+  const targetDependencies = targetNames
+    .map((targetName) => `"${targetName}"`)
+    .join(', ');
+
+  return `// swift-tools-version: 5.9
+
+import PackageDescription
+
+let package = Package(
+  name: "${packageName}",
+  platforms: [
+    .iOS(.v14),
+  ],
+  products: [
+    .library(name: "${libraryName}", targets: [${targetDependencies}]),
+  ],
+  targets: [
+${binaryTargets}
+  ]
+)
+`;
+}
+
+function renderReadme({
+  packageName,
+  libraryName,
+  targetNames,
+}: {
+  packageName: string;
+  libraryName: string;
+  targetNames: string[];
+}) {
+  const frameworks = targetNames.map((targetName) => `- \`${targetName}\``).join('\n');
+
+  return `# ${packageName}
+
+This is a generated local Swift Package Manager package for the packaged React Native brownfield artifacts.
+
+## Product
+
+- Library product: \`${libraryName}\`
+
+## Included Binary Targets
+
+${frameworks}
+
+## How To Use
+
+1. In Xcode, choose **File > Add Package Dependencies...**
+2. Click **Add Local...**
+3. Select this folder, the one containing \`Package.swift\` and the \`spm-artifacts\` directory
+4. Add the \`${libraryName}\` library product to your app target
+
+## Troubleshooting
+
+If Xcode builds your host app but the simulator installation fails, check the host app target first:
+
+- Make sure the target still includes its app entry point source files, such as \`App.swift\`, \`SceneDelegate\`, \`AppDelegate\`, or equivalent startup files
+- Make sure the host target uses the same React Native module name that the packaged app registers for its brownfield surface. This repo's example apps use \`RNApp\` for both the plain React Native and Expo variants
+- If the install error says the app is "missing its bundle executable", the host app target produced an invalid \`.app\` bundle and the issue is not in this generated SPM package
+- If you are migrating an existing target from direct \`*.xcframework\` linking to local SPM, remove the old direct XCFramework references before building again
+
+This folder is generated by \`brownfield package:ios --add-spm-package\`. Re-run that command whenever the packaged XCFrameworks change so this package stays in sync.
+`;
+}
+
+export function createLocalSpmPackage({
+  packageDir,
+  frameworkName,
+}: CreateLocalSpmPackageOptions): CreateLocalSpmPackageResult {
+  const resolvedFrameworkName = resolveAppFrameworkName(
+    packageDir,
+    frameworkName
+  );
+  const targetNames = [
+    resolvedFrameworkName,
+    requireHermesXcframework(packageDir),
+    requireXcframework(packageDir, 'ReactBrownfield'),
+    optionalXcframework(packageDir, 'Brownie'),
+    optionalXcframework(packageDir, 'BrownfieldNavigation'),
+    optionalXcframework(packageDir, 'React'),
+    optionalXcframework(packageDir, 'ReactNativeDependencies'),
+  ].filter((targetName): targetName is string => targetName !== null);
+
+  const packageManifestPath = path.join(packageDir, 'Package.swift');
+  const readmePath = path.join(packageDir, 'README.md');
+  prepareLocalSpmArtifacts({
+    packageDir,
+    targetNames,
+  });
+  const manifest = renderPackageSwift({
+    packageName: `${resolvedFrameworkName}Package`,
+    libraryName: resolvedFrameworkName,
+    targetNames,
+  });
+  const readme = renderReadme({
+    packageName: `${resolvedFrameworkName}Package`,
+    libraryName: resolvedFrameworkName,
+    targetNames,
+  });
+
+  fs.writeFileSync(packageManifestPath, manifest, 'utf8');
+  fs.writeFileSync(readmePath, readme, 'utf8');
+
+  return {
+    packageManifestPath,
+  };
+}

package/src/brownfield/utils/prepareLocalSpmArtifacts.ts

@@ -0,0 +1,117 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+
+type PrepareLocalSpmArtifactsOptions = {
+  packageDir: string;
+  targetNames: string[];
+};
+
+export const SPM_ARTIFACTS_DIR_NAME = 'spm-artifacts';
+
+function removeCodeSignatureArtifacts(dirPath: string) {
+  for (const entry of fs.readdirSync(dirPath, { withFileTypes: true })) {
+    const entryPath = path.join(dirPath, entry.name);
+
+    if (entry.isDirectory()) {
+      if (entry.name === '_CodeSignature') {
+        fs.rmSync(entryPath, { recursive: true, force: true });
+        continue;
+      }
+
+      removeCodeSignatureArtifacts(entryPath);
+      continue;
+    }
+
+    if (entry.name === 'CodeResources') {
+      fs.rmSync(entryPath, { force: true });
+    }
+  }
+}
+
+function resolveFrameworkExecutablePath(
+  frameworkDir: string,
+  frameworkName: string
+) {
+  const directExecutablePath = path.join(frameworkDir, frameworkName);
+  if (fs.existsSync(directExecutablePath)) {
+    return directExecutablePath;
+  }
+
+  const versionedExecutablePath = path.join(
+    frameworkDir,
+    'Versions',
+    'Current',
+    frameworkName
+  );
+  if (fs.existsSync(versionedExecutablePath)) {
+    return versionedExecutablePath;
+  }
+
+  return null;
+}
+
+function removeExecutableSignature(executablePath: string) {
+  try {
+    execFileSync('codesign', ['--remove-signature', executablePath], {
+      stdio: 'pipe',
+    });
+  } catch (error) {
+    if (
+      error instanceof Error &&
+      error.message.includes('code object is not signed at all')
+    ) {
+      return;
+    }
+
+    throw error;
+  }
+}
+
+function normalizeCopiedXcframeworkSignature(xcframeworkPath: string) {
+  removeCodeSignatureArtifacts(xcframeworkPath);
+
+  for (const sliceName of fs.readdirSync(xcframeworkPath)) {
+    const slicePath = path.join(xcframeworkPath, sliceName);
+    if (!fs.statSync(slicePath).isDirectory()) {
+      continue;
+    }
+
+    for (const entry of fs.readdirSync(slicePath)) {
+      if (!entry.endsWith('.framework')) {
+        continue;
+      }
+
+      const frameworkName = path.basename(entry, '.framework');
+      const frameworkDir = path.join(slicePath, entry);
+      const executablePath = resolveFrameworkExecutablePath(
+        frameworkDir,
+        frameworkName
+      );
+
+      if (executablePath) {
+        removeExecutableSignature(executablePath);
+      }
+    }
+  }
+}
+
+export function prepareLocalSpmArtifacts({
+  packageDir,
+  targetNames,
+}: PrepareLocalSpmArtifactsOptions) {
+  const spmArtifactsDir = path.join(packageDir, SPM_ARTIFACTS_DIR_NAME);
+
+  fs.rmSync(spmArtifactsDir, { recursive: true, force: true });
+  fs.mkdirSync(spmArtifactsDir, { recursive: true });
+
+  for (const targetName of targetNames) {
+    const sourcePath = path.join(packageDir, `${targetName}.xcframework`);
+    const destinationPath = path.join(spmArtifactsDir, `${targetName}.xcframework`);
+
+    fs.renameSync(sourcePath, destinationPath);
+    normalizeCopiedXcframeworkSignature(destinationPath);
+  }
+
+  return spmArtifactsDir;
+}

package/src/brownfield/utils/project.ts

@@ -56,6 +56,15 @@ export function isExpoProject(projectRoot: string): boolean {
   return hasExpoConfig && dependsOnExpo;
 }
 
+export function getExpoSdkMajor(projectRoot: string): number | null {
+  const rawExpoVersion = getExpoConfigIfIsExpo(projectRoot)?.exp.sdkVersion;
+  if (!rawExpoVersion) {
+    return null;
+  }
+  const expoSdkMajor = parseInt(rawExpoVersion.split('.')[0], 10);
+  return Number.isFinite(expoSdkMajor) ? expoSdkMajor : null;
+}
+
 /**
  * Fills the RNC CLI project config from the Expo config by mutating the passed in `options.projectConfig` object in place
  */

package/src/brownfield/utils/resolvePackagedFrameworkName.ts

@@ -0,0 +1,98 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+type Resolution = 'explicit' | 'detected' | 'not_found' | 'ambiguous';
+
+export interface ResolvePackagedFrameworkNameResult {
+  frameworkName: string | null;
+  resolution: Resolution;
+  candidates?: string[];
+}
+
+interface ResolvePackagedFrameworkNameOptions {
+  explicitScheme?: string;
+  productsPath: string;
+  configuration: string;
+}
+
+function collectFrameworkCandidates(configurationProductsPath: string): string[] {
+  if (!fs.existsSync(configurationProductsPath)) {
+    return [];
+  }
+
+  const discoveredFrameworks = new Set<string>();
+
+  for (const entry of fs.readdirSync(configurationProductsPath, { withFileTypes: true })) {
+    const entryPath = path.join(configurationProductsPath, entry.name);
+
+    if (entry.isDirectory() && entry.name.endsWith('.framework')) {
+      const frameworkName = path.basename(entry.name, '.framework');
+      const bundlePath = path.join(entryPath, 'main.jsbundle');
+
+      if (fs.existsSync(bundlePath)) {
+        discoveredFrameworks.add(frameworkName);
+      }
+
+      continue;
+    }
+
+    if (!entry.isDirectory()) {
+      continue;
+    }
+
+    for (const nestedEntry of fs.readdirSync(entryPath, { withFileTypes: true })) {
+      if (!nestedEntry.isDirectory() || !nestedEntry.name.endsWith('.framework')) {
+        continue;
+      }
+
+      const frameworkName = path.basename(nestedEntry.name, '.framework');
+      const bundlePath = path.join(entryPath, nestedEntry.name, 'main.jsbundle');
+
+      if (fs.existsSync(bundlePath)) {
+        discoveredFrameworks.add(frameworkName);
+      }
+    }
+  }
+
+  return [...discoveredFrameworks].sort();
+}
+
+export function resolvePackagedFrameworkName({
+  explicitScheme,
+  productsPath,
+  configuration,
+}: ResolvePackagedFrameworkNameOptions): ResolvePackagedFrameworkNameResult {
+  if (explicitScheme) {
+    return {
+      frameworkName: explicitScheme,
+      resolution: 'explicit',
+    };
+  }
+
+  const configurationProductsPath = path.join(
+    productsPath,
+    `${configuration}-iphoneos`
+  );
+  const candidates = collectFrameworkCandidates(configurationProductsPath);
+
+  if (candidates.length === 1) {
+    return {
+      frameworkName: candidates[0] ?? null,
+      resolution: 'detected',
+    };
+  }
+
+  if (candidates.length === 0) {
+    return {
+      frameworkName: null,
+      resolution: 'not_found',
+      candidates,
+    };
+  }
+
+  return {
+    frameworkName: null,
+    resolution: 'ambiguous',
+    candidates,
+  };
+}

package/src/brownfield/utils/supportsPrebuiltRNCore.ts

@@ -0,0 +1,67 @@
+import { getReactNativeVersion, versionCompare } from '@rock-js/tools';
+
+import { getExpoSdkMajor, isExpoProject } from './project.js';
+
+/** Minimum RN version that can opt in to prebuilts via `--use-prebuilt-rn-core`. */
+export const MIN_REACT_NATIVE_VERSION_FOR_OPT_IN_PREBUILT_RN_CORE = '0.81.0';
+/** Minimum RN version where Brownfield enables prebuilts by default (vanilla projects). */
+export const MIN_REACT_NATIVE_VERSION_FOR_PREBUILT_RN_CORE_BY_DEFAULT =
+  '0.84.0';
+export const MIN_EXPO_SDK_MAJOR_FOR_PREBUILT_RN_CORE_BY_DEFAULT = 55;
+
+export type PrebuiltRNCoreSupportResult =
+  | { supported: true; enabledByDefault: boolean; reason?: never }
+  | { supported: false; enabledByDefault?: never; reason: string };
+
+export function supportsPrebuiltRNCore({
+  projectRoot,
+}: {
+  projectRoot: string;
+}): PrebuiltRNCoreSupportResult {
+  const reactNativeVersion = getReactNativeVersion(projectRoot);
+
+  if (reactNativeVersion === 'unknown') {
+    return {
+      supported: false,
+      reason:
+        'Cannot use --use-prebuilt-rn-core: unable to resolve the installed react-native version.',
+    };
+  }
+
+  if (
+    versionCompare(
+      reactNativeVersion,
+      MIN_REACT_NATIVE_VERSION_FOR_OPT_IN_PREBUILT_RN_CORE
+    ) < 0
+  ) {
+    return {
+      supported: false,
+      reason: `--use-prebuilt-rn-core requires React Native ${MIN_REACT_NATIVE_VERSION_FOR_OPT_IN_PREBUILT_RN_CORE} or newer (found ${reactNativeVersion}).`,
+    };
+  }
+
+  if (isExpoProject(projectRoot)) {
+    const expoSdkMajor = getExpoSdkMajor(projectRoot);
+
+    if (
+      expoSdkMajor === null ||
+      expoSdkMajor < MIN_EXPO_SDK_MAJOR_FOR_PREBUILT_RN_CORE_BY_DEFAULT
+    ) {
+      const sdkLabel = expoSdkMajor === null ? 'unknown' : String(expoSdkMajor);
+      return {
+        supported: false,
+        reason: `--use-prebuilt-rn-core is unsupported in Expo SDK ${sdkLabel}: packaging brownfield with prebuilts requires Expo SDK ${MIN_EXPO_SDK_MAJOR_FOR_PREBUILT_RN_CORE_BY_DEFAULT} or newer.`,
+      };
+    }
+
+    return { supported: true, enabledByDefault: true };
+  }
+
+  const enabledByDefault =
+    versionCompare(
+      reactNativeVersion,
+      MIN_REACT_NATIVE_VERSION_FOR_PREBUILT_RN_CORE_BY_DEFAULT
+    ) >= 0;
+
+  return { supported: true, enabledByDefault };
+}