@callstack/react-native-brownfield 3.6.1 → 3.8.0

package/src/expo-config-plugin/android/utils/androidManifest.ts

@@ -0,0 +1,131 @@
+export type AndroidManifestMetaDataEntry = {
+  name: string;
+  value: string;
+};
+
+export type AndroidStringResourceEntry = {
+  name: string;
+  value: string;
+};
+
+const APPLICATION_BLOCK_REGEX = /<application\b[\s\S]*?<\/application>/;
+const META_DATA_TAG_REGEX =
+  /<meta-data\b[\s\S]*?(?:\/>|>[\s\S]*?<\/meta-data>)/g;
+const STRING_TAG_REGEX = /<string\b[\s\S]*?>[\s\S]*?<\/string>/g;
+
+export function extractApplicationMetaData(
+  manifestContent: string
+): AndroidManifestMetaDataEntry[] {
+  const applicationBlock = manifestContent.match(APPLICATION_BLOCK_REGEX)?.[0];
+
+  if (!applicationBlock) {
+    return [];
+  }
+
+  return (applicationBlock.match(META_DATA_TAG_REGEX) ?? [])
+    .map(parseMetaDataTag)
+    .filter(
+      (metaDataEntry): metaDataEntry is AndroidManifestMetaDataEntry =>
+        metaDataEntry !== null
+    );
+}
+
+export function extractStringResourcesFromXml(
+  stringsContent: string,
+  resourceNames: string[]
+): AndroidStringResourceEntry[] {
+  if (resourceNames.length === 0) {
+    return [];
+  }
+
+  return resourceNames
+    .map((name) => extractStringResource(stringsContent, name))
+    .filter(
+      (stringResource): stringResource is AndroidStringResourceEntry =>
+        stringResource !== null
+    );
+}
+
+export function renderLibraryManifestApplication(
+  metaDataEntries: AndroidManifestMetaDataEntry[]
+): string {
+  if (metaDataEntries.length === 0) {
+    return '';
+  }
+
+  const renderedMetaDataEntries = metaDataEntries
+    .map(
+      ({ name, value }) =>
+        `    <meta-data android:name="${name}" android:value="${value}" />`
+    )
+    .join('\n');
+
+  return `  <application>\n${renderedMetaDataEntries}\n  </application>`;
+}
+
+export function renderLibraryStringResources(
+  stringResources: AndroidStringResourceEntry[]
+): string {
+  if (stringResources.length === 0) {
+    return '';
+  }
+
+  return stringResources
+    .map(({ name, value }) => `  <string name="${name}">${value}</string>`)
+    .join('\n');
+}
+
+function parseMetaDataTag(
+  metaDataTag: string
+): AndroidManifestMetaDataEntry | null {
+  const name = getAndroidAttribute(metaDataTag, 'name');
+  const value = getAndroidAttribute(metaDataTag, 'value');
+
+  return parseMetaDataAttributes(name, value);
+}
+
+function parseMetaDataAttributes(
+  name: string | undefined,
+  value: string | undefined
+): AndroidManifestMetaDataEntry | null {
+  if (name === undefined || value === undefined) {
+    return null;
+  }
+  return { name, value };
+}
+
+function extractStringResource(
+  stringsContent: string,
+  resourceName: string
+): AndroidStringResourceEntry | null {
+  const stringTag = (stringsContent.match(STRING_TAG_REGEX) ?? []).find(
+    (tag) => getAttribute(tag, 'name') === resourceName
+  );
+
+  if (!stringTag) {
+    return null;
+  }
+
+  const value = stringTag.match(/>([\s\S]*?)<\/string>/)?.[1];
+
+  if (value === undefined) {
+    return null;
+  }
+
+  return { name: resourceName, value };
+}
+
+function getAndroidAttribute(
+  metaDataTag: string,
+  attributeName: string
+): string | undefined {
+  return getAttribute(metaDataTag, `android:${attributeName}`);
+}
+
+function getAttribute(tag: string, attributeName: string): string | undefined {
+  const attributeRegex = new RegExp(
+    `\\b${attributeName}\\s*=\\s*(['"])([\\s\\S]*?)\\1`
+  );
+
+  return tag.match(attributeRegex)?.[2];
+}

package/src/expo-config-plugin/android/utils/constants.ts

@@ -1,2 +1,2 @@
-export const BROWNFIELD_PLUGIN_VERSION = '1.0.2';
+export const BROWNFIELD_PLUGIN_VERSION = '1.1.0';
 export const brownfieldGradlePluginDependency = `classpath("com.callstack.react:brownfield-gradle-plugin:${BROWNFIELD_PLUGIN_VERSION}")`;

package/src/expo-config-plugin/android/utils/expo-updates.ts

@@ -0,0 +1,106 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+import { Logger } from '../../logging';
+import {
+  type AndroidManifestMetaDataEntry,
+  type AndroidStringResourceEntry,
+  extractApplicationMetaData,
+  extractStringResourcesFromXml,
+} from './androidManifest';
+
+const APP_MANIFEST_PATH_SEGMENTS = ['src', 'main', 'AndroidManifest.xml'];
+const APP_STRINGS_PATH_SEGMENTS = [
+  'src',
+  'main',
+  'res',
+  'values',
+  'strings.xml',
+];
+const STRING_REFERENCE_REGEX = /^@string\/([A-Za-z0-9_.]+)$/;
+const EXPO_UPDATES_META_DATA_PREFIX = 'expo.modules.updates.';
+
+/**
+ * This copies values from the app's finalized Android files while running
+ * inside `withDangerousMod` / `withFinalizedMod`. In that phase, the stable
+ * cross-plugin input is the on-disk XML after Expo and other config plugins have
+ * finished mutating it, so extraction intentionally uses raw file
+ * contents as the source of truth.
+ */
+export function readExpoUpdatesApplicationMetaData(
+  androidDir: string,
+  appModuleName: string
+): AndroidManifestMetaDataEntry[] {
+  const manifestPath = path.join(
+    androidDir,
+    appModuleName,
+    ...APP_MANIFEST_PATH_SEGMENTS
+  );
+
+  if (!fs.existsSync(manifestPath)) {
+    Logger.logDebug(
+      `App manifest not found, skipping metadata copy: ${manifestPath}`
+    );
+    return [];
+  }
+
+  return extractExpoUpdatesApplicationMetaData(
+    fs.readFileSync(manifestPath, 'utf8')
+  );
+}
+
+export function extractExpoUpdatesApplicationMetaData(
+  manifestContent: string
+): AndroidManifestMetaDataEntry[] {
+  return extractApplicationMetaData(manifestContent).filter(
+    isExpoUpdatesMetaDataEntry
+  );
+}
+
+export function readExpoUpdatesStringResources(
+  androidDir: string,
+  appModuleName: string,
+  metaDataEntries: AndroidManifestMetaDataEntry[]
+): AndroidStringResourceEntry[] {
+  const stringResourceNames = getReferencedStringResourceNames(metaDataEntries);
+
+  if (stringResourceNames.length === 0) {
+    return [];
+  }
+
+  const stringsPath = path.join(
+    androidDir,
+    appModuleName,
+    ...APP_STRINGS_PATH_SEGMENTS
+  );
+
+  if (!fs.existsSync(stringsPath)) {
+    Logger.logDebug(
+      `App strings not found, skipping string resource copy: ${stringsPath}`
+    );
+    return [];
+  }
+
+  return extractStringResourcesFromXml(
+    fs.readFileSync(stringsPath, 'utf8'),
+    stringResourceNames
+  );
+}
+
+function isExpoUpdatesMetaDataEntry(
+  metaDataEntry: AndroidManifestMetaDataEntry
+): boolean {
+  return metaDataEntry.name.startsWith(EXPO_UPDATES_META_DATA_PREFIX);
+}
+
+function getReferencedStringResourceNames(
+  metaDataEntries: AndroidManifestMetaDataEntry[]
+): string[] {
+  return [
+    ...new Set(
+      metaDataEntries
+        .map(({ value }) => value.match(STRING_REFERENCE_REGEX)?.[1])
+        .filter((name): name is string => name !== undefined)
+    ),
+  ];
+}

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

@@ -9,7 +9,17 @@ import type {
 } from '../types';
 import { Logger } from '../logging';
 import { renderTemplate } from '../template/engine';
-import { getExpoInfo } from '../expoUtils';
+import { getExpoInfo, hasExpoUpdatesInstalled } from '../expoUtils';
+import {
+  type AndroidManifestMetaDataEntry,
+  type AndroidStringResourceEntry,
+  renderLibraryManifestApplication,
+  renderLibraryStringResources,
+} from './utils/androidManifest';
+import {
+  readExpoUpdatesApplicationMetaData,
+  readExpoUpdatesStringResources,
+} from './utils/expo-updates';
 import { getHermesArtifact } from './utils/hermes';
 
 /**
@@ -20,7 +30,13 @@ export function createAndroidModule({
   config,
   rnVersion,
   isExpoPre55,
+  projectRoot,
 }: {
+  /**
+   * Expo app root (used to detect optional dependencies such as expo-updates)
+   */
+  projectRoot?: string;
+
   /**
    * Whether the Expo project is pre-55
    */
@@ -43,6 +59,7 @@ export function createAndroidModule({
 }): void {
   const { android } = config;
   const moduleDir = path.join(androidDir, android.moduleName);
+  const hasExpoUpdates = hasExpoUpdatesInstalled(projectRoot);
 
   Logger.logDebug(`Creating Android module in: ${androidDir}`);
 
@@ -70,10 +87,6 @@ export function createAndroidModule({
       relativePath: 'gradle.properties',
       content: renderTemplate('android', 'gradle.properties', {}),
     },
-    {
-      relativePath: 'src/main/AndroidManifest.xml',
-      content: renderTemplate('android', 'AndroidManifest.xml', {}),
-    },
     {
       relativePath: `src/main/java/${config.android.packageName.replace(/\./g, '/')}/ReactNativeHostManager.kt`,
       content: renderTemplate(
@@ -81,9 +94,19 @@ export function createAndroidModule({
         isExpoPre55
           ? 'ReactNativeHostManager.pre55.kt'
           : 'ReactNativeHostManager.post55.kt',
-        {
-          '{{PACKAGE_NAME}}': android.packageName,
-        }
+        isExpoPre55
+          ? {
+              '{{PACKAGE_NAME}}': android.packageName,
+              '{{EXPO_UPDATES_IMPORTS}}': hasExpoUpdates
+                ? 'import expo.modules.updates.UpdatesController'
+                : '',
+              '{{EXPO_UPDATES_REACT_HOST_BLOCK}}': hasExpoUpdates
+                ? '\n        UpdatesController.setReactHost(reactHost)\n'
+                : '\n',
+            }
+          : {
+              '{{PACKAGE_NAME}}': android.packageName,
+            }
       ),
     },
     {
@@ -111,11 +134,101 @@ export function createAndroidModule({
     Logger.logDebug(`Created file: ${filePath}`);
   }
 
+  syncAndroidModuleExpoUpdatesFromAppFiles({
+    androidDir,
+    config,
+  });
+
   Logger.logDebug(
     `Android module "${android.moduleName}" created at ${moduleDir}`
   );
 }
 
+export function syncAndroidModuleManifest({
+  androidDir,
+  config,
+  expoUpdatesMetaData,
+}: {
+  androidDir: string;
+  config: ResolvedBrownfieldPluginConfigWithAndroid;
+  expoUpdatesMetaData: AndroidManifestMetaDataEntry[];
+}): void {
+  writeAndroidModuleFile(
+    path.join(androidDir, config.android.moduleName),
+    'src/main/AndroidManifest.xml',
+    renderTemplate('android', 'AndroidManifest.xml', {
+      '{{APPLICATION_BLOCK}}':
+        renderLibraryManifestApplication(expoUpdatesMetaData),
+    })
+  );
+}
+
+export function syncAndroidModuleStringResources({
+  androidDir,
+  config,
+  expoUpdatesStringResources,
+}: {
+  androidDir: string;
+  config: ResolvedBrownfieldPluginConfigWithAndroid;
+  expoUpdatesStringResources: AndroidStringResourceEntry[];
+}): void {
+  writeAndroidModuleFile(
+    path.join(androidDir, config.android.moduleName),
+    'src/main/res/values/strings.xml',
+    renderTemplate('android', 'strings.xml', {
+      '{{STRING_RESOURCES}}': renderLibraryStringResources(
+        expoUpdatesStringResources
+      ),
+    })
+  );
+}
+
+function writeAndroidModuleFile(
+  moduleDir: string,
+  relativePath: string,
+  content: string
+): void {
+  const filePath = path.join(moduleDir, relativePath);
+  const fileDir = path.dirname(filePath);
+
+  if (!fs.existsSync(fileDir)) {
+    fs.mkdirSync(fileDir, { recursive: true });
+  }
+
+  fs.writeFileSync(filePath, content, 'utf8');
+  Logger.logDebug(`Created file: ${filePath}`);
+}
+
+export function syncAndroidModuleExpoUpdatesFromAppFiles({
+  androidDir,
+  config,
+}: {
+  androidDir: string;
+  config: ResolvedBrownfieldPluginConfigWithAndroid;
+}): void {
+  const appModuleName = 'app';
+  const expoUpdatesMetaData = readExpoUpdatesApplicationMetaData(
+    androidDir,
+    appModuleName
+  );
+  const expoUpdatesStringResources = readExpoUpdatesStringResources(
+    androidDir,
+    appModuleName,
+    expoUpdatesMetaData
+  );
+
+  syncAndroidModuleManifest({
+    androidDir,
+    config,
+    expoUpdatesMetaData,
+  });
+  syncAndroidModuleStringResources({
+    androidDir,
+    config,
+    expoUpdatesStringResources,
+  });
+}
+
 /**
  * Dangerous mod that creates the Android module directory and files
  */
@@ -154,6 +267,7 @@ export const withAndroidModuleFiles: ConfigPlugin<
         config: props,
         rnVersion,
         isExpoPre55,
+        projectRoot: dangerousConfig.modRequest.projectRoot,
       });
 
       return dangerousConfig;

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

@@ -1,6 +1,7 @@
 import {
   withProjectBuildGradle,
   withSettingsGradle,
+  withFinalizedMod,
   type ConfigPlugin,
 } from '@expo/config-plugins';
 
@@ -8,7 +9,10 @@ import {
   modifyRootBuildGradle,
   modifySettingsGradle,
 } from './utils/gradleHelpers';
-import { withAndroidModuleFiles } from './withAndroidModuleFiles';
+import {
+  syncAndroidModuleExpoUpdatesFromAppFiles,
+  withAndroidModuleFiles,
+} from './withAndroidModuleFiles';
 import type { ResolvedBrownfieldPluginConfigWithAndroid } from '../types';
 
 /**
@@ -47,5 +51,18 @@ export const withBrownfieldAndroid: ConfigPlugin<
   // Step 3: create the Android module files using dangerous mod
   config = withAndroidModuleFiles(config, props);
 
+  // Step 4: sync module metadata after Expo writes all Android files
+  config = withFinalizedMod(config, [
+    'android',
+    async (finalizedConfig) => {
+      syncAndroidModuleExpoUpdatesFromAppFiles({
+        androidDir: finalizedConfig.modRequest.platformProjectRoot,
+        config: props,
+      });
+
+      return finalizedConfig;
+    },
+  ]);
+
   return config;
 };

package/src/expo-config-plugin/expoUtils.ts

@@ -10,3 +10,17 @@ export function getExpoInfo(config: ExpoConfig) {
     isExpoPre55,
   };
 }
+
+export function hasExpoUpdatesInstalled(
+  projectRoot: string | undefined
+): boolean {
+  if (!projectRoot) return false;
+  try {
+    require.resolve('expo-updates/package.json', {
+      paths: [projectRoot],
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/expo-config-plugin/ios/utils/expo-updates.ts

@@ -0,0 +1,168 @@
+import type { XcodeProject } from '@expo/config-plugins';
+
+import { Logger } from '../../logging';
+import { SourceModificationError } from '../../errors/SourceModificationError';
+import { ensureTargetHasFileReferenceInResourcesBuildPhase } from '../xcodeHelpers';
+
+type PbxFileReference = {
+  [key: string]: unknown;
+  name?: string;
+  path?: string;
+};
+
+type PbxGroupLike = {
+  [key: string]: unknown;
+  name?: string;
+  path?: string;
+  children?: Array<{ value?: string; comment?: string } | string>;
+};
+
+const EXPO_PLIST_FILE_NAME = 'Expo.plist';
+const EXPO_PLIST_PRIMARY_RELATIVE_PATH = 'Supporting/Expo.plist';
+const RESOURCES_BUILD_PHASE_COMMENT = 'Resources';
+const EXPO_PLIST_RESOURCE_COMMENT = 'Expo.plist in Resources';
+
+function normalizePbxString(value: unknown): string {
+  return String(value ?? '').replace(/^"(.*)"$/, '$1');
+}
+
+function normalizePbxPathLike(value: unknown): string {
+  return normalizePbxString(value).replace(/^\.\//, '');
+}
+
+function isSupportingGroup(group: PbxGroupLike): boolean {
+  const groupName = normalizePbxString(group.name);
+  const groupPath = normalizePbxString(group.path);
+
+  return (
+    groupName === 'Supporting' ||
+    groupPath === 'Supporting' ||
+    groupPath.endsWith('/Supporting')
+  );
+}
+
+function groupContainsFileReference(
+  group: PbxGroupLike,
+  fileRefUuid: string
+): boolean {
+  const children = Array.isArray(group.children) ? group.children : [];
+
+  return children.some((child) => {
+    if (typeof child === 'string') {
+      return child === fileRefUuid;
+    }
+
+    return child?.value === fileRefUuid;
+  });
+}
+
+function isPrimaryExpoPlistMatch(
+  fileRefUuid: string,
+  fileRef: PbxFileReference,
+  groups?: Record<string, PbxGroupLike | string>
+): boolean {
+  const normalizedPath = normalizePbxPathLike(fileRef.path);
+  const fileName = normalizePbxString(fileRef.name);
+
+  if (
+    normalizedPath === EXPO_PLIST_PRIMARY_RELATIVE_PATH ||
+    normalizedPath.endsWith(`/${EXPO_PLIST_PRIMARY_RELATIVE_PATH}`)
+  ) {
+    return true;
+  }
+
+  if (
+    normalizedPath !== EXPO_PLIST_FILE_NAME &&
+    fileName !== EXPO_PLIST_FILE_NAME
+  ) {
+    return false;
+  }
+
+  return Object.entries(groups ?? {}).some(([groupUuid, group]) => {
+    if (groupUuid.endsWith('_comment') || typeof group === 'string') {
+      return false;
+    }
+
+    return (
+      isSupportingGroup(group) && groupContainsFileReference(group, fileRefUuid)
+    );
+  });
+}
+
+/**
+ * Selects an existing PBXFileReference for the app-level Expo plist.
+ *
+ * Matches either:
+ * - a file reference whose own path is `Supporting/Expo.plist`
+ * - or an `Expo.plist` file reference that lives under a `Supporting` PBXGroup
+ */
+export function selectExpoPlistFileReference(
+  fileReferences: Record<string, PbxFileReference | string>,
+  groups?: Record<string, PbxGroupLike | string>
+): string | null {
+  for (const [fileRefUuid, fileRef] of Object.entries(fileReferences)) {
+    if (fileRefUuid.endsWith('_comment') || typeof fileRef === 'string') {
+      continue;
+    }
+
+    if (isPrimaryExpoPlistMatch(fileRefUuid, fileRef, groups)) {
+      return fileRefUuid;
+    }
+  }
+
+  return null;
+}
+
+function getExpoPlistFileRefOrThrow(project: XcodeProject): string {
+  const fileReferences = project.pbxFileReferenceSection() as Record<
+    string,
+    PbxFileReference | string
+  >;
+  const groups = (project as any).hash?.project?.objects?.PBXGroup as
+    | Record<string, PbxGroupLike | string>
+    | undefined;
+  const existingExpoPlistFileRefUuid = selectExpoPlistFileReference(
+    fileReferences,
+    groups
+  );
+
+  if (existingExpoPlistFileRefUuid) {
+    return existingExpoPlistFileRefUuid;
+  }
+
+  throw new SourceModificationError(
+    `Could not find the "${EXPO_PLIST_PRIMARY_RELATIVE_PATH}" PBXFileReference needed for Expo.plist resource wiring`
+  );
+}
+
+/**
+ * Ensures the framework target contains the app-level `Supporting/Expo.plist`
+ * in a `PBXResourcesBuildPhase`. This is idempotent and safe to call repeatedly.
+ */
+export function ensureFrameworkHasExpoPlistResource(
+  project: XcodeProject,
+  frameworkTargetUUID: string
+): void {
+  const expoPlistFileRefUuid = getExpoPlistFileRefOrThrow(project);
+  const didAddExpoPlistResource =
+    ensureTargetHasFileReferenceInResourcesBuildPhase(
+      project,
+      frameworkTargetUUID,
+      expoPlistFileRefUuid,
+      {
+        resourcesBuildPhaseComment: RESOURCES_BUILD_PHASE_COMMENT,
+        buildFileComment: EXPO_PLIST_RESOURCE_COMMENT,
+      }
+    );
+
+  if (!didAddExpoPlistResource) {
+    Logger.logDebug(
+      'Framework resources already include Supporting/Expo.plist'
+    );
+    return;
+  }
+
+  Logger.logDebug(
+    'Added Supporting/Expo.plist to framework PBXResourcesBuildPhase'
+  );
+}

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

@@ -11,10 +11,11 @@ import {
   copyBundleReactNativePhase,
 } from './xcodeHelpers';
 import { modifyPodfile } from './podfileHelpers';
+import { ensureFrameworkHasExpoPlistResource } from './utils/expo-updates';
 import { withIosFrameworkFiles } from './withIosFrameworkFiles';
 import type { ResolvedBrownfieldPluginConfigWithIos } from '../types';
 import { Logger } from '../logging';
-import { getExpoInfo } from '../expoUtils';
+import { getExpoInfo, hasExpoUpdatesInstalled } from '../expoUtils';
 
 /**
  * iOS Config Plugin for integration with @callstack/react-native-brownfield.
@@ -34,6 +35,7 @@ export const withBrownfieldIos: ConfigPlugin<
   // Step 1: modify the Xcode project to add framework target &
   config = withXcodeProject(config, (xcodeConfig) => {
     const { modResults: project, modRequest } = xcodeConfig;
+    const hasExpoUpdates = hasExpoUpdatesInstalled(modRequest.projectRoot);
 
     const { frameworkTargetUUID, targetAlreadyExists } = addFrameworkTarget(
       project,
@@ -41,6 +43,16 @@ export const withBrownfieldIos: ConfigPlugin<
       props.ios
     );
 
+    // Ensure Expo.plist is present in the framework resources phase when
+    // expo-updates is installed, including for pre-existing framework targets.
+    if (hasExpoUpdates) {
+      ensureFrameworkHasExpoPlistResource(project, frameworkTargetUUID);
+    } else {
+      Logger.logDebug(
+        'Skipping Expo.plist framework resource wiring because expo-updates is not installed'
+      );
+    }
+
     if (targetAlreadyExists) {
       Logger.logDebug(
         `Skipping further Xcode modifications as framework target was already present`