@callstack/react-native-brownfield 5.2.0 → 5.3.0

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

@@ -62,8 +62,15 @@ export function resolveTargetSdkVersionExpression(
 
 export function renderTargetSdkBlock(
   config: ResolvedBrownfieldPluginConfigWithAndroid,
-  expoMajor?: number
+  expoMajor?: number,
+  templateVariant: 'expo' | 'vanilla' = 'expo'
 ): string {
+  // RN CLI (vanilla) projects target AGP 9, where library modules must not
+  // set `targetSdk` (compilation fails with "Unresolved reference 'targetSdk'").
+  if (templateVariant === 'vanilla') {
+    return '';
+  }
+
   if (
     expoMajor !== undefined &&
     expoMajor >= EXPO_SDK_OMIT_TARGET_SDK_FROM_MAJOR
@@ -83,11 +90,22 @@ export function createAndroidModule({
   rnVersion,
   projectRoot,
   expoMajor,
+  templateVariant = 'expo',
 }: {
   /**
    * Expo app root (used to detect optional dependencies such as expo-updates)
    */
   projectRoot?: string;
+
+  /**
+   * Source template flavor. 'vanilla' is used by the RN CLI scaffold for
+   * non-Expo projects; Expo keeps the default 'expo' variant.
+   * Note: expresses the same Expo-vs-vanilla axis as `useExpoHost` in the
+   * iOS helpers (withIosFrameworkFiles/xcodeHelpers), with opposite
+   * polarity: 'vanilla' here === `useExpoHost: false` there.
+   */
+  templateVariant?: 'expo' | 'vanilla';
+
   /**
    * The root Android directory path
    */
@@ -116,7 +134,11 @@ export function createAndroidModule({
   const hermesArtifact = getHermesArtifact(rnVersion, projectRoot);
   const compileSdkVersionExpression =
     resolveCompileSdkVersionExpression(config);
-  const targetSdkBlock = renderTargetSdkBlock(config, expoMajor);
+  const targetSdkBlock = renderTargetSdkBlock(
+    config,
+    expoMajor,
+    templateVariant
+  );
   const minifyEnabled =
     (android as { minifyEnabled?: boolean }).minifyEnabled ?? false;
   const extraProguardRules =
@@ -157,9 +179,15 @@ export function createAndroidModule({
     },
     {
       relativePath: `src/main/java/${config.android.packageName.replace(/\./g, '/')}/ReactNativeHostManager.kt`,
-      content: renderTemplate('android', 'ReactNativeHostManager.post55.kt', {
-        '{{PACKAGE_NAME}}': android.packageName,
-      }),
+      content: renderTemplate(
+        'android',
+        templateVariant === 'vanilla'
+          ? 'ReactNativeHostManager.vanilla.kt'
+          : 'ReactNativeHostManager.post55.kt',
+        {
+          '{{PACKAGE_NAME}}': android.packageName,
+        }
+      ),
     },
     {
       relativePath: 'consumer-rules.pro',

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

@@ -54,13 +54,15 @@ function ensureExpoDefinesForSDK55AndAbove(
  * Modifies the Podfile to include the Brownfield framework target
  * @param podfile The original Podfile content
  * @param frameworkName The name of the framework target to add
- * @param expoMajor The major version of the Expo SDK
+ * @param expoMajor The major version of the Expo SDK. Omit for vanilla
+ * (non-Expo) projects: the vanilla target block is inserted and no
+ * Expo-only hooks are applied.
  * @returns The modified Podfile content
  */
 export function modifyPodfile(
   podfile: string,
   frameworkName: string,
-  expoMajor: number
+  expoMajor?: number
 ): string {
   // check if the framework target is already included
   if (podfile.includes(`target '${frameworkName}'`)) {
@@ -73,9 +75,18 @@ export function modifyPodfile(
   Logger.logDebug(`Modifying Podfile for framework: ${frameworkName}`);
 
   // insert the framework target after the main target's "do"
-  const frameworkTargetBlock = renderTemplate('ios', 'PodfileTargetBlock.rb', {
-    '{{FRAMEWORK_NAME}}': frameworkName,
-  });
+  // Vanilla means the caller passed no Expo SDK version at all (undefined).
+  // Negative values mean "Expo detected but unknown version" and must still
+  // hit the unsupported-version error path below, not the vanilla path.
+  const frameworkTargetBlock = renderTemplate(
+    'ios',
+    typeof expoMajor === 'number'
+      ? 'PodfileTargetBlock.rb'
+      : 'PodfileTargetBlock.vanilla.rb',
+    {
+      '{{FRAMEWORK_NAME}}': frameworkName,
+    }
+  );
 
   // find insertion point after the first target's content begins, before the end of the target block
   const mainTargetMatch = podfile.match(
@@ -101,8 +112,15 @@ 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;
+  }
+
   if (expoMajor < MIN_SUPPORTED_EXPO_SDK_MAJOR_VERSION) {
-    const versionLabel = expoMajor < 0 ? 'unknown' : expoMajor.toString();
+    const versionLabel = expoMajor < 0 ? 'unknown' : String(expoMajor);
     throw new SourceModificationError(
       `Expo SDK ${versionLabel} is not supported. Please use Expo SDK ${MIN_SUPPORTED_EXPO_SDK_MAJOR_VERSION} or newer. For older versions, please see the matrix of supported versions: https://oss.callstack.com/react-native-brownfield/docs/getting-started/introduction#expo-version-compatibility`
     );

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

@@ -47,7 +47,8 @@ export const withBrownfieldIos: ConfigPlugin<
     const { frameworkTargetUUID, targetAlreadyExists } = addFrameworkTarget(
       project,
       modRequest,
-      iosProps
+      iosProps,
+      { useExpoHost: true }
     );
 
     // Ensure Expo.plist is present in the framework resources phase when
@@ -73,7 +74,9 @@ export const withBrownfieldIos: ConfigPlugin<
     // copy the "Bundle React Native code and images" build phase from the main target to the framework target
     copyBundleReactNativePhase(project, frameworkTargetUUID);
 
-    addSourceFilesBuildPhase(project, frameworkTargetUUID, iosProps);
+    addSourceFilesBuildPhase(project, frameworkTargetUUID, iosProps, {
+      useExpoHost: true,
+    });
 
     return xcodeConfig;
   });

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

@@ -16,14 +16,28 @@ import { renderTemplate } from '../template/engine';
  * @returns The list of framework source files
  */
 export function getFrameworkSourceFiles(
-  ios: ResolvedBrownfieldPluginConfigWithIos['ios']
+  ios: ResolvedBrownfieldPluginConfigWithIos['ios'],
+  options?: {
+    /**
+     * Whether the packaged framework is expected to use the Expo host.
+     * This influences template selection for the generated framework sources.
+     * Note: expresses the same Expo-vs-vanilla axis as `templateVariant` in
+     * the Android helper (withAndroidModuleFiles.createAndroidModule), with
+     * opposite polarity: `false` here === 'vanilla' there.
+     */
+    useExpoHost?: boolean;
+  }
 ): RenderedTemplateFile[] {
+  const useExpoHost = options?.useExpoHost ?? true;
+
   return [
     {
       relativePath: `${ios.frameworkName}.swift`,
-      content: renderTemplate('ios', 'FrameworkInterface.swift', {
-        '{{BUNDLE_IDENTIFIER}}': ios.bundleIdentifier,
-      }),
+      content: useExpoHost
+        ? renderTemplate('ios', 'FrameworkInterface.swift', {
+            '{{BUNDLE_IDENTIFIER}}': ios.bundleIdentifier,
+          })
+        : renderTemplate('ios', 'FrameworkInterface.vanilla.swift', {}),
     },
     {
       relativePath: 'Info.plist',
@@ -41,7 +55,8 @@ export function getFrameworkSourceFiles(
  */
 export function createIosFramework(
   iosDir: string,
-  config: ResolvedBrownfieldPluginConfigWithIos
+  config: ResolvedBrownfieldPluginConfigWithIos,
+  options?: Parameters<typeof getFrameworkSourceFiles>[1]
 ) {
   const { ios } = config;
   const frameworkDir = path.join(iosDir, ios.frameworkName);
@@ -61,7 +76,7 @@ export function createIosFramework(
   }
 
   // write files
-  for (const file of getFrameworkSourceFiles(ios)) {
+  for (const file of getFrameworkSourceFiles(ios, options)) {
     const filePath = path.join(frameworkDir, file.relativePath);
 
     fs.writeFileSync(filePath, file.content, 'utf8');

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

@@ -11,6 +11,43 @@ import type { ResolvedBrownfieldPluginIosConfig } from '../types';
 import { SourceModificationError } from '../errors/SourceModificationError';
 import { getFrameworkSourceFiles } from './withIosFrameworkFiles';
 
+/**
+ * xcode@3.x addTarget() stores target names/comments quoted (e.g. name =
+ * "BrownfieldLib"), and the pbxproj parser keeps the quote characters on
+ * re-parse. That makes pbxTargetByName() (comment-based, unquoted) miss
+ * targets we previously wrote, so a second run would create a duplicate
+ * target. Match by unquoting the stored name as a fallback.
+ */
+function findFrameworkTargetByQuotedName(
+  project: XcodeProject,
+  frameworkName: string
+): ReturnType<XcodeProject['pbxTargetByName']> {
+  const nativeTargets = getRawProjectObjects(project).PBXNativeTarget as
+    | Record<string, PbxNativeTarget & { isa?: string }>
+    | undefined;
+
+  for (const [key, target] of Object.entries(nativeTargets ?? {})) {
+    if (key.endsWith('_comment') || target?.isa !== 'PBXNativeTarget') {
+      continue;
+    }
+    const name = unquotePbxString(target.name);
+    if (name === frameworkName) {
+      return target as any;
+    }
+  }
+
+  return null;
+}
+
+function unquotePbxString(value: string | undefined): string | undefined {
+  if (typeof value !== 'string') {
+    return undefined;
+  }
+  return value.startsWith('"') && value.endsWith('"')
+    ? value.slice(1, -1)
+    : value;
+}
+
 /**
  * Adds a new Framework target to the Xcode project for Brownfield packaging
  * @throws If target creation fails
@@ -20,7 +57,10 @@ import { getFrameworkSourceFiles } from './withIosFrameworkFiles';
 export function addFrameworkTarget(
   project: XcodeProject,
   modRequest: ModProps<XcodeProject>,
-  options: ResolvedBrownfieldPluginIosConfig
+  options: ResolvedBrownfieldPluginIosConfig,
+  brownfieldOptions?: {
+    useExpoHost?: boolean;
+  }
 ): {
   frameworkTargetUUID: string;
   targetAlreadyExists: boolean;
@@ -28,7 +68,9 @@ export function addFrameworkTarget(
   const { frameworkName, bundleIdentifier } = options;
 
   // check if target already exists
-  const existingTarget = project.pbxTargetByName(frameworkName);
+  const existingTarget =
+    project.pbxTargetByName(frameworkName) ??
+    findFrameworkTargetByQuotedName(project, frameworkName);
   if (existingTarget) {
     Logger.logDebug(
       `Framework target "${frameworkName}" already exists, skipping creation`
@@ -131,7 +173,7 @@ export function addFrameworkTarget(
   });
 
   // create the framework group in the project
-  const filePaths = getFrameworkSourceFiles(options).map(
+  const filePaths = getFrameworkSourceFiles(options, brownfieldOptions).map(
     (file) => file.relativePath
   );
   const groupPath = path.join(modRequest.platformProjectRoot, frameworkName);
@@ -161,9 +203,12 @@ export function addFrameworkTarget(
 export function addSourceFilesBuildPhase(
   project: XcodeProject,
   frameworkTargetUUID: string,
-  options: ResolvedBrownfieldPluginIosConfig
+  options: ResolvedBrownfieldPluginIosConfig,
+  brownfieldOptions?: {
+    useExpoHost?: boolean;
+  }
 ) {
-  const filePaths = getFrameworkSourceFiles(options).map(
+  const filePaths = getFrameworkSourceFiles(options, brownfieldOptions).map(
     (file) => file.relativePath
   );
 
@@ -171,6 +216,26 @@ 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
+    | Record<string, PbxNativeTarget>
+    | undefined;
+  const targetBuildPhases =
+    nativeTargets?.[frameworkTargetUUID]?.buildPhases ?? [];
+  const alreadyHasSourcePhase = targetBuildPhases.some((phase) =>
+    hasBuildPhaseComment(
+      { comment: typeof phase === 'string' ? undefined : phase.comment },
+      options.frameworkName
+    )
+  );
+  if (alreadyHasSourcePhase) {
+    Logger.logDebug(
+      `Sources build phase "${options.frameworkName}" already present on target ${frameworkTargetUUID}, skipping`
+    );
+    return;
+  }
+
   project.addBuildPhase(
     sourceFiles,
     'PBXSourcesBuildPhase',
@@ -613,6 +678,13 @@ export function copyBundleReactNativePhase(
         }
       );
 
+      // xcode's pbxShellScriptBuildPhaseObj only escapes quotes, leaving real
+      // newlines in the shellScript value — that produces an invalid pbxproj
+      // once the project is written. Encode both fields the same way the
+      // update path above does.
+      addedPhase.buildPhase.shellPath = encodePbxString(frameworkShellPath);
+      addedPhase.buildPhase.shellScript = encodePbxString(frameworkShellScript);
+
       if (existingPhase.showEnvVarsInLog !== undefined) {
         addedPhase.buildPhase.showEnvVarsInLog = existingPhase.showEnvVarsInLog;
       }

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

@@ -0,0 +1,35 @@
+package {{PACKAGE_NAME}}
+
+import android.app.Application
+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
+
+object ReactNativeHostManager {
+    fun initialize(application: Application, onJSBundleLoaded: OnJSBundleLoaded? = null) {
+        loadReactNative(application)
+
+        val reactHost: ReactHost by lazy {
+            getDefaultReactHost(
+                context = application,
+                packageList = PackageList(application).packages,
+                jsMainModulePath = "index",
+                jsBundleAssetPath = "index.android.bundle",
+                jsBundleFilePath = null,
+                useDevSupport = BuildConfig.DEBUG,
+                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/FrameworkInterface.vanilla.swift

@@ -0,0 +1,12 @@
+import Foundation
+
+// Re-export the Brownfield runtime so the native host app resolves
+// ReactNativeBrownfield.shared by importing only this framework, matching the
+// manual guide's interface file (docs getting-started/ios.mdx).
+@_exported import ReactBrownfield
+
+// Initializes a Bundle instance that points at the framework target.
+public let ReactNativeBundle = Bundle(for: InternalClassForBundle.self)
+
+class InternalClassForBundle {}
+

package/src/expo-config-plugin/template/ios/PodfileTargetBlock.vanilla.rb

@@ -0,0 +1,5 @@
+  # Brownfield framework target for packaging as XCFramework
+  target '{{FRAMEWORK_NAME}}' do
+    inherit! :complete
+  end
+

package/src/index.ts

@@ -2,6 +2,13 @@ import { Platform } from 'react-native';
 
 import ReactNativeBrownfieldModule from './NativeReactNativeBrownfieldModule';
 
+// NOTE: the scaffold API is intentionally NOT re-exported here. This module is
+// the package's `react-native`/`source` entry point, so anything reachable from
+// it is traversed by Metro when an app imports the package. The scaffold pulls
+// in node:fs, node:path, xcode and the Community CLI, which cannot bundle.
+// Node-side consumers import it from the dedicated subpath instead:
+// `@callstack/react-native-brownfield/scaffold`.
+
 export type { BrownfieldConfig } from '@callstack/brownfield-cli/types';
 
 export interface MessageEvent {