@expo/build-tools 18.6.0 → 18.8.0

package/dist/steps/functions/export.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEasExportBuildFunction = createEasExportBuildFunction;
+const eas_build_job_1 = require("@expo/eas-build-job");
+const steps_1 = require("@expo/steps");
+const packageManager_1 = require("../../utils/packageManager");
+const project_1 = require("../../utils/project");
+function createEasExportBuildFunction() {
+    return new steps_1.BuildFunction({
+        namespace: 'eas',
+        id: 'export',
+        name: 'Export',
+        __metricsId: 'eas/export',
+        inputProviders: [
+            steps_1.BuildStepInput.createProvider({
+                id: 'output_dir',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+                required: false,
+                defaultValue: 'dist',
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'dev',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.BOOLEAN,
+                required: false,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'minify',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.BOOLEAN,
+                required: false,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'dump_assetmap',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.BOOLEAN,
+                required: false,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'ssg',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.BOOLEAN,
+                required: false,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'api_only',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.BOOLEAN,
+                required: false,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'platform',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+                required: false,
+                defaultValue: 'web',
+            }),
+        ],
+        outputProviders: [
+            steps_1.BuildStepOutput.createProvider({
+                id: 'export_dir',
+                required: true,
+            }),
+        ],
+        fn: async (stepsCtx, { inputs, outputs, env }) => {
+            const outputDir = inputs.output_dir.value;
+            const dev = inputs.dev.value;
+            const minify = inputs.minify.value;
+            const dumpAssetmap = inputs.dump_assetmap.value;
+            const ssg = inputs.ssg.value;
+            const apiOnly = inputs.api_only.value;
+            const platform = inputs.platform.value;
+            const packageManager = (0, packageManager_1.resolvePackageManager)(stepsCtx.workingDirectory, { env });
+            const exportCommand = getExportCommand({
+                outputDir,
+                dev,
+                minify,
+                dumpAssetmap,
+                ssg,
+                apiOnly,
+                platform,
+            });
+            stepsCtx.logger.info(`Running export command: expo ${exportCommand.join(' ')}`);
+            try {
+                await (0, project_1.runExpoCliCommand)({
+                    packageManager,
+                    args: exportCommand,
+                    options: {
+                        cwd: stepsCtx.workingDirectory,
+                        env,
+                        logger: stepsCtx.logger,
+                        stdio: 'pipe',
+                    },
+                });
+                outputs.export_dir.set(outputDir);
+            }
+            catch (error) {
+                throw new eas_build_job_1.UserError('EXPO_EXPORT_FAILED', `Export command failed: ${error instanceof Error ? error.message : 'unknown error'}`);
+            }
+        },
+    });
+}
+function getExportCommand({ outputDir, dev, minify, dumpAssetmap, ssg, apiOnly, platform, }) {
+    const exportCommand = ['export', '--output-dir', outputDir, '--platform', platform];
+    if (dev) {
+        exportCommand.push('--dev');
+    }
+    if (minify === false) {
+        exportCommand.push('--no-minify');
+    }
+    if (dumpAssetmap) {
+        exportCommand.push('--dump-assetmap');
+    }
+    if (ssg === false) {
+        exportCommand.push('--no-ssg');
+    }
+    if (apiOnly) {
+        exportCommand.push('--api-only');
+    }
+    return exportCommand;
+}

package/dist/steps/functions/generateGymfileFromTemplate.js

@@ -10,6 +10,7 @@ const steps_1 = require("@expo/steps");
 const template_file_1 = require("@expo/template-file");
 const assert_1 = __importDefault(require("assert"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
+const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const credentials_1 = require("../utils/ios/credentials/credentials");
 const manager_1 = __importDefault(require("../utils/ios/credentials/manager"));
@@ -38,6 +39,10 @@ const DEFAULT_CREDENTIALS_TEMPLATE = `
     disable_xcpretty(true)
     buildlog_path("<%- LOGS_DIRECTORY %>")
 
+    derived_data_path("<%- DERIVED_DATA_PATH %>")
+    result_bundle(true)
+    result_bundle_path("<%- RESULT_BUNDLE_PATH %>")
+
     output_directory("<%- OUTPUT_DIRECTORY %>")
 `;
 const DEFAULT_SIMULATOR_TEMPLATE = `
@@ -56,6 +61,9 @@ const DEFAULT_SIMULATOR_TEMPLATE = `
 
     disable_xcpretty(true)
     buildlog_path("<%- LOGS_DIRECTORY %>")
+
+    result_bundle(true)
+    result_bundle_path("<%- RESULT_BUNDLE_PATH %>")
 `;
 function generateGymfileFromTemplateFunction() {
     return new steps_1.BuildFunction({
@@ -158,6 +166,7 @@ function generateGymfileFromTemplateFunction() {
                     ICLOUD_CONTAINER_ENVIRONMENT,
                     SCHEME_SIMULATOR_DESTINATION: simulatorDestination,
                     DERIVED_DATA_PATH: './build',
+                    RESULT_BUNDLE_PATH: path_1.default.join(os_1.default.tmpdir(), `result-bundle-${Date.now()}.xcresult`),
                     ...(PROFILES ? { PROFILES } : {}),
                     ...(credentials
                         ? {

package/dist/steps/functions/installNodeModules.js

@@ -23,7 +23,7 @@ function createInstallNodeModulesBuildFunction() {
 }
 async function installNodeModules(stepCtx, env) {
     const { logger } = stepCtx;
-    const packageManager = (0, packageManager_1.resolvePackageManager)(stepCtx.workingDirectory);
+    const packageManager = (0, packageManager_1.resolvePackageManager)(stepCtx.workingDirectory, { env });
     const packagerRunDir = (0, packageManager_1.findPackagerRootDir)(stepCtx.workingDirectory);
     if (packagerRunDir !== stepCtx.workingDirectory) {
         const relativeReactNativeProjectDirectory = path_1.default.relative(stepCtx.global.projectTargetDirectory, stepCtx.workingDirectory);

package/dist/steps/functions/parseXcactivitylog.d.ts

@@ -0,0 +1,2 @@
+import { BuildFunction } from '@expo/steps';
+export declare function parseXcactivitylogFunction(): BuildFunction;

package/dist/steps/functions/parseXcactivitylog.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseXcactivitylogFunction = parseXcactivitylogFunction;
+const steps_1 = require("@expo/steps");
+const path_1 = __importDefault(require("path"));
+const xcactivitylog_1 = require("../utils/ios/xcactivitylog");
+function parseXcactivitylogFunction() {
+    return new steps_1.BuildFunction({
+        namespace: 'eas',
+        id: 'parse_xcactivitylog',
+        name: 'Analyze build performance',
+        __metricsId: 'eas/parse_xcactivitylog',
+        supportedRuntimePlatforms: [steps_1.BuildRuntimePlatform.DARWIN],
+        inputProviders: [
+            steps_1.BuildStepInput.createProvider({
+                id: 'derived_data_path',
+                required: false,
+                defaultValue: 'ios/build',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'workspace_path',
+                required: false,
+                defaultValue: 'ios',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'xclogparser_version',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+            }),
+        ],
+        fn: async (stepCtx, { inputs, env }) => {
+            const derivedDataPath = inputs.derived_data_path.value;
+            const workspacePath = inputs.workspace_path.value;
+            const version = inputs.xclogparser_version.value;
+            await (0, xcactivitylog_1.parseAndReportXcactivitylog)({
+                derivedDataPath: path_1.default.resolve(stepCtx.workingDirectory, derivedDataPath),
+                workspacePath: path_1.default.resolve(stepCtx.workingDirectory, workspacePath),
+                xclogparserVersion: version,
+                logger: stepCtx.logger,
+                proxyBaseUrl: env.EAS_BUILD_COCOAPODS_CACHE_URL,
+            });
+        },
+    });
+}

package/dist/steps/functions/prebuild.js

@@ -35,7 +35,7 @@ function createPrebuildBuildFunction() {
         fn: async (stepCtx, { inputs, env }) => {
             const { logger } = stepCtx;
             const appleTeamId = inputs.apple_team_id.value;
-            const packageManager = (0, packageManager_1.resolvePackageManager)(stepCtx.workingDirectory);
+            const packageManager = (0, packageManager_1.resolvePackageManager)(stepCtx.workingDirectory, { env });
             const defaultPlatform = process.platform === 'darwin' ? 'ios' : 'android';
             const job = stepCtx.global.staticContext.job;
             const prebuildCommandArgs = getPrebuildCommandArgs({

package/dist/steps/functions/readAppConfig.d.ts

@@ -0,0 +1,2 @@
+import { BuildFunction } from '@expo/steps';
+export declare function createReadAppConfigBuildFunction(): BuildFunction;

package/dist/steps/functions/readAppConfig.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createReadAppConfigBuildFunction = createReadAppConfigBuildFunction;
+const steps_1 = require("@expo/steps");
+const appConfig_1 = require("../../utils/appConfig");
+function createReadAppConfigBuildFunction() {
+    return new steps_1.BuildFunction({
+        namespace: 'eas',
+        id: 'read_app_config',
+        name: 'Read app config',
+        __metricsId: 'eas/read_app_config',
+        outputProviders: [
+            steps_1.BuildStepOutput.createProvider({
+                id: 'app_config',
+                required: false,
+            }),
+        ],
+        fn: async (stepCtx, { env, outputs }) => {
+            const metadata = stepCtx.global.staticContext.metadata;
+            try {
+                const appConfig = (await (0, appConfig_1.readAppConfig)({
+                    projectDir: stepCtx.workingDirectory,
+                    env: Object.keys(env).reduce((acc, key) => {
+                        acc[key] = env[key] ?? '';
+                        return acc;
+                    }, {}),
+                    logger: stepCtx.logger,
+                    sdkVersion: metadata?.sdkVersion,
+                })).exp;
+                stepCtx.logger.info('Using app configuration:');
+                stepCtx.logger.info(JSON.stringify(appConfig, null, 2));
+                outputs.app_config.set(JSON.stringify(appConfig));
+            }
+            catch {
+                // readAppConfig logs underlying failures.
+            }
+        },
+    });
+}

package/dist/steps/functions/readPackageJson.d.ts

@@ -0,0 +1,2 @@
+import { BuildFunction } from '@expo/steps';
+export declare function createReadPackageJsonBuildFunction(): BuildFunction;

package/dist/steps/functions/readPackageJson.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createReadPackageJsonBuildFunction = createReadPackageJsonBuildFunction;
+const steps_1 = require("@expo/steps");
+const project_1 = require("../../utils/project");
+function createReadPackageJsonBuildFunction() {
+    return new steps_1.BuildFunction({
+        namespace: 'eas',
+        id: 'read_package_json',
+        name: 'Read package.json',
+        __metricsId: 'eas/read_package_json',
+        outputProviders: [
+            steps_1.BuildStepOutput.createProvider({
+                id: 'package_json',
+                required: false,
+            }),
+        ],
+        fn: async (stepCtx, { outputs }) => {
+            try {
+                const packageJson = (0, project_1.readAndLogPackageJson)(stepCtx.logger, stepCtx.workingDirectory);
+                outputs.package_json.set(JSON.stringify(packageJson));
+            }
+            catch (err) {
+                stepCtx.logger.error({ err });
+            }
+        },
+    });
+}

package/dist/steps/functions/restoreBuildCache.js

@@ -154,7 +154,7 @@ async function restoreCcacheAsync({ logger, workingDirectory, platform, env, sec
     }
 }
 async function restoreGradleCacheAsync({ logger, workingDirectory, env, secrets, }) {
-    if (env.EXPERIMENTAL_EAS_GRADLE_CACHE !== '1') {
+    if (env.EAS_GRADLE_CACHE !== '1') {
         return;
     }
     try {

package/dist/steps/functions/saveBuildCache.js

@@ -112,7 +112,7 @@ async function saveCcacheAsync({ logger, workingDirectory, platform, evictUsedBe
     }
 }
 async function saveGradleCacheAsync({ logger, workingDirectory, env, secrets, }) {
-    if (env.EXPERIMENTAL_EAS_GRADLE_CACHE !== '1') {
+    if (env.EAS_GRADLE_CACHE !== '1') {
         return;
     }
     const gradleCachesPath = path_1.default.join(os_1.default.homedir(), '.gradle', 'caches');

package/dist/steps/functions/startAndroidEmulator.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createStartAndroidEmulatorBuildFunction = createStartAndroidEmulatorBuildFunction;
+const eas_build_job_1 = require("@expo/eas-build-job");
 const results_1 = require("@expo/results");
 const steps_1 = require("@expo/steps");
 const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
@@ -43,6 +44,12 @@ function createStartAndroidEmulatorBuildFunction() {
             }),
         ],
         fn: async ({ logger }, { inputs, env }) => {
+            if (env.EAS_NO_EMULATOR_HOST_SUPPORT_CHECK !== '1') {
+                await assertAndroidEmulatorHostSupportAsync({ env });
+            }
+            else {
+                logger.info('Skipping Android emulator host support check because $EAS_NO_EMULATOR_HOST_SUPPORT_CHECK is enabled.');
+            }
             try {
                 const availableDevices = await AndroidEmulatorUtils_1.AndroidEmulatorUtils.getAvailableDevicesAsync({ env });
                 logger.info(`Available Android devices:\n- ${availableDevices.join(`\n- `)}`);
@@ -229,3 +236,24 @@ function createStartAndroidEmulatorBuildFunction() {
         },
     });
 }
+async function assertAndroidEmulatorHostSupportAsync({ env, }) {
+    const isAndroidEmulatorHostSupported = await isAndroidEmulatorHostSupportedAsync(env);
+    if (!isAndroidEmulatorHostSupported) {
+        throw new eas_build_job_1.UserError('ANDROID_EMULATOR_ACCEL_CHECK_UNAVAILABLE', 'Could not start the Android emulator on this runner.\n\n' +
+            'Android emulator requires nested virtualization on Linux. This job does not have the required virtualization support.\n\n' +
+            'Update your workflow YAML to use a nested-virtualization Linux runner, for example:\n' +
+            '  runs_on: linux-medium-nested-virtualization\n' +
+            '  runs_on: linux-large-nested-virtualization\n\n' +
+            'See https://docs.expo.dev/eas/workflows/syntax/#jobsjob_idruns_on for more information.');
+    }
+}
+async function isAndroidEmulatorHostSupportedAsync(env) {
+    const androidSdkPath = env.ANDROID_HOME ?? env.ANDROID_SDK_ROOT ?? '';
+    try {
+        await (0, turtle_spawn_1.default)(`${androidSdkPath}/emulator/emulator`, ['-accel-check'], { env });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/steps/utils/ios/xcactivitylog.d.ts

@@ -0,0 +1,57 @@
+import { bunyan } from '@expo/logger';
+import { z } from 'zod';
+/**
+ * Download xclogparser, parse xcactivitylog from derived data, and log a
+ * compile metrics report. Never throws — all errors are logged at debug level.
+ *
+ * Can be called from both the step-based flow (BuildFunction) and the
+ * traditional builder flow (runBuildPhase).
+ */
+export declare function parseAndReportXcactivitylog({ derivedDataPath, workspacePath, xclogparserVersion, logger, proxyBaseUrl, }: {
+    derivedDataPath: string;
+    workspacePath: string;
+    xclogparserVersion?: string;
+    logger: bunyan;
+    proxyBaseUrl?: string;
+}): Promise<void>;
+declare const XcactivitylogStepSchemaZ: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    detailStepType: z.ZodOptional<z.ZodString>;
+    signature: z.ZodOptional<z.ZodString>;
+    duration: z.ZodOptional<z.ZodNumber>;
+    startTimestamp: z.ZodOptional<z.ZodNumber>;
+    endTimestamp: z.ZodOptional<z.ZodNumber>;
+    subSteps: z.ZodOptional<z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strip>>>;
+}, z.core.$strip>;
+declare const XcactivitylogDataSchemaZ: z.ZodObject<{
+    schema: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>;
+    subSteps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
+        detailStepType: z.ZodOptional<z.ZodString>;
+        signature: z.ZodOptional<z.ZodString>;
+        duration: z.ZodOptional<z.ZodNumber>;
+        startTimestamp: z.ZodOptional<z.ZodNumber>;
+        endTimestamp: z.ZodOptional<z.ZodNumber>;
+        subSteps: z.ZodOptional<z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type XcactivitylogStep = z.infer<typeof XcactivitylogStepSchemaZ>;
+type XcactivitylogData = z.infer<typeof XcactivitylogDataSchemaZ>;
+interface TargetMetric {
+    moduleName: string;
+    taskSeconds: number;
+    wallSpan: number;
+    activeWallTime: number;
+}
+export declare function isCompileStep(step: Partial<XcactivitylogStep>): boolean;
+export declare function collectTopLevelCompileSteps(step: XcactivitylogStep, results?: XcactivitylogStep[]): XcactivitylogStep[];
+export declare function buildTargetMetrics(data: XcactivitylogData, { minTaskSeconds }?: {
+    minTaskSeconds?: number;
+}): {
+    results: TargetMetric[];
+    totalTaskSeconds: number;
+};
+export declare function formatReport(data: XcactivitylogData): string;
+export {};