@expo/repack-app 0.0.5 → 0.1.0

package/build/android/resources.js

@@ -3,176 +3,171 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.updateAndroidManifestAsync = exports.updateResourcesAsync = void 0;
+exports.queryAppIdFromManifestAsync = exports.buildXmlFileAsync = exports.parseXmlFileAsync = exports.updateAndroidManifestAsync = exports.updateResourcesAsync = void 0;
 const node_assert_1 = __importDefault(require("node:assert"));
 const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
-const protobufjs_1 = __importDefault(require("protobufjs"));
+const xml2js_1 = require("xml2js");
 const utils_1 = require("../utils");
 /**
- * Update resources inside the **resources.pb** file.
+ * Update resources in the decoded APK.
  */
-async function updateResourcesAsync(config, resourcesPbFilePath) {
-    const root = await protobufjs_1.default.load(node_path_1.default.join(__dirname, '../../assets', 'Resources.proto'));
-    const resourceTableType = root.lookupType('aapt.pb.ResourceTable');
-    const resourceTable = await decodeProtoFile(resourceTableType, resourcesPbFilePath);
-    // [0] Update the package name
-    (0, node_assert_1.default)(resourceTable.package.length === 1, 'Expected only one package');
-    (0, node_assert_1.default)(config.android?.package, 'Expected android.package to be defined');
-    resourceTable.package[0].packageName = config.android.package;
-    const stringType = resourceTable.package[0].type.find((type) => type.name === 'string');
-    const stringEntries = stringType?.entry;
-    // [1] Update the `app_name` in **res/values/strings.xml**.
-    const appNameEntry = stringEntries?.find((entry) => entry.name === 'app_name');
-    (0, node_assert_1.default)(appNameEntry?.configValue?.[0].value?.item?.str?.value === 'HelloWorld', 'Expected app_name to be predefined "HelloWorld"');
-    appNameEntry.configValue[0].value.item.str.value = config.name;
-    await encodeProtoFile(resourceTableType, resourcesPbFilePath, resourceTable);
+async function updateResourcesAsync({ config, decodedApkRoot, }) {
+    // [0] Update the `app_name` in **res/values/strings.xml**.
+    const stringsXmlPath = node_path_1.default.join(decodedApkRoot, 'res', 'values', 'strings.xml');
+    let stringsXml = await promises_1.default.readFile(stringsXmlPath, 'utf8');
+    stringsXml = stringsXml.replace(/(<string name="app_name">)(.+)(<\/string>)/, `$1${config.name}$3`);
+    await promises_1.default.writeFile(stringsXmlPath, stringsXml);
 }
 exports.updateResourcesAsync = updateResourcesAsync;
 /**
  * Update the proto-based AndroidManiest.xml.
  */
-async function updateAndroidManifestAsync(config, androidManiestFilePath, options, updatesRuntimeVersion) {
-    const root = await protobufjs_1.default.load(node_path_1.default.join(__dirname, '../../assets', 'Resources.proto'));
-    const xmlNodeType = root.lookupType('aapt.pb.XmlNode');
-    const rootNode = await decodeProtoFile(xmlNodeType, androidManiestFilePath);
+async function updateAndroidManifestAsync({ config, androidManiestXml, dexClasses, originalAppId, updatesRuntimeVersion, }) {
     // [0] Update the package name
-    replaceXmlAttributeValue(rootNode, (value) => value.replace(/dev\.expo\.templatedefault\.appid/g, (0, utils_1.requireNotNull)(config.android?.package)));
+    const appId = (0, utils_1.requireNotNull)(config.android?.package);
+    androidManiestXml.manifest.$.package = appId;
+    replaceXmlAttributeValue(androidManiestXml, (value) => {
+        if (value.startsWith(originalAppId) && !dexClasses.has(value)) {
+            return value.replace(originalAppId, appId);
+        }
+        return value;
+    });
     // [1] Update the scheme in the intent-filters
-    const intentFilterViewActionNodes = findXmlNodes(rootNode, (node) => node.element?.name === 'intent-filter' &&
-        findXmlNodes(node, (node) => node.element?.name === 'action' &&
-            node.element?.attribute[0]?.value === 'android.intent.action.VIEW').length > 0);
+    const intentFilterViewActionNodes = findXmlNodes('manifest', androidManiestXml.manifest, (nodeName, node) => nodeName === 'intent-filter' &&
+        findXmlNodes(nodeName, node, (nodeName, node) => nodeName === 'action' && node[0].$?.['android:name'] === 'android.intent.action.VIEW').length > 0);
     const firstScheme = Array.isArray(config.scheme) ? config.scheme[0] : config.scheme;
     for (const node of intentFilterViewActionNodes) {
         replaceXmlAttributeValue(node, (value) => value
             // scheme in app.json
             .replace(/^myapp$/g, (0, utils_1.requireNotNull)(firstScheme))
             // android.package in app.json
-            .replace(/^dev\.expo\.templatedefault$/g, (0, utils_1.requireNotNull)(config.android?.package))
+            .replace(originalAppId, appId)
             // default scheme generated from slug in app.json
-            .replace(/^exp\+expo-template-default$/g, `exp+${(0, utils_1.requireNotNull)(config.slug)}`));
+            .replace(/^exp\+.+$/g, `exp+${(0, utils_1.requireNotNull)(config.slug)}`));
     }
     // [2] expo-updates configuration
-    const mainApplicationNode = findXmlNodes(rootNode, (node) => node.element?.name === 'application' &&
-        node.element?.attribute.find((attr) => attr.name === 'name' && attr.value.endsWith('.MainApplication')) != null)[0];
-    (0, node_assert_1.default)(mainApplicationNode != null, 'Expected application node to be present');
-    mutateExpoUpdatesConfigAsync(mainApplicationNode, config, updatesRuntimeVersion);
-    await encodeProtoFile(xmlNodeType, androidManiestFilePath, rootNode);
+    const mainApplicationNode = androidManiestXml.manifest.application[0];
+    (0, node_assert_1.default)(mainApplicationNode.$?.['android:name']?.endsWith('.MainApplication'), 'Expected application node to be named as MainApplication');
+    if (updatesRuntimeVersion) {
+        mutateExpoUpdatesConfigAsync(mainApplicationNode, config, updatesRuntimeVersion);
+    }
 }
 exports.updateAndroidManifestAsync = updateAndroidManifestAsync;
+/**
+ * Parse the XML file.
+ */
+async function parseXmlFileAsync(filePath) {
+    const contents = await promises_1.default.readFile(filePath, 'utf8');
+    const parser = new xml2js_1.Parser();
+    const xmlJs = await parser.parseStringPromise(contents);
+    return xmlJs;
+}
+exports.parseXmlFileAsync = parseXmlFileAsync;
+/**
+ * Build the XML file from the given node.
+ */
+async function buildXmlFileAsync(rootNode, filePath) {
+    const builder = new xml2js_1.Builder();
+    const xmlString = builder.buildObject(rootNode);
+    await promises_1.default.writeFile(filePath, xmlString);
+}
+exports.buildXmlFileAsync = buildXmlFileAsync;
+/**
+ * Query the app ID from the AndroidManiest.xml.
+ */
+async function queryAppIdFromManifestAsync(androidManiestXml) {
+    const packageAttr = androidManiestXml.manifest.$.package;
+    (0, node_assert_1.default)(packageAttr != null, 'Expected package attribute to be present in AndroidManifest.xml');
+    return packageAttr;
+}
+exports.queryAppIdFromManifestAsync = queryAppIdFromManifestAsync;
 //#region Internals
 /**
  * Update the `expo-updates` configuration in the Android project.
  */
 function mutateExpoUpdatesConfigAsync(mainApplicationNode, config, runtimeVersion) {
-    const updateEnabledNodeIndex = mainApplicationNode.element?.child.findIndex((child) => child.element?.name === 'meta-data' &&
-        child.element?.attribute.find((attr) => attr.name === 'name' && attr.value === 'expo.modules.updates.ENABLED'));
-    (0, node_assert_1.default)(updateEnabledNodeIndex != null && updateEnabledNodeIndex >= 0, `Expected 'expo.modules.updates.ENABLED' node to be present`);
-    const updateEnabledNode = (0, utils_1.requireNotNull)(mainApplicationNode.element?.child[updateEnabledNodeIndex]);
+    const metaDataNodes = mainApplicationNode['meta-data'] ?? [];
     // [0] expo.modules.updates.ENABLED
-    const updateEnabledPrimValue = updateEnabledNode.element?.attribute?.[1]?.compiledItem?.prim;
-    (0, node_assert_1.default)(updateEnabledPrimValue != null, 'Expected updateEnabledPrimValue to be present');
-    updateEnabledPrimValue.booleanValue = true;
+    const updateEnabledNode = metaDataNodes.find((node) => node.$?.['android:name'] === 'expo.modules.updates.ENABLED');
+    if (updateEnabledNode != null) {
+        (0, node_assert_1.default)(updateEnabledNode.$ != null);
+        updateEnabledNode.$['android:value'] = 'true';
+    }
+    else {
+        metaDataNodes.push({
+            $: {
+                'android:name': 'expo.modules.updates.ENABLED',
+                'android:value': 'true',
+            },
+        });
+    }
     // [1] expo.modules.updates.EXPO_RUNTIME_VERSION
-    const updateRuntimeVersionNode = mainApplicationNode.element?.child.find((child) => child.element?.name === 'meta-data' &&
-        child.element?.attribute.find((attr) => attr.name === 'name' && attr.value === 'expo.modules.updates.EXPO_RUNTIME_VERSION'));
-    if (updateRuntimeVersionNode == null) {
-        mainApplicationNode.element?.child.splice(updateEnabledNodeIndex + 1, 0, createUpdateStringNode(updateEnabledNode, 'expo.modules.updates.EXPO_RUNTIME_VERSION', runtimeVersion));
+    const updateRuntimeVersionNode = metaDataNodes.find((node) => node.$?.['android:name'] === 'expo.modules.updates.EXPO_RUNTIME_VERSION');
+    if (updateRuntimeVersionNode != null) {
+        (0, node_assert_1.default)(updateRuntimeVersionNode.$ != null);
+        updateRuntimeVersionNode.$['android:value'] = runtimeVersion;
     }
     else {
-        (0, node_assert_1.default)(updateRuntimeVersionNode.element != null);
-        updateRuntimeVersionNode.element.attribute[1].value = runtimeVersion;
+        metaDataNodes.push({
+            $: {
+                'android:name': 'expo.modules.updates.EXPO_RUNTIME_VERSION',
+                'android:value': runtimeVersion,
+            },
+        });
     }
     // [2] expo.modules.updates.EXPO_UPDATE_URL
-    const updateUrlNode = mainApplicationNode.element?.child.find((child) => child.element?.name === 'meta-data' &&
-        child.element?.attribute.find((attr) => attr.name === 'name' && attr.value === 'expo.modules.updates.EXPO_UPDATE_URL'));
+    const updateUrlNode = metaDataNodes.find((node) => node.$?.['android:name'] === 'expo.modules.updates.EXPO_UPDATE_URL');
     const updateUrl = config.updates?.url;
     (0, node_assert_1.default)(updateUrl);
-    if (updateUrlNode == null) {
-        mainApplicationNode.element?.child.splice(updateEnabledNodeIndex + 1, 0, createUpdateStringNode(updateEnabledNode, 'expo.modules.updates.EXPO_UPDATE_URL', updateUrl));
+    if (updateUrlNode != null) {
+        (0, node_assert_1.default)(updateUrlNode.$ != null);
+        updateUrlNode.$['android:value'] = updateUrl;
     }
     else {
-        (0, node_assert_1.default)(updateUrlNode.element != null);
-        updateUrlNode.element.attribute[1].value = updateUrl;
+        metaDataNodes.push({
+            $: {
+                'android:name': 'expo.modules.updates.EXPO_UPDATE_URL',
+                'android:value': updateUrl,
+            },
+        });
     }
 }
-/**
- * Decode the proto-encoded file from `filePath` with the given `protoTypeString` and return as JSON object.
- */
-async function decodeProtoFile(protoType, filePath) {
-    const buffer = await promises_1.default.readFile(filePath);
-    const message = await protoType.decode(buffer);
-    const json = protoType.toObject(message, {
-        longs: String,
-        enums: String,
-        bytes: String,
-        defaults: true,
-        arrays: true,
-        objects: true,
-        oneofs: true,
-    });
-    return json;
-}
-async function encodeProtoFile(protoType, filePath, json) {
-    const updatedMessage = protoType.fromObject(json);
-    const updatedBuffer = protoType.encode(updatedMessage).finish();
-    await promises_1.default.writeFile(filePath, updatedBuffer);
-}
 /**
  * Recursively find XML nodes that satisfy the given `predicate`.
  */
-function findXmlNodes(rootNode, predicate) {
-    if (rootNode.element == null) {
+function findXmlNodes(rootNodeName, rootNode, predicate) {
+    if (rootNode == null) {
         return [];
     }
-    if (predicate(rootNode)) {
+    if (predicate(rootNodeName, rootNode)) {
         return [rootNode];
     }
-    return rootNode.element.child.flatMap((child) => findXmlNodes(child, predicate));
+    return Object.keys(rootNode)
+        .filter((key) => key !== '$' && key !== '_')
+        .flatMap((key) => {
+        const node = rootNode[key];
+        return findXmlNodes(key, node, predicate);
+    });
 }
 /**
  * Recursively replace the attribute values in the XML nodes's attributes.
  */
 function replaceXmlAttributeValue(node, replacer) {
-    if (node.element == null) {
+    if (node == null) {
         return;
     }
-    const attrs = node.element.attribute;
-    for (const attr of attrs) {
-        attr.value = replacer(attr.value);
+    const attrs = node.$ ?? {};
+    for (const [attrKey, attrValue] of Object.entries(attrs)) {
+        attrs[attrKey] = replacer(attrValue);
     }
-    for (const child of node.element.child) {
-        replaceXmlAttributeValue(child, replacer);
+    for (const [nodeKey, nodeValue] of Object.entries(node)) {
+        if (nodeKey === '$' || nodeKey === '_') {
+            continue;
+        }
+        else {
+            replaceXmlAttributeValue(nodeValue, replacer);
+        }
     }
 }
-/**
- * Create a new `meta-data` node with the given `name` and `value`.
- * We use the `updateEnabledNode` as the source to clone most of the properties.
- */
-function createUpdateStringNode(updateEnabledNode, name, value) {
-    return {
-        ...updateEnabledNode,
-        element: {
-            ...(0, utils_1.requireNotNull)(updateEnabledNode.element),
-            attribute: [
-                {
-                    namespaceUri: 'http://schemas.android.com/apk/res/android',
-                    name: 'name',
-                    value: name,
-                    source: null,
-                    resourceId: 16842755,
-                    compiledItem: null,
-                },
-                {
-                    namespaceUri: 'http://schemas.android.com/apk/res/android',
-                    name: 'value',
-                    value,
-                    source: null,
-                    resourceId: 16842788,
-                    compiledItem: null,
-                },
-            ],
-        },
-    };
-}
 //#endregion

package/build/cli.js

@@ -22,6 +22,9 @@ const program = new commander_1.Command('repack-app')
     // iOS signing options
     .option('--signing-identity <identity>', 'Signing identity')
     .option('--provisioning-profile <path>', 'Path to the provisioning profile')
+    // export:embed options
+    .option('--embed-bundle-assets', 'Whether to execute export:embed to embed new bundle assets')
+    .option('--bundle-assets-sourcemap-output <path>', 'Paired with --embed-bundle-assets and generate the sourcemap to the specified path')
     // arguments
     .argument('<project-root>', 'Path to the project root')
     .parse(process.argv);
@@ -29,6 +32,12 @@ async function runAsync() {
     const logger = (0, logger_1.createLogger)({ name: 'repack-app' });
     const platform = program.opts().platform;
     const projectRoot = program.args[0];
+    const exportEmbedOptions = program.opts()
+        .embedBundleAssets
+        ? {
+            sourcemapOutput: program.opts().bundleAssetsSourcemapOutput,
+        }
+        : undefined;
     if (platform === 'android') {
         const outputPath = await (0, index_1.repackAppAndroidAsync)({
             platform: program.opts().platform,
@@ -37,6 +46,7 @@ async function runAsync() {
             sourceAppPath: program.opts().sourceApp,
             workingDirectory: program.opts().workingDirectory,
             outputPath: program.opts().output,
+            exportEmbedOptions,
             androidSigningOptions: {
                 keyStorePath: program.opts().ks,
                 keyStorePassword: program.opts().ksPass,
@@ -49,6 +59,12 @@ async function runAsync() {
         logger.info(picocolors_1.default.green(`Updated APK created at ${outputPath}`));
     }
     else if (platform === 'ios') {
+        const iosSigningOptions = program.opts().signingIdentity && program.opts().provisioningProfile
+            ? {
+                signingIdentity: program.opts().signingIdentity,
+                provisioningProfile: program.opts().provisioningProfile,
+            }
+            : undefined;
         const options = {
             platform: program.opts().platform,
             projectRoot,
@@ -56,10 +72,8 @@ async function runAsync() {
             sourceAppPath: program.opts().sourceApp,
             workingDirectory: program.opts().workingDirectory,
             outputPath: program.opts().output,
-            iosSigningOptions: {
-                signingIdentity: program.opts().signingIdentity,
-                provisioningProfile: program.opts().provisioningProfile,
-            },
+            exportEmbedOptions,
+            iosSigningOptions,
             logger,
         };
         const outputPath = await (0, index_1.repackAppIosAsync)(options);

package/build/expo.d.ts

@@ -4,7 +4,18 @@ import type { NormalizedOptions } from './types';
  * Generate the app.config file for the Android app.
  */
 export declare function generateAppConfigAsync(options: NormalizedOptions, config: ExpoConfig): Promise<string>;
+/**
+ * Returns whether expo-updates is installed in the project.
+ */
+export declare function isExpoUpdatesInstalled(projectRoot: string): boolean;
 /**
  * Resolve the `runtimeVersion` for expo-updates.
  */
 export declare function resolveRuntimeVersionAsync(options: NormalizedOptions, config: ExpoConfig): Promise<string>;
+/**
+ * Generate JS bundle and assets for the app.
+ */
+export declare function generateBundleAssetsAsync(expoConfig: ExpoConfig, options: NormalizedOptions): Promise<{
+    bundleOutputPath: string;
+    assetRoot: string;
+}>;

package/build/expo.js

@@ -3,7 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveRuntimeVersionAsync = exports.generateAppConfigAsync = void 0;
+exports.generateBundleAssetsAsync = exports.resolveRuntimeVersionAsync = exports.isExpoUpdatesInstalled = exports.generateAppConfigAsync = void 0;
+const config_1 = require("@expo/config");
 const steps_1 = require("@expo/steps");
 const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
@@ -18,6 +19,14 @@ async function generateAppConfigAsync(options, config) {
     return appConfigPath;
 }
 exports.generateAppConfigAsync = generateAppConfigAsync;
+/**
+ * Returns whether expo-updates is installed in the project.
+ */
+function isExpoUpdatesInstalled(projectRoot) {
+    const packageJson = (0, config_1.getPackageJson)(projectRoot);
+    return !!(packageJson.dependencies && 'expo-updates' in packageJson.dependencies);
+}
+exports.isExpoUpdatesInstalled = isExpoUpdatesInstalled;
 /**
  * Resolve the `runtimeVersion` for expo-updates.
  */
@@ -32,3 +41,67 @@ async function resolveRuntimeVersionAsync(options, config) {
     return runtimeVersion ?? config.version ?? '1.0.0';
 }
 exports.resolveRuntimeVersionAsync = resolveRuntimeVersionAsync;
+/**
+ * Generate JS bundle and assets for the app.
+ */
+async function generateBundleAssetsAsync(expoConfig, options) {
+    const { projectRoot, platform, workingDirectory } = options;
+    const bundleAssetRoot = node_path_1.default.resolve(workingDirectory, 'bundles');
+    await promises_1.default.mkdir(bundleAssetRoot, { recursive: true });
+    // [0] Resolve entry point
+    const { stdout: entryFile } = await (0, steps_1.spawnAsync)('node', ['-e', "require('expo/scripts/resolveAppEntry')", projectRoot, platform, 'absolute'], { cwd: projectRoot });
+    // [1] Execute export:embed
+    const isEnableHermes = isEnableHermesManaged(expoConfig, platform);
+    const bundleFileName = platform === 'android' ? 'index.android.bundle' : 'main.bundle';
+    const bundleOutputPath = node_path_1.default.join(bundleAssetRoot, bundleFileName);
+    const assetRoot = node_path_1.default.join(bundleAssetRoot, 'assets');
+    const exportEmbedArgs = [
+        'expo',
+        'export:embed',
+        '--platform',
+        platform,
+        '--entry-file',
+        entryFile.trim(),
+        '--bundle-output',
+        node_path_1.default.join(bundleAssetRoot, bundleFileName),
+        '--assets-dest',
+        node_path_1.default.join(bundleAssetRoot, 'assets'),
+        '--dev',
+        'false',
+        '--reset-cache',
+    ];
+    if (isEnableHermes) {
+        exportEmbedArgs.push('--minify', 'false');
+        exportEmbedArgs.push('--bundle-bytecode', 'true');
+        exportEmbedArgs.push('--unstable-transform-profile', 'hermes');
+    }
+    else {
+        exportEmbedArgs.push('--minify', 'true');
+    }
+    if (options.exportEmbedOptions?.sourcemapOutput) {
+        exportEmbedArgs.push('--sourcemap-output', options.exportEmbedOptions.sourcemapOutput);
+    }
+    await (0, steps_1.spawnAsync)('npx', exportEmbedArgs, options.verbose
+        ? { logger: options.logger, stdio: 'pipe', cwd: projectRoot }
+        : { cwd: projectRoot });
+    return {
+        bundleOutputPath,
+        assetRoot,
+    };
+}
+exports.generateBundleAssetsAsync = generateBundleAssetsAsync;
+/**
+ * Determine whether Hermes is enabled for the project.
+ */
+function isEnableHermesManaged(expoConfig, platform) {
+    switch (platform) {
+        case 'android': {
+            return (expoConfig.android?.jsEngine ?? expoConfig.jsEngine) !== 'jsc';
+        }
+        case 'ios': {
+            return (expoConfig.ios?.jsEngine ?? expoConfig.jsEngine) !== 'jsc';
+        }
+        default:
+            return false;
+    }
+}

package/build/index.d.ts

@@ -1,2 +1,3 @@
 export { repackAppAndroidAsync } from './android';
 export { repackAppIosAsync } from './ios';
+export * from './types';

package/build/index.js

@@ -1,7 +1,22 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.repackAppIosAsync = exports.repackAppAndroidAsync = void 0;
 var android_1 = require("./android");
 Object.defineProperty(exports, "repackAppAndroidAsync", { enumerable: true, get: function () { return android_1.repackAppAndroidAsync; } });
 var ios_1 = require("./ios");
 Object.defineProperty(exports, "repackAppIosAsync", { enumerable: true, get: function () { return ios_1.repackAppIosAsync; } });
+__exportStar(require("./types"), exports);

package/build/ios/build-tools.d.ts

@@ -1,5 +1,5 @@
 import { type ExpoConfig } from '@expo/config';
-import type { NormalizedOptions } from '../types';
+import type { IosSigningOptions, NormalizedOptions } from '../types';
 /**
  * Unzip the IPA file.
  */
@@ -12,3 +12,7 @@ export declare function updateFilesAsync(config: ExpoConfig, appWorkingDirectory
  * From the given working .app directory, create a new .ipa file.
  */
 export declare function createIpaAsync(options: NormalizedOptions, appWorkingDirectory: string): Promise<string>;
+/**
+ * Create a Fastfile lane for resigning an IPA.
+ */
+export declare function createResignLane(laneName: string, ipaPath: string, signingOptions: IosSigningOptions): string;

package/build/ios/build-tools.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createIpaAsync = exports.updateFilesAsync = exports.unzipIpaAsync = void 0;
+exports.createResignLane = exports.createIpaAsync = exports.updateFilesAsync = exports.unzipIpaAsync = void 0;
 const steps_1 = require("@expo/steps");
 const node_assert_1 = __importDefault(require("node:assert"));
 const promises_1 = __importDefault(require("node:fs/promises"));
@@ -40,10 +40,45 @@ async function createIpaAsync(options, appWorkingDirectory) {
     const { workingDirectory } = options;
     await promises_1.default.mkdir(node_path_1.default.join(workingDirectory, 'Payload'), { recursive: true });
     await promises_1.default.rename(appWorkingDirectory, node_path_1.default.join(workingDirectory, 'Payload', node_path_1.default.basename(appWorkingDirectory)));
-    const outputIpaPath = node_path_1.default.join(workingDirectory, 'repacked.ipa');
+    const outputIpaPath = node_path_1.default.resolve(workingDirectory, 'repacked.ipa');
     await (0, steps_1.spawnAsync)('zip', ['-r', outputIpaPath, 'Payload'], options.verbose
         ? { logger: options.logger, stdio: 'pipe', cwd: workingDirectory }
         : { cwd: workingDirectory });
     return outputIpaPath;
 }
 exports.createIpaAsync = createIpaAsync;
+/**
+ * Create a Fastfile lane for resigning an IPA.
+ */
+function createResignLane(laneName, ipaPath, signingOptions) {
+    const keychainPath = signingOptions.keychainPath
+        ? `keychain_path: "${signingOptions.keychainPath}",`
+        : '';
+    let provisioningProfile;
+    if (typeof signingOptions.provisioningProfile === 'string') {
+        provisioningProfile = `provisioning_profile: "${signingOptions.provisioningProfile}",`;
+    }
+    else if (typeof signingOptions.provisioningProfile === 'object' &&
+        !Array.isArray(signingOptions.provisioningProfile)) {
+        let profileHash = '';
+        for (const [key, value] of Object.entries(signingOptions.provisioningProfile)) {
+            profileHash += `      "${key}" => "${value}",\n`;
+        }
+        provisioningProfile = `provisioning_profile: {\n${profileHash}\n    },`;
+    }
+    else {
+        provisioningProfile = '';
+    }
+    const fastfileContents = `\
+lane :${laneName} do
+  resign(
+    ipa: "${ipaPath}",
+    signing_identity: "${signingOptions.signingIdentity}",
+    ${keychainPath}
+    ${provisioningProfile}
+  )
+end
+`;
+    return fastfileContents.replace(/^\s*[\r\n]/gm, '');
+}
+exports.createResignLane = createResignLane;

package/build/ios/index.d.ts

@@ -6,4 +6,4 @@ export declare function repackAppIosAsync(_options: Options): Promise<string>;
 /**
  * Resign an IPA by fastlane.
  */
-export declare function resignIpaAsync(ipaPath: string, signingOptions: IosSigningOptions, options: Options): Promise<void>;
+export declare function resignIpaAsync(ipaPath: string, signingOptions: IosSigningOptions, _options: Options): Promise<void>;

package/build/ios/index.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.resignIpaAsync = exports.repackAppIosAsync = void 0;
 const config_1 = require("@expo/config");
 const steps_1 = require("@expo/steps");
+const node_assert_1 = __importDefault(require("node:assert"));
 const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
 const picocolors_1 = __importDefault(require("picocolors"));
@@ -24,14 +25,31 @@ async function repackAppIosAsync(_options) {
         isPublicConfig: true,
         skipSDKVersionRequirement: true,
     });
-    const updatesRuntimeVersion = await (0, expo_1.resolveRuntimeVersionAsync)(options, exp);
+    (0, node_assert_1.default)(exp.ios?.bundleIdentifier, 'Expected app ID (`ios.bundleIdentifier`) to be defined in app.json');
+    const updatesRuntimeVersion = (0, expo_1.isExpoUpdatesInstalled)(options.projectRoot)
+        ? await (0, expo_1.resolveRuntimeVersionAsync)(options, exp)
+        : null;
     logger.info(picocolors_1.default.dim(`Resolved runtime version: ${updatesRuntimeVersion}`));
     logger.info(`Unzipping IPA`);
     let appWorkingDirectory = await (0, build_tools_1.unzipIpaAsync)(options);
     appWorkingDirectory = await (0, build_tools_1.updateFilesAsync)(exp, appWorkingDirectory);
+    const infoPlistPath = node_path_1.default.join(appWorkingDirectory, 'Info.plist');
+    const originalAppId = await (0, resources_1.queryAppIdFromPlistAsync)(infoPlistPath, options);
     logger.info(`Finished unzipping IPA ✅`);
+    if (options.exportEmbedOptions != null) {
+        logger.info(`Generating bundle`);
+        const { assetRoot, bundleOutputPath } = await (0, expo_1.generateBundleAssetsAsync)(exp, options);
+        logger.info(`Finished generating bundle ✅`);
+        logger.info(`Adding bundled resources`);
+        await (0, resources_1.addBundleAssetsAsync)({
+            appWorkingDirectory,
+            assetRoot,
+            bundleOutputPath,
+        });
+        logger.info(`Finished adding bundled resources ✅`);
+    }
     logger.info(`Updating Info.plist`);
-    await (0, resources_1.updateInfoPlistAsync)(exp, node_path_1.default.join(appWorkingDirectory, 'Info.plist'), options);
+    await (0, resources_1.updateInfoPlistAsync)({ config: exp, infoPlistPath, originalAppId, options });
     logger.info(`Finished updating Info.plist ✅`);
     logger.info(`Updating Expo.plist`);
     await (0, resources_1.updateExpoPlistAsync)(exp, node_path_1.default.join(appWorkingDirectory, 'Expo.plist'), updatesRuntimeVersion, options);
@@ -51,7 +69,7 @@ async function repackAppIosAsync(_options) {
     await promises_1.default.rename(outputIpa, options.outputPath);
     if (!options.skipWorkingDirCleanup) {
         try {
-            await promises_1.default.rmdir(workingDirectory, { recursive: true });
+            await promises_1.default.rm(workingDirectory, { recursive: true });
         }
         catch { }
     }
@@ -61,17 +79,17 @@ exports.repackAppIosAsync = repackAppIosAsync;
 /**
  * Resign an IPA by fastlane.
  */
-async function resignIpaAsync(ipaPath, signingOptions, options) {
-    const args = [
-        'run',
-        'resign',
-        `ipa:${ipaPath}`,
-        `signing_identity:${signingOptions.signingIdentity}`,
-        `provisioning_profile:${signingOptions.provisioningProfile}`,
-    ];
-    if (signingOptions.keychainPath) {
-        args.push(`keychain_path:${signingOptions.keychainPath}`);
-    }
-    await (0, steps_1.spawnAsync)('fastlane', args, { logger: options.logger, stdio: 'pipe' });
+async function resignIpaAsync(ipaPath, signingOptions, _options) {
+    const options = await (0, utils_1.normalizeOptionAsync)(_options);
+    const resignWorkingDirectory = node_path_1.default.join(options.workingDirectory, 'fastlane');
+    await promises_1.default.mkdir(resignWorkingDirectory, { recursive: true });
+    const fastfileContents = (0, build_tools_1.createResignLane)('resign_ipa', ipaPath, signingOptions);
+    await promises_1.default.writeFile(node_path_1.default.join(resignWorkingDirectory, 'Fastfile'), fastfileContents);
+    await (0, steps_1.spawnAsync)('fastlane', ['resign_ipa'], {
+        logger: options.logger,
+        stdio: 'pipe',
+        cwd: resignWorkingDirectory,
+        env: options.env,
+    });
 }
 exports.resignIpaAsync = resignIpaAsync;