@donotuse/eas-cli 18.5.0-rc.1

package/build/onboarding/installDependencies.d.ts

@@ -0,0 +1,8 @@
+export declare const PACKAGE_MANAGERS: readonly ["bun", "npm", "pnpm", "yarn"];
+export type PackageManager = (typeof PACKAGE_MANAGERS)[number];
+export declare function promptForPackageManagerAsync(): Promise<PackageManager>;
+export declare function installDependenciesAsync({ outputLevel, projectDir, packageManager, }: {
+    outputLevel?: 'default' | 'none';
+    projectDir: string;
+    packageManager?: PackageManager;
+}): Promise<void>;

package/build/onboarding/installDependencies.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PACKAGE_MANAGERS = void 0;
+exports.promptForPackageManagerAsync = promptForPackageManagerAsync;
+exports.installDependenciesAsync = installDependenciesAsync;
+const runCommand_1 = require("./runCommand");
+const prompts_1 = require("../prompts");
+exports.PACKAGE_MANAGERS = ['bun', 'npm', 'pnpm', 'yarn'];
+async function promptForPackageManagerAsync() {
+    return await (0, prompts_1.selectAsync)('Which package manager would you like to use?', ['bun', 'npm', 'pnpm', 'yarn'].map(manager => ({ title: manager, value: manager })), { initial: 'npm' });
+}
+async function installDependenciesAsync({ outputLevel = 'default', projectDir, packageManager = 'npm', }) {
+    await (0, runCommand_1.runCommandAsync)({
+        command: packageManager,
+        args: ['install'],
+        cwd: projectDir,
+        shouldShowStderrLine: line => {
+            return (!line.includes('WARN') &&
+                !line.includes('deprecated') &&
+                !line.includes('no longer maintained') &&
+                !line.includes('has been moved') &&
+                !(line === packageManager));
+        },
+        showOutput: outputLevel !== 'none',
+        showSpinner: outputLevel !== 'none',
+    });
+}

package/build/onboarding/runCommand.d.ts

@@ -0,0 +1,9 @@
+export declare function runCommandAsync({ cwd, args, command, shouldShowStderrLine, shouldPrintStderrLineAsStdout, showSpinner, showOutput, }: {
+    cwd?: string;
+    args: string[];
+    command: string;
+    shouldShowStderrLine?: (line: string) => boolean;
+    shouldPrintStderrLineAsStdout?: (line: string) => boolean;
+    showSpinner?: boolean;
+    showOutput?: boolean;
+}): Promise<void>;

package/build/onboarding/runCommand.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCommandAsync = runCommandAsync;
+const tslib_1 = require("tslib");
+const spawn_async_1 = tslib_1.__importDefault(require("@expo/spawn-async"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const log_1 = tslib_1.__importDefault(require("../log"));
+const ora_1 = require("../ora");
+async function runCommandAsync({ cwd, args, command, shouldShowStderrLine, shouldPrintStderrLineAsStdout, showSpinner = true, showOutput = true, }) {
+    if (showOutput) {
+        log_1.default.log(`🏗️  Running ${chalk_1.default.bold(`${command} ${args.join(' ')}`)}...`);
+    }
+    let spinner;
+    if (showSpinner) {
+        spinner = (0, ora_1.ora)(`${chalk_1.default.bold(`${command} ${args.join(' ')}`)}`).start();
+    }
+    const spawnPromise = (0, spawn_async_1.default)(command, args, {
+        stdio: showOutput ? ['inherit', 'pipe', 'pipe'] : 'ignore',
+        cwd,
+    });
+    if (showOutput) {
+        const { child: { stdout, stderr }, } = spawnPromise;
+        if (!stdout || !stderr) {
+            throw new Error(`Failed to spawn ${command}`);
+        }
+        stdout.on('data', data => {
+            for (const line of data.toString().trim().split('\n')) {
+                log_1.default.log(`${chalk_1.default.gray(`[${command}]`)} ${line}`);
+            }
+        });
+        stderr.on('data', data => {
+            for (const line of data.toString().trim().split('\n')) {
+                if (shouldShowStderrLine && !shouldShowStderrLine(line)) {
+                    continue;
+                }
+                const log = `${chalk_1.default.gray(`[${command}]`)} ${line}`;
+                if (shouldPrintStderrLineAsStdout?.(line)) {
+                    log_1.default.log(log);
+                }
+                else {
+                    log_1.default.warn(`${chalk_1.default.gray(`[${command}]`)} ${line}`);
+                }
+            }
+        });
+    }
+    try {
+        await spawnPromise;
+    }
+    catch (error) {
+        if (showSpinner) {
+            spinner?.fail(`${chalk_1.default.bold(`${command} ${args.join(' ')}`)} failed`);
+        }
+        else {
+            log_1.default.error(`❌ ${chalk_1.default.bold(`${command} ${args.join(' ')}`)} failed`);
+        }
+        throw error;
+    }
+    if (!showOutput) {
+        return;
+    }
+    if (showSpinner) {
+        spinner?.succeed(`${chalk_1.default.bold(`${command} ${args.join(' ')}`)} succeeded`);
+    }
+    else {
+        log_1.default.log(`✅ ${chalk_1.default.bold(`${command} ${args.join(' ')}`)} succeeded`);
+    }
+    log_1.default.log('');
+}

package/build/ora.d.ts

@@ -0,0 +1,9 @@
+import { Options, Ora } from 'ora';
+export { Ora, Options };
+/**
+ * A custom ora spinner that sends the stream to stdout in CI, or non-TTY, instead of stderr (the default).
+ *
+ * @param options
+ * @returns
+ */
+export declare function ora(options?: Options | string): Ora;

package/build/ora.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ora = ora;
+const tslib_1 = require("tslib");
+const getenv_1 = require("getenv");
+// eslint-disable-next-line
+const ora_1 = tslib_1.__importDefault(require("ora"));
+const log_1 = tslib_1.__importDefault(require("./log"));
+// eslint-disable-next-line no-console
+const logReal = console.log;
+// eslint-disable-next-line no-console
+const infoReal = console.info;
+// eslint-disable-next-line no-console
+const warnReal = console.warn;
+// eslint-disable-next-line no-console
+const errorReal = console.error;
+const isCi = (0, getenv_1.boolish)('CI', false);
+/**
+ * A custom ora spinner that sends the stream to stdout in CI, or non-TTY, instead of stderr (the default).
+ *
+ * @param options
+ * @returns
+ */
+function ora(options) {
+    const inputOptions = typeof options === 'string' ? { text: options } : (options ?? {});
+    const disabled = log_1.default.isDebug || !process.stdin.isTTY || isCi;
+    const spinner = (0, ora_1.default)({
+        // Ensure our non-interactive mode emulates CI mode.
+        isEnabled: !disabled,
+        // In non-interactive mode, send the stream to stdout so it prevents looking like an error.
+        stream: disabled ? process.stdout : process.stderr,
+        ...inputOptions,
+    });
+    const oraStart = spinner.start.bind(spinner);
+    const oraStop = spinner.stop.bind(spinner);
+    const oraStopAndPersist = spinner.stopAndPersist.bind(spinner);
+    const logWrap = (method, args) => {
+        oraStop();
+        method(...args);
+        spinner.start();
+    };
+    const wrapNativeLogs = () => {
+        // eslint-disable-next-line no-console
+        console.log = (...args) => {
+            logWrap(logReal, args);
+        };
+        // eslint-disable-next-line no-console
+        console.info = (...args) => {
+            logWrap(infoReal, args);
+        };
+        // eslint-disable-next-line no-console
+        console.warn = (...args) => {
+            logWrap(warnReal, args);
+        };
+        // eslint-disable-next-line no-console
+        console.error = (...args) => {
+            logWrap(errorReal, args);
+        };
+    };
+    const resetNativeLogs = () => {
+        // eslint-disable-next-line no-console
+        console.log = logReal;
+        // eslint-disable-next-line no-console
+        console.info = infoReal;
+        // eslint-disable-next-line no-console
+        console.warn = warnReal;
+        // eslint-disable-next-line no-console
+        console.error = errorReal;
+    };
+    spinner.start = (text) => {
+        // wrapNativeLogs wraps calls to console so they always:
+        // 1. stop the spinner
+        // 2. log the message
+        // 3. start the spinner again
+        // Every restart of the spinner causes the spinner message to be logged again
+        // which makes logs look like
+        //
+        // - Exporting...
+        // [expo-cli] Starting Metro Bundler
+        // - Exporting...
+        // [expo-cli] Android Bundling complete 3492ms
+        // - Exporting...
+        //
+        // Skipping wrapping native logs removes the repeated interleaved "Exporting..." messages.
+        if (!disabled) {
+            wrapNativeLogs();
+        }
+        return oraStart(text);
+    };
+    spinner.stopAndPersist = (options) => {
+        const result = oraStopAndPersist(options);
+        resetNativeLogs();
+        return result;
+    };
+    spinner.stop = () => {
+        const result = oraStop();
+        resetNativeLogs();
+        return result;
+    };
+    return spinner;
+}

package/build/platform.d.ts

@@ -0,0 +1,17 @@
+import { Platform } from '@expo/eas-build-job';
+import { AppPlatform } from './graphql/generated';
+export declare const appPlatformDisplayNames: Record<AppPlatform, string>;
+export declare const appPlatformEmojis: {
+    IOS: string;
+    ANDROID: string;
+};
+export declare enum RequestedPlatform {
+    Android = "android",
+    Ios = "ios",
+    All = "all"
+}
+export declare const requestedPlatformDisplayNames: Record<RequestedPlatform, string>;
+export declare function selectRequestedPlatformAsync(platform?: string): Promise<RequestedPlatform>;
+export declare function selectPlatformWithExitOptionAsync(platform?: string): Promise<Platform>;
+export declare function selectPlatformAsync(platform?: string): Promise<Platform>;
+export declare function toPlatforms(requestedPlatform: RequestedPlatform): Platform[];

package/build/platform.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestedPlatformDisplayNames = exports.RequestedPlatform = exports.appPlatformEmojis = exports.appPlatformDisplayNames = void 0;
+exports.selectRequestedPlatformAsync = selectRequestedPlatformAsync;
+exports.selectPlatformWithExitOptionAsync = selectPlatformWithExitOptionAsync;
+exports.selectPlatformAsync = selectPlatformAsync;
+exports.toPlatforms = toPlatforms;
+const tslib_1 = require("tslib");
+const eas_build_job_1 = require("@expo/eas-build-job");
+const generated_1 = require("./graphql/generated");
+const log_1 = tslib_1.__importDefault(require("./log"));
+const prompts_1 = require("./prompts");
+exports.appPlatformDisplayNames = {
+    [generated_1.AppPlatform.Android]: 'Android',
+    [generated_1.AppPlatform.Ios]: 'iOS',
+};
+exports.appPlatformEmojis = {
+    [generated_1.AppPlatform.Ios]: '🍏',
+    [generated_1.AppPlatform.Android]: '🤖',
+};
+// for `eas build`, `eas submit`, and `eas update`
+var RequestedPlatform;
+(function (RequestedPlatform) {
+    RequestedPlatform["Android"] = "android";
+    RequestedPlatform["Ios"] = "ios";
+    RequestedPlatform["All"] = "all";
+})(RequestedPlatform || (exports.RequestedPlatform = RequestedPlatform = {}));
+exports.requestedPlatformDisplayNames = {
+    [RequestedPlatform.Android]: 'Android',
+    [RequestedPlatform.Ios]: 'iOS',
+    [RequestedPlatform.All]: 'Android and iOS',
+};
+async function selectRequestedPlatformAsync(platform) {
+    if (platform &&
+        Object.values(RequestedPlatform).includes(platform.toLowerCase())) {
+        return platform.toLowerCase();
+    }
+    const { requestedPlatform } = await (0, prompts_1.promptAsync)({
+        type: 'select',
+        message: 'Select platform',
+        name: 'requestedPlatform',
+        choices: [
+            { title: 'All', value: RequestedPlatform.All },
+            { title: 'Android', value: RequestedPlatform.Android },
+            { title: 'iOS', value: RequestedPlatform.Ios },
+        ],
+    });
+    return requestedPlatform;
+}
+async function selectPlatformWithExitOptionAsync(platform) {
+    return await selectPlatformInternalAsync(platform, true);
+}
+async function selectPlatformAsync(platform) {
+    return await selectPlatformInternalAsync(platform, false);
+}
+async function selectPlatformInternalAsync(platform, allowExit) {
+    if (platform && Object.values(eas_build_job_1.Platform).includes(platform.toLowerCase())) {
+        return platform.toLowerCase();
+    }
+    const platformChoices = [
+        { title: 'Android', value: eas_build_job_1.Platform.ANDROID },
+        { title: 'iOS', value: eas_build_job_1.Platform.IOS },
+    ];
+    if (allowExit) {
+        platformChoices.push({ title: 'Exit', value: 'Exit' });
+    }
+    const result = await (0, prompts_1.promptAsync)({
+        type: 'select',
+        message: 'Select platform',
+        name: 'resolvedPlatform',
+        choices: platformChoices,
+    });
+    if (result.resolvedPlatform === 'Exit') {
+        log_1.default.addNewLineIfNone();
+        log_1.default.log('Exiting');
+        process.exit(0);
+    }
+    return result.resolvedPlatform;
+}
+function toPlatforms(requestedPlatform) {
+    if (requestedPlatform === RequestedPlatform.All) {
+        return [eas_build_job_1.Platform.ANDROID, eas_build_job_1.Platform.IOS];
+    }
+    else if (requestedPlatform === RequestedPlatform.Android) {
+        return [eas_build_job_1.Platform.ANDROID];
+    }
+    else {
+        return [eas_build_job_1.Platform.IOS];
+    }
+}

package/build/project/android/applicationId.d.ts

@@ -0,0 +1,20 @@
+import { ExpoConfig } from '@expo/config';
+import { GradleBuildContext } from './gradle';
+import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
+import { Client } from '../../vcs/vcs';
+export declare const INVALID_APPLICATION_ID_MESSAGE = "Invalid format of Android applicationId. Only alphanumeric characters, '.' and '_' are allowed, and each '.' must be followed by a letter.";
+export declare function ensureApplicationIdIsDefinedForManagedProjectAsync({ graphqlClient, projectDir, projectId, exp, vcsClient, nonInteractive, }: {
+    graphqlClient: ExpoGraphqlClient;
+    projectDir: string;
+    projectId: string;
+    exp: ExpoConfig;
+    vcsClient: Client;
+    nonInteractive: boolean;
+}): Promise<string>;
+export declare class AmbiguousApplicationIdError extends Error {
+    constructor(message?: string);
+}
+export declare function getApplicationIdFromBareAsync(projectDir: string, gradleContext?: GradleBuildContext): Promise<string>;
+export declare function getApplicationIdAsync(projectDir: string, exp: ExpoConfig, vcsClient: Client, gradleContext?: GradleBuildContext): Promise<string>;
+export declare function isApplicationIdValid(applicationId: string): boolean;
+export declare function warnIfAndroidPackageDefinedInAppConfigForBareWorkflowProject(projectDir: string, exp: ExpoConfig): void;

package/build/project/android/applicationId.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AmbiguousApplicationIdError = exports.INVALID_APPLICATION_ID_MESSAGE = void 0;
+exports.ensureApplicationIdIsDefinedForManagedProjectAsync = ensureApplicationIdIsDefinedForManagedProjectAsync;
+exports.getApplicationIdFromBareAsync = getApplicationIdFromBareAsync;
+exports.getApplicationIdAsync = getApplicationIdAsync;
+exports.isApplicationIdValid = isApplicationIdValid;
+exports.warnIfAndroidPackageDefinedInAppConfigForBareWorkflowProject = warnIfAndroidPackageDefinedInAppConfigForBareWorkflowProject;
+const tslib_1 = require("tslib");
+const config_1 = require("@expo/config");
+const config_plugins_1 = require("@expo/config-plugins");
+const eas_build_job_1 = require("@expo/eas-build-job");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const nullthrows_1 = tslib_1.__importDefault(require("nullthrows"));
+const gradleUtils = tslib_1.__importStar(require("./gradleUtils"));
+const appJson_1 = require("../../build/utils/appJson");
+const env_1 = tslib_1.__importDefault(require("../../env"));
+const log_1 = tslib_1.__importStar(require("../../log"));
+const projectUtils_1 = require("../../project/projectUtils");
+const prompts_1 = require("../../prompts");
+const workflow_1 = require("../workflow");
+exports.INVALID_APPLICATION_ID_MESSAGE = `Invalid format of Android applicationId. Only alphanumeric characters, '.' and '_' are allowed, and each '.' must be followed by a letter.`;
+async function ensureApplicationIdIsDefinedForManagedProjectAsync({ graphqlClient, projectDir, projectId, exp, vcsClient, nonInteractive, }) {
+    const workflow = await (0, workflow_1.resolveWorkflowAsync)(projectDir, eas_build_job_1.Platform.ANDROID, vcsClient);
+    (0, assert_1.default)(workflow === eas_build_job_1.Workflow.MANAGED, 'This function should be called only for managed projects');
+    try {
+        return await getApplicationIdAsync(projectDir, exp, vcsClient, {
+            moduleName: gradleUtils.DEFAULT_MODULE_NAME,
+        });
+    }
+    catch {
+        return await configureApplicationIdAsync({
+            graphqlClient,
+            projectDir,
+            projectId,
+            exp,
+            nonInteractive,
+        });
+    }
+}
+class AmbiguousApplicationIdError extends Error {
+    constructor(message) {
+        super(message ?? 'Could not resolve applicationId.');
+    }
+}
+exports.AmbiguousApplicationIdError = AmbiguousApplicationIdError;
+async function getApplicationIdFromBareAsync(projectDir, gradleContext) {
+    const errorMessage = 'Could not read applicationId from Android project.';
+    if (gradleContext) {
+        const buildGradle = await gradleUtils.getAppBuildGradleAsync(projectDir);
+        const applicationIdSuffix = gradleUtils.resolveConfigValue(buildGradle, 'applicationIdSuffix', gradleContext.flavor);
+        if (applicationIdSuffix) {
+            throw new Error('"applicationIdSuffix" in app/build.gradle is not supported, configure the full application ID under productFlavors.');
+        }
+        const applicationId = gradleUtils.resolveConfigValue(buildGradle, 'applicationId', gradleContext.flavor);
+        return (0, nullthrows_1.default)(applicationId, errorMessage);
+    }
+    else {
+        // should return value only if productFlavors are not used
+        const buildGradlePath = config_plugins_1.AndroidConfig.Paths.getAppBuildGradleFilePath(projectDir);
+        const buildGradle = await fs_extra_1.default.readFile(buildGradlePath, 'utf8');
+        const matchResult = buildGradle.match(/applicationId ['"](.*)['"]/);
+        if (buildGradle.match(/applicationIdSuffix/)) {
+            throw new Error('"applicationIdSuffix" in app/build.gradle is not supported, configure the full application ID under productFlavors.');
+        }
+        if (buildGradle.match(/productFlavors/)) {
+            throw new AmbiguousApplicationIdError('Failed to autodetect applicationId in multi-flavor project.');
+        }
+        return (0, nullthrows_1.default)(matchResult?.[1], errorMessage);
+    }
+}
+async function getApplicationIdAsync(projectDir, exp, vcsClient, gradleContext) {
+    if (env_1.default.overrideAndroidApplicationId) {
+        return env_1.default.overrideAndroidApplicationId;
+    }
+    const workflow = await (0, workflow_1.resolveWorkflowAsync)(projectDir, eas_build_job_1.Platform.ANDROID, vcsClient);
+    if (workflow === eas_build_job_1.Workflow.GENERIC) {
+        warnIfAndroidPackageDefinedInAppConfigForBareWorkflowProject(projectDir, exp);
+        return await getApplicationIdFromBareAsync(projectDir, gradleContext);
+    }
+    else {
+        const applicationId = config_plugins_1.AndroidConfig.Package.getPackage(exp);
+        if (!applicationId || !isApplicationIdValid(applicationId)) {
+            if (applicationId) {
+                log_1.default.warn(exports.INVALID_APPLICATION_ID_MESSAGE);
+            }
+            throw new Error(`Specify "android.package" in ${(0, projectUtils_1.getProjectConfigDescription)(projectDir)} and run this command again.`);
+        }
+        else {
+            return applicationId;
+        }
+    }
+}
+async function configureApplicationIdAsync({ graphqlClient, projectDir, projectId, exp, nonInteractive, }) {
+    if (nonInteractive) {
+        throw new Error(`The "android.package" is required to be set in app config when running in non-interactive mode. ${(0, log_1.learnMore)('https://docs.expo.dev/versions/latest/config/app/#package')}`);
+    }
+    const paths = (0, config_1.getConfigFilePaths)(projectDir);
+    // we can't automatically update app.config.js
+    if (paths.dynamicConfigPath) {
+        throw new Error(`"android.package" is not defined in your app.config.js and we can't update this file programmatically. Add the value on your own and run this command again.`);
+    }
+    (0, assert_1.default)(paths.staticConfigPath, 'app.json must exist');
+    log_1.default.addNewLineIfNone();
+    log_1.default.log(`${chalk_1.default.bold(`📝  Android application id`)} ${chalk_1.default.dim((0, log_1.learnMore)('https://expo.fyi/android-package'))}`);
+    const suggestedAndroidApplicationId = await getSuggestedApplicationIdAsync(graphqlClient, exp, projectId);
+    const { packageName } = await (0, prompts_1.promptAsync)({
+        name: 'packageName',
+        type: 'text',
+        message: `What would you like your Android application id to be?`,
+        initial: suggestedAndroidApplicationId,
+        validate: value => (isApplicationIdValid(value) ? true : exports.INVALID_APPLICATION_ID_MESSAGE),
+    });
+    const rawStaticConfig = (0, appJson_1.readAppJson)(paths.staticConfigPath);
+    rawStaticConfig.expo = {
+        ...rawStaticConfig.expo,
+        android: { ...rawStaticConfig.expo?.android, package: packageName },
+    };
+    await fs_extra_1.default.writeJson(paths.staticConfigPath, rawStaticConfig, { spaces: 2 });
+    exp.android = { ...exp.android, package: packageName };
+    return packageName;
+}
+function isApplicationIdValid(applicationId) {
+    return /^[a-zA-Z][a-zA-Z0-9_]*(\.[a-zA-Z][a-zA-Z0-9_]*)+$/.test(applicationId);
+}
+let warnPrinted = false;
+function warnIfAndroidPackageDefinedInAppConfigForBareWorkflowProject(projectDir, exp) {
+    if (config_plugins_1.AndroidConfig.Package.getPackage(exp) && !warnPrinted) {
+        log_1.default.warn(`Specified value for "android.package" in ${(0, projectUtils_1.getProjectConfigDescription)(projectDir)} is ignored because an ${chalk_1.default.bold('android')} directory was detected in the project.\n` +
+            'EAS Build will use the value found in the native code.');
+        warnPrinted = true;
+    }
+}
+async function getSuggestedApplicationIdAsync(graphqlClient, exp, projectId) {
+    // Attempt to use the ios bundle id first since it's convenient to have them aligned.
+    const maybeBundleId = config_plugins_1.IOSConfig.BundleIdentifier.getBundleIdentifier(exp);
+    if (maybeBundleId && isApplicationIdValid(maybeBundleId)) {
+        return maybeBundleId;
+    }
+    else {
+        // the only callsite is heavily interactive
+        const account = await (0, projectUtils_1.getOwnerAccountForProjectIdAsync)(graphqlClient, projectId);
+        // It's common to use dashes in your node project name, strip them from the suggested package name.
+        const possibleId = `com.${account.name}.${exp.slug}`.split('-').join('');
+        if (isApplicationIdValid(possibleId)) {
+            return possibleId;
+        }
+    }
+    return undefined;
+}

package/build/project/android/gradle.d.ts

@@ -0,0 +1,9 @@
+import { Platform } from '@expo/eas-build-job';
+import { BuildProfile } from '@expo/eas-json';
+import { Client } from '../../vcs/vcs';
+export interface GradleBuildContext {
+    moduleName?: string;
+    flavor?: string;
+    buildType?: string;
+}
+export declare function resolveGradleBuildContextAsync(projectDir: string, buildProfile: BuildProfile<Platform.ANDROID>, vcsClient: Client): Promise<GradleBuildContext | undefined>;

package/build/project/android/gradle.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveGradleBuildContextAsync = resolveGradleBuildContextAsync;
+const tslib_1 = require("tslib");
+const eas_build_job_1 = require("@expo/eas-build-job");
+const gradleUtils = tslib_1.__importStar(require("./gradleUtils"));
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const workflow_1 = require("../../project/workflow");
+async function resolveGradleBuildContextAsync(projectDir, buildProfile, vcsClient) {
+    const workflow = await (0, workflow_1.resolveWorkflowAsync)(projectDir, eas_build_job_1.Platform.ANDROID, vcsClient);
+    if (workflow === eas_build_job_1.Workflow.GENERIC) {
+        try {
+            if (buildProfile.gradleCommand) {
+                const buildGradle = await gradleUtils.getAppBuildGradleAsync(projectDir);
+                const parsedGradleCommand = buildProfile.gradleCommand
+                    ? gradleUtils.parseGradleCommand(buildProfile.gradleCommand, buildGradle)
+                    : undefined;
+                if (parsedGradleCommand?.moduleName &&
+                    parsedGradleCommand.moduleName !== gradleUtils.DEFAULT_MODULE_NAME) {
+                    log_1.default.warn(`Building modules different than "${gradleUtils.DEFAULT_MODULE_NAME}" might result in unexpected behavior.`);
+                }
+                return {
+                    moduleName: parsedGradleCommand?.moduleName ?? gradleUtils.DEFAULT_MODULE_NAME,
+                    flavor: parsedGradleCommand?.flavor,
+                    buildType: parsedGradleCommand?.buildType,
+                };
+            }
+            else {
+                return { moduleName: gradleUtils.DEFAULT_MODULE_NAME };
+            }
+        }
+        catch (err) {
+            log_1.default.warn(`Unable to read gradle project config: ${err.message}.`);
+            log_1.default.warn('Values from app/build.gradle might be resolved incorrectly.');
+            return undefined;
+        }
+    }
+    else {
+        return { moduleName: gradleUtils.DEFAULT_MODULE_NAME };
+    }
+}

package/build/project/android/gradleUtils.d.ts

@@ -0,0 +1,42 @@
+interface GradleCommand {
+    moduleName?: string;
+    flavor?: string;
+    buildType?: string;
+}
+interface Config {
+    applicationId?: string;
+    applicationIdSuffix?: string;
+    versionCode?: string;
+    versionName?: string;
+}
+interface AppBuildGradle {
+    android?: {
+        defaultConfig?: Config;
+        /**
+         * If defined as `flavorDimensions = ['dimension1', 'dimension2']`,
+         * this will be an array of strings (`['dimension1', 'dimension2']`).
+         *
+         * If defined as `flavorDimensions "dimension1", "dimension2"`,
+         * this will be a string (`"dimension1", "dimension2"`).
+         */
+        flavorDimensions?: string | string[];
+        productFlavors?: Record<string, Config>;
+    };
+}
+export declare const DEFAULT_MODULE_NAME = "app";
+export declare function getAppBuildGradleAsync(projectDir: string): Promise<AppBuildGradle>;
+export declare function resolveConfigValue(buildGradle: AppBuildGradle, field: keyof Config, flavor?: string): string | undefined;
+/**
+ * Extract module name, buildType, and flavor from the gradle command.
+ *
+ * @param cmd can be any valid string that can be added after `./gradlew` call
+ * e.g.
+ *   - :app:buildDebug
+ *   - app:buildDebug
+ *   - buildDebug
+ *   - buildDebug --console verbose
+ * @param buildGradle is used to verify correct casing of the first letter in
+ * the flavor name
+ **/
+export declare function parseGradleCommand(cmd: string, buildGradle: AppBuildGradle): GradleCommand;
+export {};