@callstack/brownfield-cli 3.9.0 → 3.11.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @callstack/brownfield-cli
 
+## 3.11.0
+
+### Minor Changes
+
+- [#358](https://github.com/callstack/react-native-brownfield/pull/358) [`3715ac7`](https://github.com/callstack/react-native-brownfield/commit/3715ac7783000756ef1c66ecfe24a85c5e43abab) Thanks [@adamTrz](https://github.com/adamTrz)! - Add `--add-spm-package` to `brownfield package:ios` so packaging can also generate a local Swift Package Manager wrapper around the produced XCFrameworks, including a generated `Package.swift`, `README.md`, and Xcode integration instructions. Fail fast when Debug packaging cannot resolve the app framework name while local SPM output is requested.
+
+- [#364](https://github.com/callstack/react-native-brownfield/pull/364) [`05c557d`](https://github.com/callstack/react-native-brownfield/commit/05c557da9e2b6fca02e6e1a0b0fe71a909bab15f) Thanks [@hurali97](https://github.com/hurali97)! - keep only one reference of xcframeworks when spm enabled
+
+## 3.10.0
+
+### Minor Changes
+
+- [#323](https://github.com/callstack/react-native-brownfield/pull/323) [`3456d3a`](https://github.com/callstack/react-native-brownfield/commit/3456d3aded18002475def4b79889979e76e1db5e) Thanks [@artus9033](https://github.com/artus9033)! - Support RN prebuilts in Brownfield, by default enabled in RN >= 0.84, opt-in in RN 0.83; or in Expo 55+ (Expo 54 is not supported).
+
+  Add `--use-prebuilt-rn-core` to `brownfield package:ios` so callers can opt into or out of React Native Apple prebuilt binaries; omitting the flag defers to version-aware defaults handled by Rock. The CLI rejects `--use-prebuilt-rn-core` when React Native is older than 0.81 or when the project is Expo SDK older than 55.
+
+  Fix brownfield framework dylib install names to use @rpath instead of hardcoded paths.
+
 ## 3.9.0
 
 ### Minor Changes

package/dist/brownfield/commands/packageIos.d.ts

@@ -1,5 +1,6 @@
 import { Command } from 'commander';
 import { ExampleUsage } from '../../shared/index.js';
+export declare function parseUsePrebuiltRnCoreArgument(value: string | boolean): boolean;
 export declare const packageIosCommand: Command;
 export declare const packageIosExample: ExampleUsage;
 //# sourceMappingURL=packageIos.d.ts.map

package/dist/brownfield/commands/packageIos.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"packageIos.d.ts","sourceRoot":"","sources":["../../../src/brownfield/commands/packageIos.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIpC,OAAO,EAGL,YAAY,EACb,MAAM,uBAAuB,CAAC;AAK/B,eAAO,MAAM,iBAAiB,SAgJ7B,CAAC;AAEF,eAAO,MAAM,iBAAiB,cAG7B,CAAC"}
+{"version":3,"file":"packageIos.d.ts","sourceRoot":"","sources":["../../../src/brownfield/commands/packageIos.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,OAAO,EAAU,MAAM,WAAW,CAAC;AAK5C,OAAO,EAGL,YAAY,EACb,MAAM,uBAAuB,CAAC;AAe/B,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,MAAM,GAAG,OAAO,GACtB,OAAO,CAcT;AAqBD,eAAO,MAAM,iBAAiB,SA8P3B,CAAC;AAEJ,eAAO,MAAM,iBAAiB,cAG7B,CAAC"}

package/dist/brownfield/commands/packageIos.js

@@ -2,22 +2,69 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { getBuildOptions, mergeFrameworks, } from '@rock-js/platform-apple-helpers';
 import { packageIosAction } from '@rock-js/plugin-brownfield-ios';
-import { colorLink, getReactNativeVersion, logger, relativeToCwd, } from '@rock-js/tools';
-import { Command } from 'commander';
+import { RockError, colorLink, getReactNativeVersion, logger, relativeToCwd, } from '@rock-js/tools';
+import { Command, Option } from 'commander';
 import { runExpoPrebuildIfNeeded } from '../utils/expo.js';
 import { getProjectInfo } from '../utils/project.js';
+import { supportsPrebuiltRNCore } from '../utils/supportsPrebuiltRNCore.js';
 import { actionRunner, curryOptions, ExampleUsage, } from '../../shared/index.js';
 import { runBrownieCodegenIfApplicable } from '../../brownie/helpers/runBrownieCodegenIfApplicable.js';
 import { runNavigationCodegenIfApplicable } from '../../navigation/helpers/runNavigationCodegenIfApplicable.js';
+import { copyDebugBundleToSimulatorSlice } from '../utils/copyDebugBundleToSimulatorSlice.js';
+import { resolvePackagedFrameworkName } from '../utils/resolvePackagedFrameworkName.js';
 import { stripFrameworkBinary } from '../utils/stripFrameworkBinary.js';
+import { createLocalSpmPackage } from '../utils/createLocalSpmPackage.js';
+/** Help text for `--use-prebuilt-rn-core` (keep in sync with docs/docs/docs/getting-started/ios.mdx, "React Native Prebuilts" section). */
+const USE_PREBUILT_RN_CORE_HELP = 'Whether the Xcode build for packaging should use React Native Apple prebuilt binaries (via CocoaPods). ' +
+    'If you omit this flag, Brownfield follows version-aware defaults: for React Native 0.84 and newer, prebuilts are enabled by default; for RN 0.83, they are disabled unless you opt in. ' +
+    'Pass true or false to force either behavior. Use the flag without a value as shorthand for true (same as `--use-prebuilt-rn-core true`). ' +
+    'See the Brownfield iOS guide for details: https://oss.callstack.com/react-native-brownfield/docs/getting-started/ios#react-native-prebuilts';
+export function parseUsePrebuiltRnCoreArgument(value) {
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'true' || normalized === '1') {
+        return true;
+    }
+    if (normalized === 'false' || normalized === '0') {
+        return false;
+    }
+    throw new RockError(`Invalid value for --use-prebuilt-rn-core: expected true or false, received "${value}"`);
+}
+function getPackagedFrameworkResolutionFailureMessage({ resolution, candidates, }) {
+    return resolution === 'ambiguous'
+        ? `found multiple bundled framework candidates (${candidates?.join(', ') ?? 'none'}); pass --scheme explicitly`
+        : 'could not resolve the packaged framework output automatically; pass --scheme explicitly';
+}
 export const packageIosCommand = curryOptions(new Command('package:ios').description('Build iOS XCFramework'), getBuildOptions({ platformName: 'ios' }).map((option) => option.name.startsWith('--build-folder')
     ? {
         ...option,
         description: option.description +
             " By default, the '.brownfield/build' path will be used.",
     }
-    : option)).action(actionRunner(async (options) => {
+    : option))
+    .addOption(new Option('--use-prebuilt-rn-core [bool]', USE_PREBUILT_RN_CORE_HELP)
+    .preset(true)
+    .argParser(parseUsePrebuiltRnCoreArgument))
+    .addOption(new Option('--add-spm-package', 'Generate a local Swift Package Manager manifest next to the packaged XCFramework outputs'))
+    .action(actionRunner(async (options) => {
     const { projectRoot, platformConfig, userConfig } = getProjectInfo('ios');
+    const prebuiltRNCoreSupport = supportsPrebuiltRNCore({ projectRoot });
+    // version-aware default when the flag is omitted (see ios.mdx "React Native Prebuilts")
+    options.usePrebuiltRnCore ??= prebuiltRNCoreSupport.supported
+        ? prebuiltRNCoreSupport.enabledByDefault
+        : false;
+    if (prebuiltRNCoreSupport) {
+        logger.info(`${options.usePrebuiltRnCore ? 'Using' : 'Not using'} prebuilt RN core`);
+        if (!prebuiltRNCoreSupport.enabledByDefault &&
+            !options.usePrebuiltRnCore) {
+            logger.info('Your environment supports prebuilt RN Core as an opt-in feature, but it is disabled by default. Pass --use-prebuilt-rn-core to enable it.');
+        }
+    }
+    if (options.usePrebuiltRnCore && !prebuiltRNCoreSupport.supported) {
+        throw new RockError(prebuiltRNCoreSupport.reason);
+    }
     await runExpoPrebuildIfNeeded({ projectRoot, platform: 'ios' });
     if (!userConfig.project.ios) {
         throw new Error('iOS project not found.');
@@ -35,6 +82,7 @@ export const packageIosCommand = curryOptions(new Command('package:ios').descrip
         dotBrownfieldDir = path.join(projectRoot, dotBrownfieldDir);
     }
     options.buildFolder ??= path.join(dotBrownfieldDir, 'build');
+    options.verbose ??= logger.isVerbose();
     // The new_architecture.rb script scans Info.plist and fails on binary plist files,
     // which is the case for our XCFrameworks.
     // We're reusing the "build" directory which is excluded from the scan.
@@ -50,10 +98,46 @@ export const packageIosCommand = curryOptions(new Command('package:ios').descrip
         // e.g. '0.82' (note the missing patch component),
         // therefore we resolve it manually from RN's package.json using Rock's utils
         reactNativeVersion: getReactNativeVersion(projectRoot),
-        usePrebuiltRNCore: false, // for brownfield, it is required to build RN from source
         packageDir, // the output directory for artifacts
         skipCache: true, // cache is dependent on existence of Rock config file
+        usePrebuiltRNCore: options.usePrebuiltRnCore,
     }, platformConfig);
+    const productsPath = path.join(options.buildFolder, 'Build', 'Products');
+    const { frameworkName, resolution, candidates } = resolvePackagedFrameworkName({
+        explicitScheme: options.scheme,
+        productsPath,
+        configuration,
+    });
+    if (!frameworkName && options.addSpmPackage) {
+        throw new RockError(`Cannot generate local SPM package: ${getPackagedFrameworkResolutionFailureMessage({
+            resolution,
+            candidates,
+        })}`);
+    }
+    if (frameworkName) {
+        copyDebugBundleToSimulatorSlice({
+            productsPath,
+            configuration,
+            frameworkName,
+        });
+        if (configuration.includes('Debug')) {
+            // Re-merge only Debug frameworks so the simulator slice includes main.jsbundle.
+            await mergeFrameworks({
+                sourceDir: userConfig.project.ios.sourceDir,
+                frameworkPaths: [
+                    path.join(productsPath, `${configuration}-iphoneos`, `${frameworkName}.framework`),
+                    path.join(productsPath, `${configuration}-iphonesimulator`, `${frameworkName}.framework`),
+                ],
+                outputPath: path.join(packageDir, `${frameworkName}.xcframework`),
+            });
+        }
+    }
+    else if (configuration.includes('Debug')) {
+        logger.warn(`Skipping Debug simulator JS bundle copy: ${getPackagedFrameworkResolutionFailureMessage({
+            resolution,
+            candidates,
+        })}`);
+    }
     const reactBrownfieldXcframeworkPath = path.join(packageDir, 'ReactBrownfield.xcframework');
     if (fs.existsSync(reactBrownfieldXcframeworkPath)) {
         // Strip the binary from ReactBrownfield.xcframework to make it interface-only.
@@ -62,7 +146,6 @@ export const packageIosCommand = curryOptions(new Command('package:ios').descrip
         stripFrameworkBinary(reactBrownfieldXcframeworkPath);
     }
     if (hasBrownie) {
-        const productsPath = path.join(options.buildFolder, 'Build', 'Products');
         const brownieOutputPath = path.join(packageDir, 'Brownie.xcframework');
         await mergeFrameworks({
             sourceDir: userConfig.project.ios.sourceDir,
@@ -79,7 +162,6 @@ export const packageIosCommand = curryOptions(new Command('package:ios').descrip
         logger.success(`Brownie.xcframework created at ${colorLink(relativeToCwd(brownieOutputPath))}`);
     }
     if (hasNavigation) {
-        const productsPath = path.join(options.buildFolder, 'Build', 'Products');
         const brownfieldNavigationOutputPath = path.join(packageDir, 'BrownfieldNavigation.xcframework');
         await mergeFrameworks({
             sourceDir: userConfig.project.ios.sourceDir,
@@ -92,5 +174,14 @@ export const packageIosCommand = curryOptions(new Command('package:ios').descrip
         stripFrameworkBinary(brownfieldNavigationOutputPath);
         logger.success(`BrownfieldNavigation.xcframework created at ${colorLink(relativeToCwd(brownfieldNavigationOutputPath))}`);
     }
+    if (options.addSpmPackage) {
+        const { packageManifestPath } = createLocalSpmPackage({
+            packageDir,
+            frameworkName: frameworkName ?? undefined,
+        });
+        logger.success(`Local SPM package manifest created at ${colorLink(relativeToCwd(packageManifestPath))}`);
+        logger.info(`Add the local package folder in Xcode: ${colorLink(relativeToCwd(packageDir))}`);
+        logger.info("In Xcode, choose File > Add Package Dependencies..., click Add Local..., and select that folder.");
+    }
 }));
 export const packageIosExample = new ExampleUsage('package:ios --scheme BrownfieldLib --configuration Release', "Build iOS XCFramework for 'BrownfieldLib' scheme in Release configuration");

package/dist/brownfield/utils/copyDebugBundleToSimulatorSlice.d.ts

@@ -0,0 +1,8 @@
+interface CopyDebugBundleToSimulatorSliceOptions {
+    productsPath: string;
+    configuration: string;
+    frameworkName: string;
+}
+export declare function copyDebugBundleToSimulatorSlice({ productsPath, configuration, frameworkName, }: CopyDebugBundleToSimulatorSliceOptions): void;
+export {};
+//# sourceMappingURL=copyDebugBundleToSimulatorSlice.d.ts.map

package/dist/brownfield/utils/copyDebugBundleToSimulatorSlice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"copyDebugBundleToSimulatorSlice.d.ts","sourceRoot":"","sources":["../../../src/brownfield/utils/copyDebugBundleToSimulatorSlice.ts"],"names":[],"mappings":"AAKA,UAAU,sCAAsC;IAC9C,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,wBAAgB,+BAA+B,CAAC,EAC9C,YAAY,EACZ,aAAa,EACb,aAAa,GACd,EAAE,sCAAsC,QA0CxC"}

package/dist/brownfield/utils/copyDebugBundleToSimulatorSlice.js

@@ -0,0 +1,21 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { colorLink, logger, relativeToCwd } from '@rock-js/tools';
+export function copyDebugBundleToSimulatorSlice({ productsPath, configuration, frameworkName, }) {
+    if (!configuration.includes('Debug')) {
+        return;
+    }
+    const deviceBundlePath = path.join(productsPath, `${configuration}-iphoneos`, `${frameworkName}.framework`, 'main.jsbundle');
+    const simulatorFrameworkPath = path.join(productsPath, `${configuration}-iphonesimulator`, `${frameworkName}.framework`);
+    const simulatorBundlePath = path.join(simulatorFrameworkPath, 'main.jsbundle');
+    if (!fs.existsSync(deviceBundlePath)) {
+        logger.warn(`Skipping simulator JS bundle copy: missing ${relativeToCwd(deviceBundlePath)}`);
+        return;
+    }
+    if (!fs.existsSync(simulatorFrameworkPath)) {
+        logger.warn(`Skipping simulator JS bundle copy: missing ${relativeToCwd(simulatorFrameworkPath)}`);
+        return;
+    }
+    fs.copyFileSync(deviceBundlePath, simulatorBundlePath);
+    logger.success(`Copied Debug JS bundle to simulator slice at ${colorLink(relativeToCwd(simulatorBundlePath))}`);
+}

package/dist/brownfield/utils/createLocalSpmPackage.d.ts

@@ -0,0 +1,10 @@
+type CreateLocalSpmPackageOptions = {
+    packageDir: string;
+    frameworkName?: string;
+};
+type CreateLocalSpmPackageResult = {
+    packageManifestPath: string;
+};
+export declare function createLocalSpmPackage({ packageDir, frameworkName, }: CreateLocalSpmPackageOptions): CreateLocalSpmPackageResult;
+export {};
+//# sourceMappingURL=createLocalSpmPackage.d.ts.map

package/dist/brownfield/utils/createLocalSpmPackage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createLocalSpmPackage.d.ts","sourceRoot":"","sources":["../../../src/brownfield/utils/createLocalSpmPackage.ts"],"names":[],"mappings":"AAQA,KAAK,4BAA4B,GAAG;IAClC,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,KAAK,2BAA2B,GAAG;IACjC,mBAAmB,EAAE,MAAM,CAAC;CAC7B,CAAC;AAuJF,wBAAgB,qBAAqB,CAAC,EACpC,UAAU,EACV,aAAa,GACd,EAAE,4BAA4B,GAAG,2BAA2B,CAsC5D"}

package/dist/brownfield/utils/createLocalSpmPackage.js

@@ -0,0 +1,138 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { prepareLocalSpmArtifacts, SPM_ARTIFACTS_DIR_NAME, } from './prepareLocalSpmArtifacts.js';
+const RESERVED_FRAMEWORK_NAMES = new Set([
+    'hermes',
+    'hermesvm',
+    'ReactBrownfield',
+    'Brownie',
+    'BrownfieldNavigation',
+    'React',
+    'ReactNativeDependencies',
+]);
+function requireXcframework(packageDir, name) {
+    const xcframeworkPath = path.join(packageDir, `${name}.xcframework`);
+    if (!fs.existsSync(xcframeworkPath)) {
+        throw new Error(`Missing required XCFramework: ${name}.xcframework`);
+    }
+    return name;
+}
+function optionalXcframework(packageDir, name) {
+    return fs.existsSync(path.join(packageDir, `${name}.xcframework`))
+        ? name
+        : null;
+}
+function requireHermesXcframework(packageDir) {
+    return (optionalXcframework(packageDir, 'hermesvm') ??
+        requireXcframework(packageDir, 'hermes'));
+}
+function resolveAppFrameworkName(packageDir, explicitFrameworkName) {
+    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, }) {
+    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, }) {
+    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, }) {
+    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 !== 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/dist/brownfield/utils/prepareLocalSpmArtifacts.d.ts

@@ -0,0 +1,8 @@
+type PrepareLocalSpmArtifactsOptions = {
+    packageDir: string;
+    targetNames: string[];
+};
+export declare const SPM_ARTIFACTS_DIR_NAME = "spm-artifacts";
+export declare function prepareLocalSpmArtifacts({ packageDir, targetNames, }: PrepareLocalSpmArtifactsOptions): string;
+export {};
+//# sourceMappingURL=prepareLocalSpmArtifacts.d.ts.map

package/dist/brownfield/utils/prepareLocalSpmArtifacts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prepareLocalSpmArtifacts.d.ts","sourceRoot":"","sources":["../../../src/brownfield/utils/prepareLocalSpmArtifacts.ts"],"names":[],"mappings":"AAIA,KAAK,+BAA+B,GAAG;IACrC,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,sBAAsB,kBAAkB,CAAC;AAyFtD,wBAAgB,wBAAwB,CAAC,EACvC,UAAU,EACV,WAAW,GACZ,EAAE,+BAA+B,UAejC"}

package/dist/brownfield/utils/prepareLocalSpmArtifacts.js

@@ -0,0 +1,77 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+export const SPM_ARTIFACTS_DIR_NAME = 'spm-artifacts';
+function removeCodeSignatureArtifacts(dirPath) {
+    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, frameworkName) {
+    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) {
+    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) {
+    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, }) {
+    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/dist/brownfield/utils/project.d.ts

@@ -14,6 +14,7 @@ export declare function getExpoConfigIfIsExpo(projectRoot: string): ExpoProjectC
  * @returns Whether the project is an Expo project
  */
 export declare function isExpoProject(projectRoot: string): boolean;
+export declare function getExpoSdkMajor(projectRoot: string): number | null;
 /**
  * Fills the RNC CLI project config from the Expo config by mutating the passed in `options.projectConfig` object in place
  */

package/dist/brownfield/utils/project.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../../../src/brownfield/utils/project.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,oBAAoB,EACpB,aAAa,EACb,UAAU,EACX,MAAM,mCAAmC,CAAC;AAC3C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAKjE,OAAO,EAEL,KAAK,aAAa,IAAI,iBAAiB,EACxC,MAAM,cAAc,CAAC;AAQtB;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,MAAM,4BAMxD;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAc1D;AAED;;GAEG;AACH,wBAAgB,+BAA+B,CAAC,EAC9C,aAAa,EACb,UAAU,EAAE,EAAE,GAAG,EAAE,EACnB,WAAW,GACZ,EAAE;IACD,8CAA8C;IAC9C,aAAa,EAAE,aAAa,CAAC;IAE7B,8BAA8B;IAC9B,UAAU,EAAE,iBAAiB,CAAC;IAE9B,4BAA4B;IAC5B,WAAW,EAAE,MAAM,CAAC;CACrB,QAuBA;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,QAAQ,SAAS,KAAK,GAAG,SAAS,EAC/D,QAAQ,EAAE,QAAQ,GACjB;IACD,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,UAAU,CAAC;IACvB,cAAc,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAC;CACzC,CAeA;AAED,wBAAgB,aAAa,CAAC,EAC5B,WAAW,EACX,QAAQ,GACT,EAAE;IACD,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,KAAK,GAAG,SAAS,CAAC;CAC7B,GAAG,UAAU,CAuBb;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,eAAe,EACrB,aAAa,EAAE,oBAAoB;;;EAQpC"}
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../../../src/brownfield/utils/project.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,oBAAoB,EACpB,aAAa,EACb,UAAU,EACX,MAAM,mCAAmC,CAAC;AAC3C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAKjE,OAAO,EAEL,KAAK,aAAa,IAAI,iBAAiB,EACxC,MAAM,cAAc,CAAC;AAQtB;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,MAAM,4BAMxD;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAc1D;AAED,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAOlE;AAED;;GAEG;AACH,wBAAgB,+BAA+B,CAAC,EAC9C,aAAa,EACb,UAAU,EAAE,EAAE,GAAG,EAAE,EACnB,WAAW,GACZ,EAAE;IACD,8CAA8C;IAC9C,aAAa,EAAE,aAAa,CAAC;IAE7B,8BAA8B;IAC9B,UAAU,EAAE,iBAAiB,CAAC;IAE9B,4BAA4B;IAC5B,WAAW,EAAE,MAAM,CAAC;CACrB,QAuBA;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,QAAQ,SAAS,KAAK,GAAG,SAAS,EAC/D,QAAQ,EAAE,QAAQ,GACjB;IACD,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,UAAU,CAAC;IACvB,cAAc,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAC;CACzC,CAeA;AAED,wBAAgB,aAAa,CAAC,EAC5B,WAAW,EACX,QAAQ,GACT,EAAE;IACD,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,KAAK,GAAG,SAAS,CAAC;CAC7B,GAAG,UAAU,CAuBb;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,eAAe,EACrB,aAAa,EAAE,oBAAoB;;;EAQpC"}

package/dist/brownfield/utils/project.js

@@ -36,6 +36,14 @@ export function isExpoProject(projectRoot) {
         ['dependencies', 'peerDependencies', 'devDependencies'].some((key) => JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'))[key]?.expo);
     return hasExpoConfig && dependsOnExpo;
 }
+export function getExpoSdkMajor(projectRoot) {
+    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/dist/brownfield/utils/resolvePackagedFrameworkName.d.ts

@@ -0,0 +1,14 @@
+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;
+}
+export declare function resolvePackagedFrameworkName({ explicitScheme, productsPath, configuration, }: ResolvePackagedFrameworkNameOptions): ResolvePackagedFrameworkNameResult;
+export {};
+//# sourceMappingURL=resolvePackagedFrameworkName.d.ts.map

package/dist/brownfield/utils/resolvePackagedFrameworkName.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolvePackagedFrameworkName.d.ts","sourceRoot":"","sources":["../../../src/brownfield/utils/resolvePackagedFrameworkName.ts"],"names":[],"mappings":"AAGA,KAAK,UAAU,GAAG,UAAU,GAAG,UAAU,GAAG,WAAW,GAAG,WAAW,CAAC;AAEtE,MAAM,WAAW,kCAAkC;IACjD,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,UAAU,EAAE,UAAU,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;CACvB;AAED,UAAU,mCAAmC;IAC3C,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;CACvB;AA4CD,wBAAgB,4BAA4B,CAAC,EAC3C,cAAc,EACd,YAAY,EACZ,aAAa,GACd,EAAE,mCAAmC,GAAG,kCAAkC,CAkC1E"}

package/dist/brownfield/utils/resolvePackagedFrameworkName.js

@@ -0,0 +1,61 @@
+import fs from 'node:fs';
+import path from 'node:path';
+function collectFrameworkCandidates(configurationProductsPath) {
+    if (!fs.existsSync(configurationProductsPath)) {
+        return [];
+    }
+    const discoveredFrameworks = new Set();
+    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, }) {
+    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/dist/brownfield/utils/supportsPrebuiltRNCore.d.ts

@@ -0,0 +1,18 @@
+/** Minimum RN version that can opt in to prebuilts via `--use-prebuilt-rn-core`. */
+export declare 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 declare const MIN_REACT_NATIVE_VERSION_FOR_PREBUILT_RN_CORE_BY_DEFAULT = "0.84.0";
+export declare 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 declare function supportsPrebuiltRNCore({ projectRoot, }: {
+    projectRoot: string;
+}): PrebuiltRNCoreSupportResult;
+//# sourceMappingURL=supportsPrebuiltRNCore.d.ts.map

package/dist/brownfield/utils/supportsPrebuiltRNCore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"supportsPrebuiltRNCore.d.ts","sourceRoot":"","sources":["../../../src/brownfield/utils/supportsPrebuiltRNCore.ts"],"names":[],"mappings":"AAIA,oFAAoF;AACpF,eAAO,MAAM,oDAAoD,WAAW,CAAC;AAC7E,2FAA2F;AAC3F,eAAO,MAAM,wDAAwD,WAC3D,CAAC;AACX,eAAO,MAAM,kDAAkD,KAAK,CAAC;AAErE,MAAM,MAAM,2BAA2B,GACnC;IAAE,SAAS,EAAE,IAAI,CAAC;IAAC,gBAAgB,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,KAAK,CAAA;CAAE,GAC9D;IAAE,SAAS,EAAE,KAAK,CAAC;IAAC,gBAAgB,CAAC,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEnE,wBAAgB,sBAAsB,CAAC,EACrC,WAAW,GACZ,EAAE;IACD,WAAW,EAAE,MAAM,CAAC;CACrB,GAAG,2BAA2B,CA+C9B"}