@callstack/react-native-brownfield 6.0.0 → 6.0.1

package/src/expo-config-plugin/ios/xcodeHelpers.ts

@@ -216,19 +216,29 @@ export function addSourceFilesBuildPhase(
     (filePath) => !filePath.endsWith('.plist')
   );
 
-  // Idempotency: skip when the target already has a sources phase with this
-  // comment, so re-running scaffolding does not duplicate the build phase.
-  const nativeTargets = getRawProjectObjects(project).PBXNativeTarget as
+  // Idempotency: skip when the target already has a sources phase, so
+  // re-running scaffolding does not duplicate the build phase. CocoaPods
+  // rewrites the phase's comment to "Sources" on `pod install`, so match by
+  // the phase type as well as by our comment.
+  const rawObjects = getRawProjectObjects(project);
+  const nativeTargets = rawObjects.PBXNativeTarget as
     | Record<string, PbxNativeTarget>
     | undefined;
+  const sourcesPhases = (rawObjects.PBXSourcesBuildPhase ?? {}) as Record<
+    string,
+    unknown
+  >;
   const targetBuildPhases =
     nativeTargets?.[frameworkTargetUUID]?.buildPhases ?? [];
-  const alreadyHasSourcePhase = targetBuildPhases.some((phase) =>
-    hasBuildPhaseComment(
-      { comment: typeof phase === 'string' ? undefined : phase.comment },
-      options.frameworkName
-    )
-  );
+  const alreadyHasSourcePhase = targetBuildPhases.some((phase) => {
+    const phaseUuid = getReferencedUuid(phase);
+    return (
+      hasBuildPhaseComment(
+        { comment: typeof phase === 'string' ? undefined : phase.comment },
+        options.frameworkName
+      ) || Boolean(phaseUuid && sourcesPhases[phaseUuid])
+    );
+  });
   if (alreadyHasSourcePhase) {
     Logger.logDebug(
       `Sources build phase "${options.frameworkName}" already present on target ${frameworkTargetUUID}, skipping`
@@ -812,3 +822,51 @@ export function resolveFrameworkDeploymentTarget(
 
   return appTargetDeploymentTarget ?? '15.0';
 }
+
+function isVersionLower(version: string, minimum: string): boolean {
+  const a = version.split('.').map(Number);
+  const b = minimum.split('.').map(Number);
+  for (let i = 0; i < Math.max(a.length, b.length); i++) {
+    const diff = (a[i] ?? 0) - (b[i] ?? 0);
+    if (diff !== 0) {
+      return diff < 0;
+    }
+  }
+  return false;
+}
+
+/**
+ * Raises the framework target's iOS deployment target to `minimum` in every
+ * build configuration where it is lower. Returns whether anything changed.
+ */
+export function raiseFrameworkDeploymentTarget(
+  project: XcodeProject,
+  frameworkTargetUUID: string,
+  minimum: string
+): boolean {
+  const rawObjects = getRawProjectObjects(project);
+  const target = rawObjects.PBXNativeTarget?.[frameworkTargetUUID] as
+    | PbxNativeTarget
+    | undefined;
+  const configList = target?.buildConfigurationList
+    ? rawObjects.XCConfigurationList?.[target.buildConfigurationList]
+    : undefined;
+  const configs = rawObjects.XCBuildConfiguration ?? {};
+
+  let changed = false;
+  for (const ref of configList?.buildConfigurations ?? []) {
+    const uuid = getReferencedUuid(ref);
+    const buildSettings = uuid ? configs[uuid]?.buildSettings : undefined;
+    if (!buildSettings) {
+      continue;
+    }
+    const current = normalizeXcodeBuildSettingValue(
+      buildSettings.IPHONEOS_DEPLOYMENT_TARGET
+    );
+    if (!current || isVersionLower(current, minimum)) {
+      buildSettings.IPHONEOS_DEPLOYMENT_TARGET = minimum;
+      changed = true;
+    }
+  }
+  return changed;
+}

package/src/expo-config-plugin/template/android/ReactNativeHostManager.vanilla.kt

@@ -5,15 +5,16 @@ import android.content.res.Configuration
 import com.callstack.reactnativebrownfield.OnJSBundleLoaded
 import com.callstack.reactnativebrownfield.ReactNativeBrownfield
 import com.facebook.react.PackageList
-import com.facebook.react.ReactHost
-import com.facebook.react.ReactNativeApplicationEntryPoint.loadReactNative
 import com.facebook.react.defaults.DefaultReactHost.getDefaultReactHost
+import com.facebook.react.views.view.setEdgeToEdgeFeatureFlagOn
 
 object ReactNativeHostManager {
     fun initialize(application: Application, onJSBundleLoaded: OnJSBundleLoaded? = null) {
-        loadReactNative(application)
+        if (BuildConfig.IS_EDGE_TO_EDGE_ENABLED) {
+            setEdgeToEdgeFeatureFlagOn()
+        }
 
-        val reactHost: ReactHost by lazy {
+        ReactNativeBrownfield.initialize(application, onJSBundleLoaded) {
             getDefaultReactHost(
                 context = application,
                 packageList = PackageList(application).packages,
@@ -24,12 +25,9 @@ object ReactNativeHostManager {
                 jsRuntimeFactory = null
             )
         }
-
-        ReactNativeBrownfield.initialize(application, reactHost, onJSBundleLoaded)
     }
 
     fun onConfigurationChanged(application: Application, newConfig: Configuration) {
         // no-op (kept for API symmetry with Expo variant)
     }
 }
-

package/src/expo-config-plugin/template/ios/ExpoModulesProviderExtension.swift

@@ -0,0 +1,7 @@
+// Keeps the generated ExpoModulesProvider linked into the framework, so Expo
+// modules register when the host app starts React Native.
+extension ReactNativeBrownfield {
+  public func ensureExpoModulesProvider() {
+    let _ = ExpoModulesProvider()
+  }
+}

package/src/scaffold/index.ts

@@ -26,6 +26,7 @@ import {
   addFrameworkTarget,
   addSourceFilesBuildPhase,
   copyBundleReactNativePhase,
+  raiseFrameworkDeploymentTarget,
 } from '../expo-config-plugin/ios/xcodeHelpers';
 import { createIosFramework } from '../expo-config-plugin/ios/withIosFrameworkFiles';
 import {
@@ -167,6 +168,35 @@ function resolveReactNativeVersion(projectRoot: string): string {
   return rnPkg.version;
 }
 
+/**
+ * Major Expo SDK version when the app itself depends on `expo` (installed
+ * with `install-expo-modules`), otherwise undefined. Only the app's own
+ * package.json counts: in a monorepo, `expo` can resolve from a hoisted
+ * node_modules even though this app never set it up. Returns -1 when the
+ * dependency is declared but not installed, which modifyPodfile reports.
+ */
+function resolveExpoMajor(projectRoot: string): number | undefined {
+  const pkg = JSON.parse(
+    fs.readFileSync(path.join(projectRoot, 'package.json'), 'utf8')
+  );
+  if (!pkg.dependencies?.expo && !pkg.devDependencies?.expo) {
+    return undefined;
+  }
+
+  const localRequire: NodeRequire =
+    typeof require === 'undefined'
+      ? createRequire(path.join(process.cwd(), 'noop.js'))
+      : require;
+  try {
+    const expoPkg = localRequire(
+      localRequire.resolve('expo/package.json', { paths: [projectRoot] })
+    );
+    return Number.parseInt(String(expoPkg.version).split('.')[0] ?? '', 10);
+  } catch {
+    return -1;
+  }
+}
+
 export async function scaffoldBrownfieldInRncCliProject(
   options: BrownfieldScaffoldOptions = {}
 ): Promise<void> {
@@ -202,6 +232,12 @@ export async function scaffoldBrownfieldInRncCliProject(
     : path.join(projectRoot, iosSourceDir || 'ios');
 
   const rnVersion = resolveReactNativeVersion(projectRoot);
+  const expoMajor = resolveExpoMajor(projectRoot);
+  if (expoMajor !== undefined) {
+    Logger.logInfo(
+      'Expo modules detected. The iOS framework will start React Native through the Expo host.'
+    );
+  }
 
   const iosFrameworkName = options.iosFrameworkName ?? 'BrownfieldLib';
   const androidModuleName = options.androidModuleName ?? 'brownfieldlib';
@@ -306,7 +342,9 @@ export async function scaffoldBrownfieldInRncCliProject(
         // an iOS deployment target directly.
         // TODO: derive from the Podfile `platform :ios` line or RN's
         // min_ios_version_supported, or expose a flag.
-        deploymentTarget: '15.0',
+        // Expo SDK 56+ modules require iOS 16.4.
+        deploymentTarget:
+          expoMajor !== undefined && expoMajor >= 56 ? '16.4' : '15.0',
         // Standard CFBundleShortVersionString for the generated framework
         // (matches the Expo plugin default); unrelated to package versioning.
         frameworkVersion: '1',
@@ -330,13 +368,25 @@ export async function scaffoldBrownfieldInRncCliProject(
       projectName: path.basename(xcodeprojPath, '.xcodeproj'),
     };
 
-    const { frameworkTargetUUID } = addFrameworkTarget(
+    const { frameworkTargetUUID, targetAlreadyExists } = addFrameworkTarget(
       project,
       modRequest,
       resolvedIosConfig.ios,
       { useExpoHost: false }
     );
 
+    // A target created before Expo was added keeps its old deployment target.
+    if (
+      targetAlreadyExists &&
+      expoMajor !== undefined &&
+      expoMajor >= 56 &&
+      raiseFrameworkDeploymentTarget(project, frameworkTargetUUID, '16.4')
+    ) {
+      Logger.logInfo(
+        `Raised the ${iosFrameworkName} deployment target to iOS 16.4, which Expo SDK 56 and newer require.`
+      );
+    }
+
     copyBundleReactNativePhase(project, frameworkTargetUUID);
     addSourceFilesBuildPhase(
       project,
@@ -355,10 +405,16 @@ export async function scaffoldBrownfieldInRncCliProject(
     if (!podfile) {
       throw new Error(`Missing ${podfilePath}`);
     }
-    writeFileIfChanged(podfilePath, modifyPodfile(podfile, iosFrameworkName));
+    writeFileIfChanged(
+      podfilePath,
+      modifyPodfile(podfile, iosFrameworkName, expoMajor)
+    );
 
     currentStep = 'ios-sources';
-    createIosFramework(iosDir, resolvedIosConfig, { useExpoHost: false });
+    createIosFramework(iosDir, resolvedIosConfig, {
+      useExpoHost: false,
+      withExpoModules: expoMajor !== undefined,
+    });
 
     // --- App package wiring: Brownfield deps + package:* scripts ---
     // The scaffolded Kotlin host imports com.callstack.reactnativebrownfield.*,

package/src/scaffold/projectFiles.ts

@@ -120,15 +120,17 @@ export function addBrownfieldDependencies(projectRoot: string): string[] {
 
 /**
  * Adds the `package:ios` / `package:android` scripts from the docs' manual
- * steps (settings come from the generated brownfield.config.json, so no flags
- * are duplicated here). Existing scripts with the same names are kept.
+ * steps (settings come from the generated brownfield.config.json, so no other
+ * flags are duplicated here). Existing scripts with the same names are kept.
  */
 export function addBrownfieldPackageScripts(projectRoot: string): string[] {
   const pkg = readPackageJson(projectRoot);
   pkg.scripts = pkg.scripts ?? {};
 
   const desiredScripts: Record<string, string> = {
-    'package:ios': 'brownfield package:ios',
+    // Also emit a local Swift package, so the host app adds one package
+    // instead of every XCFramework.
+    'package:ios': 'brownfield package:ios --add-spm-package',
     'package:android': 'brownfield package:android',
   };