@callstack/react-native-brownfield 6.0.0 → 6.1.0

package/src/expo-config-plugin/android/withAndroidModuleFiles.ts

@@ -40,6 +40,43 @@ function renderMissingDimensionStrategyBlock(
   return `        missingDimensionStrategy(${args})`;
 }
 
+const COORDINATE_PART = /^[A-Za-z0-9._-]+$/;
+
+/**
+ * Renders `excludeDependencies` as a `configurations.all` block. The Brownfield Gradle plugin
+ * leaves anything excluded this way out of the published POM and module.json. Entries become
+ * Kotlin string literals, so anything but a plain coordinate is rejected.
+ */
+function renderExcludeDependenciesBlock(excludeDependencies: string[]): string {
+  // It comes from user JSON, so the type isn't guaranteed.
+  if (!Array.isArray(excludeDependencies)) {
+    throw new Error(
+      'android.excludeDependencies must be a list of "group:module" or "group" strings.'
+    );
+  }
+  if (excludeDependencies.length === 0) {
+    return '';
+  }
+
+  const lines = excludeDependencies.map((entry) => {
+    const parts = entry.split(':');
+    if (
+      parts.length > 2 ||
+      !parts.every((part) => COORDINATE_PART.test(part))
+    ) {
+      throw new Error(
+        `android.excludeDependencies: '${entry}' is not in the form "group:module" or "group".`
+      );
+    }
+    const [group, module] = parts;
+    return module
+      ? `    exclude(group = "${group}", module = "${module}")`
+      : `    exclude(group = "${group}")`;
+  });
+
+  return `configurations.all {\n${lines.join('\n')}\n}\n\n`;
+}
+
 export function resolveCompileSdkVersionExpression(
   config: ResolvedBrownfieldPluginConfigWithAndroid
 ): string {
@@ -154,6 +191,10 @@ export function createAndroidModule({
     android.missingDimensionStrategies
   );
 
+  const excludeDependenciesBlock = renderExcludeDependenciesBlock(
+    android.excludeDependencies
+  );
+
   // generate module files
   const files: RenderedTemplateFile[] = [
     {
@@ -171,6 +212,7 @@ export function createAndroidModule({
         '{{IS_MINIFY_ENABLED}}': minifyEnabled.toString(),
         '{{MISSING_DIMENSION_STRATEGIES}}': missingDimensionStrategiesList,
         '{{MISSING_DIMENSION_STRATEGY_BLOCK}}': missingDimensionStrategyBlock,
+        '{{EXCLUDE_DEPENDENCIES_BLOCK}}': excludeDependenciesBlock,
       }),
     },
     {

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

@@ -20,7 +20,7 @@ function ensureExpoDefinesForSDK55AndAbove(
   const defaultDeploymentTarget = expoMajor >= 56 ? '16.4' : '15.1';
   const hook = `
     ${BROWNFIELD_EXPO_GTE_55_SWIFT_DEFINES_MARKER_START}
-    brownfield_ios_deployment_target = podfile_properties['ios.deploymentTarget'] || '${defaultDeploymentTarget}'
+    brownfield_ios_deployment_target = (defined?(podfile_properties) && podfile_properties['ios.deploymentTarget']) || '${defaultDeploymentTarget}'
     installer.pods_project.targets.each do |target|
       if target.name == 'ReactBrownfield'
         puts "[Brownfield] Adding definition of EXPO_SDK_GTE_55 to target: #{target.name}"
@@ -65,11 +65,23 @@ export function modifyPodfile(
   expoMajor?: number
 ): string {
   // check if the framework target is already included
-  if (podfile.includes(`target '${frameworkName}'`)) {
-    Logger.logDebug(
-      `Framework target "${frameworkName}" already in Podfile, skipping modification`
+  if (
+    podfile.includes(`target '${frameworkName}'`) ||
+    podfile.includes(`target "${frameworkName}"`)
+  ) {
+    if (typeof expoMajor !== 'number') {
+      Logger.logDebug(
+        `Framework target "${frameworkName}" already in Podfile, skipping modification`
+      );
+      return podfile;
+    }
+
+    // A React Native CLI app can add Expo after it was scaffolded, so a re-run
+    // switches the existing target to the Expo host.
+    return applyExpoHooks(
+      ensureExpoHostInFrameworkTarget(podfile, frameworkName),
+      expoMajor
     );
-    return podfile;
   }
 
   Logger.logDebug(`Modifying Podfile for framework: ${frameworkName}`);
@@ -113,12 +125,39 @@ export function modifyPodfile(
   Logger.logDebug(`Added framework target "${frameworkName}" to Podfile`);
 
   // Vanilla projects (expoMajor === undefined) get no Expo-only hooks.
-  // Early-returning here lets TypeScript narrow `expoMajor` to `number`
-  // for the rest of the function (no casts needed below).
   if (typeof expoMajor !== 'number') {
     return modifiedPodfile;
   }
 
+  return applyExpoHooks(modifiedPodfile, expoMajor);
+}
+
+function ensureExpoHostInFrameworkTarget(
+  podfile: string,
+  frameworkName: string
+): string {
+  if (/^[ \t]*ENV\['REACT_NATIVE_BROWNFIELD_USE_EXPO_HOST'\]/m.test(podfile)) {
+    return podfile;
+  }
+
+  const escapedName = frameworkName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const targetLine = new RegExp(
+    `^([ \\t]*)(target\\s+['"]${escapedName}['"]\\s+do\\b[^\\r\\n]*(\\r?\\n))`,
+    'm'
+  );
+  if (!targetLine.test(podfile)) {
+    throw new SourceModificationError(
+      `Couldn't find the "target '${frameworkName}' do" line in the Podfile to enable the Expo host. Add ENV['REACT_NATIVE_BROWNFIELD_USE_EXPO_HOST'] = '1' inside that target block manually.`
+    );
+  }
+
+  return podfile.replace(
+    targetLine,
+    `$1$2$1  ENV['REACT_NATIVE_BROWNFIELD_USE_EXPO_HOST'] = '1'$3`
+  );
+}
+
+function applyExpoHooks(podfile: string, expoMajor: number): string {
   if (expoMajor < MIN_SUPPORTED_EXPO_SDK_MAJOR_VERSION) {
     const versionLabel = expoMajor < 0 ? 'unknown' : String(expoMajor);
     throw new SourceModificationError(
@@ -126,10 +165,5 @@ export function modifyPodfile(
     );
   }
 
-  modifiedPodfile = ensureExpoDefinesForSDK55AndAbove(
-    modifiedPodfile,
-    expoMajor
-  );
-
-  return modifiedPodfile;
+  return ensureExpoDefinesForSDK55AndAbove(podfile, expoMajor);
 }

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

@@ -26,9 +26,19 @@ export function getFrameworkSourceFiles(
      * opposite polarity: `false` here === 'vanilla' there.
      */
     useExpoHost?: boolean;
+    /**
+     * Vanilla template only: a React Native CLI app that uses Expo modules
+     * also needs `ensureExpoModulesProvider()` (the Expo template has it).
+     */
+    withExpoModules?: boolean;
   }
 ): RenderedTemplateFile[] {
   const useExpoHost = options?.useExpoHost ?? true;
+  const vanillaInterface =
+    renderTemplate('ios', 'FrameworkInterface.vanilla.swift', {}) +
+    (options?.withExpoModules
+      ? renderTemplate('ios', 'ExpoModulesProviderExtension.swift', {})
+      : '');
 
   return [
     {
@@ -37,7 +47,7 @@ export function getFrameworkSourceFiles(
         ? renderTemplate('ios', 'FrameworkInterface.swift', {
             '{{BUNDLE_IDENTIFIER}}': ios.bundleIdentifier,
           })
-        : renderTemplate('ios', 'FrameworkInterface.vanilla.swift', {}),
+        : vanillaInterface,
     },
     {
       relativePath: 'Info.plist',

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/android/build.gradle.kts

@@ -47,7 +47,7 @@ reactBrownfield {
     missingDimensionStrategies = listOf({{MISSING_DIMENSION_STRATEGIES}})
 }
 
-react {
+{{EXCLUDE_DEPENDENCIES_BLOCK}}react {
     autolinkLibrariesWithApp()
 }
 

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/expo-config-plugin/types/android/BrownfieldPluginAndroidConfig.ts

@@ -69,6 +69,13 @@ export interface BrownfieldPluginAndroidConfig {
    * @default []
    */
   missingDimensionStrategies?: string[];
+
+  /**
+   * Dependencies to keep out of the published AAR's POM and module.json, as
+   * "group:module" or "group" for a whole group, e.g. "com.caverock:androidsvg".
+   * @default []
+   */
+  excludeDependencies?: string[];
 }
 
 /**

package/src/index.ts

@@ -96,11 +96,13 @@ const ReactNativeBrownfield = {
   ): { remove: () => void } => {
     const subscription = ReactNativeBrownfieldModule.onBrownfieldMessage(
       (payload) => {
+        let data: unknown;
         try {
-          callback({ data: JSON.parse(payload.text) });
+          data = JSON.parse(payload.text);
         } catch {
-          callback({ data: payload.text });
+          data = payload.text;
         }
+        callback({ data });
       }
     );
     return { remove: () => subscription.remove() };

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';
@@ -265,6 +301,7 @@ export async function scaffoldBrownfieldInRncCliProject(
         useLocalGradlePlugin: false,
         useLocalMaven: false,
         missingDimensionStrategies: [],
+        excludeDependencies: [],
       },
       ios: null,
       debug: options.debug ?? false,
@@ -306,7 +343,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 +369,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 +406,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',
   };