@donotuse/eas-cli 18.5.0-rc.1

package/build/branch/queries.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BRANCHES_LIMIT = void 0;
+exports.selectBranchOnAppAsync = selectBranchOnAppAsync;
+exports.listAndRenderBranchesOnAppAsync = listAndRenderBranchesOnAppAsync;
+exports.createUpdateBranchOnAppAsync = createUpdateBranchOnAppAsync;
+exports.ensureBranchExistsAsync = ensureBranchExistsAsync;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const graphql_1 = require("graphql");
+const graphql_tag_1 = tslib_1.__importDefault(require("graphql-tag"));
+const utils_1 = require("./utils");
+const client_1 = require("../graphql/client");
+const BranchQuery_1 = require("../graphql/queries/BranchQuery");
+const UpdateBranchBasicInfo_1 = require("../graphql/types/UpdateBranchBasicInfo");
+const log_1 = tslib_1.__importDefault(require("../log"));
+const utils_2 = require("../update/utils");
+const json_1 = require("../utils/json");
+const queries_1 = require("../utils/queries");
+exports.BRANCHES_LIMIT = 50;
+async function selectBranchOnAppAsync(graphqlClient, { projectId, promptTitle, displayTextForListItem, paginatedQueryOptions, }) {
+    if (paginatedQueryOptions.nonInteractive) {
+        const branches = await queryBranchesOnProjectAsync(graphqlClient, paginatedQueryOptions.limit ?? exports.BRANCHES_LIMIT, paginatedQueryOptions.offset, projectId);
+        if (branches.length === 0) {
+            throw new Error(`No branches found for project "${projectId}".`);
+        }
+        const branchList = branches.map(b => b.name).join('\n  ');
+        throw new Error(`Unable to select a branch in non-interactive mode. Use the --branch flag to specify the branch. Available branches:\n  ${branchList}`);
+    }
+    const selectedBranch = await (0, queries_1.paginatedQueryWithSelectPromptAsync)({
+        limit: paginatedQueryOptions.limit ?? exports.BRANCHES_LIMIT,
+        offset: paginatedQueryOptions.offset,
+        queryToPerform: (limit, offset) => queryBranchesOnProjectAsync(graphqlClient, limit, offset, projectId),
+        promptOptions: {
+            title: promptTitle,
+            getIdentifierForQueryItem: updateBranchFragment => updateBranchFragment.id,
+            makePartialChoiceObject: displayTextForListItem,
+        },
+    });
+    if (!selectedBranch) {
+        throw new Error(`Could not find any branches for project "${projectId}"`);
+    }
+    return selectedBranch;
+}
+async function listAndRenderBranchesOnAppAsync(graphqlClient, { projectId, paginatedQueryOptions, }) {
+    if (paginatedQueryOptions.nonInteractive) {
+        const branches = await queryBranchesOnProjectAsync(graphqlClient, paginatedQueryOptions.limit ?? exports.BRANCHES_LIMIT, paginatedQueryOptions.offset, projectId);
+        renderPageOfBranches(branches, paginatedQueryOptions);
+    }
+    else {
+        await (0, queries_1.paginatedQueryWithConfirmPromptAsync)({
+            limit: paginatedQueryOptions.limit ?? exports.BRANCHES_LIMIT,
+            offset: paginatedQueryOptions.offset,
+            queryToPerform: (limit, offset) => queryBranchesOnProjectAsync(graphqlClient, limit, offset, projectId),
+            promptOptions: {
+                title: 'Load more branches?',
+                renderListItems: branches => {
+                    renderPageOfBranches(branches, paginatedQueryOptions);
+                },
+            },
+        });
+    }
+}
+async function queryBranchesOnProjectAsync(graphqlClient, limit, offset, projectId) {
+    return await BranchQuery_1.BranchQuery.listBranchesOnAppAsync(graphqlClient, {
+        appId: projectId,
+        limit,
+        offset,
+    });
+}
+function renderPageOfBranches(currentPage, { json }) {
+    if (json) {
+        (0, json_1.printJsonOnlyOutput)(currentPage);
+    }
+    else {
+        log_1.default.addNewLineIfNone();
+        log_1.default.log(chalk_1.default.bold('Branches:'));
+        log_1.default.addNewLineIfNone();
+        log_1.default.log(currentPage
+            .map(branch => (0, utils_2.formatBranch)((0, utils_2.getBranchDescription)(branch)))
+            .join(`\n\n${chalk_1.default.dim('———')}\n\n`));
+    }
+}
+async function createUpdateBranchOnAppAsync(graphqlClient, { appId, name }) {
+    const result = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+        .mutation((0, graphql_tag_1.default) `
+          mutation CreateUpdateBranchForApp($appId: ID!, $name: String!) {
+            updateBranch {
+              createUpdateBranchForApp(appId: $appId, name: $name) {
+                id
+                ...UpdateBranchBasicInfoFragment
+              }
+            }
+          }
+          ${(0, graphql_1.print)(UpdateBranchBasicInfo_1.UpdateBranchBasicInfoFragmentNode)}
+        `, {
+        appId,
+        name,
+    }, { additionalTypenames: ['UpdateBranch'] })
+        .toPromise());
+    const newBranch = result.updateBranch.createUpdateBranchForApp;
+    if (!newBranch) {
+        throw new Error(`Could not create branch ${name}.`);
+    }
+    return newBranch;
+}
+async function ensureBranchExistsAsync(graphqlClient, { appId, branchName, }) {
+    try {
+        const updateBranch = await BranchQuery_1.BranchQuery.getBranchByNameAsync(graphqlClient, {
+            appId,
+            name: branchName,
+        });
+        return { branch: updateBranch, createdBranch: false };
+    }
+    catch (error) {
+        if (error instanceof utils_1.BranchNotFoundError) {
+            const newUpdateBranch = await createUpdateBranchOnAppAsync(graphqlClient, {
+                appId,
+                name: branchName,
+            });
+            return { branch: newUpdateBranch, createdBranch: true };
+        }
+        else {
+            throw error;
+        }
+    }
+}

package/build/branch/utils.d.ts

@@ -0,0 +1,5 @@
+import { Client } from '../vcs/vcs';
+export declare function getDefaultBranchNameAsync(vcsClient: Client): Promise<string | null>;
+export declare class BranchNotFoundError extends Error {
+    constructor(message?: string);
+}

package/build/branch/utils.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BranchNotFoundError = void 0;
+exports.getDefaultBranchNameAsync = getDefaultBranchNameAsync;
+async function getDefaultBranchNameAsync(vcsClient) {
+    return await vcsClient.getBranchNameAsync();
+}
+class BranchNotFoundError extends Error {
+    constructor(message) {
+        super(message ?? 'Branch not found.');
+    }
+}
+exports.BranchNotFoundError = BranchNotFoundError;

package/build/build/android/build.d.ts

@@ -0,0 +1,9 @@
+import { Platform } from '@expo/eas-build-job';
+import { BuildRequestSender } from '../build';
+import { AndroidBuildContext, BuildContext, CommonContext } from '../context';
+export declare function createAndroidContextAsync(ctx: CommonContext<Platform.ANDROID>): Promise<AndroidBuildContext>;
+export declare function prepareAndroidBuildAsync(ctx: BuildContext<Platform.ANDROID>): Promise<BuildRequestSender>;
+export declare function maybeWarnAboutNonStandardBuildType({ buildProfile, buildType, }: {
+    buildProfile: Pick<CommonContext<Platform.ANDROID>['buildProfile'], 'gradleCommand'>;
+    buildType: string;
+}): void;

package/build/build/android/build.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAndroidContextAsync = createAndroidContextAsync;
+exports.prepareAndroidBuildAsync = prepareAndroidBuildAsync;
+exports.maybeWarnAboutNonStandardBuildType = maybeWarnAboutNonStandardBuildType;
+const tslib_1 = require("tslib");
+const eas_build_job_1 = require("@expo/eas-build-job");
+const eas_json_1 = require("@expo/eas-json");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const getenv_1 = tslib_1.__importDefault(require("getenv"));
+const nullthrows_1 = tslib_1.__importDefault(require("nullthrows"));
+const graphql_1 = require("./graphql");
+const prepareJob_1 = require("./prepareJob");
+const syncProjectConfiguration_1 = require("./syncProjectConfiguration");
+const version_1 = require("./version");
+const AndroidCredentialsProvider_1 = tslib_1.__importDefault(require("../../credentials/android/AndroidCredentialsProvider"));
+const BuildMutation_1 = require("../../graphql/mutations/BuildMutation");
+const log_1 = tslib_1.__importStar(require("../../log"));
+const applicationId_1 = require("../../project/android/applicationId");
+const gradle_1 = require("../../project/android/gradle");
+const prompts_1 = require("../../prompts");
+const build_1 = require("../build");
+const credentials_1 = require("../utils/credentials");
+const validate_1 = require("../validate");
+async function createAndroidContextAsync(ctx) {
+    const { buildProfile } = ctx;
+    if (buildProfile.distribution === 'internal' && buildProfile.gradleCommand?.match(/bundle/)) {
+        log_1.default.addNewLineIfNone();
+        log_1.default.warn(`You're building your Android app for internal distribution. However, we've detected that the Gradle command you defined (${chalk_1.default.underline(buildProfile.gradleCommand)}) includes string 'bundle'.
+This means that it will most likely produce an AAB and you will not be able to install it on your Android devices straight from the Expo website.`);
+        log_1.default.newLine();
+        const confirmed = await (0, prompts_1.toggleConfirmAsync)({ message: 'Would you like to proceed?' });
+        if (!confirmed) {
+            log_1.default.error('Update eas.json and come back again.');
+            process.exit(1);
+        }
+    }
+    (0, validate_1.checkNodeEnvVariable)(ctx);
+    await (0, validate_1.checkGoogleServicesFileAsync)(ctx);
+    await (0, validate_1.validatePNGsForManagedProjectAsync)(ctx);
+    const gradleContext = await (0, gradle_1.resolveGradleBuildContextAsync)(ctx.projectDir, buildProfile, ctx.vcsClient);
+    if (gradleContext?.buildType) {
+        maybeWarnAboutNonStandardBuildType({ buildProfile, buildType: gradleContext.buildType });
+    }
+    if (ctx.workflow === eas_build_job_1.Workflow.MANAGED) {
+        await (0, applicationId_1.ensureApplicationIdIsDefinedForManagedProjectAsync)(ctx);
+    }
+    const applicationId = await (0, applicationId_1.getApplicationIdAsync)(ctx.projectDir, ctx.exp, ctx.vcsClient, gradleContext);
+    const versionCodeOverride = ctx.easJsonCliConfig?.appVersionSource === eas_json_1.AppVersionSource.REMOTE
+        ? await (0, version_1.resolveRemoteVersionCodeAsync)(ctx.graphqlClient, {
+            projectDir: ctx.projectDir,
+            projectId: ctx.projectId,
+            exp: ctx.exp,
+            applicationId,
+            buildProfile,
+            vcsClient: ctx.vcsClient,
+        })
+        : undefined;
+    return { applicationId, gradleContext, versionCodeOverride };
+}
+async function prepareAndroidBuildAsync(ctx) {
+    return await (0, build_1.prepareBuildRequestForPlatformAsync)({
+        ctx,
+        ensureCredentialsAsync: async (ctx) => {
+            return await ensureAndroidCredentialsAsync(ctx);
+        },
+        syncProjectConfigurationAsync: async () => {
+            await (0, syncProjectConfiguration_1.syncProjectConfigurationAsync)({
+                projectDir: ctx.projectDir,
+                exp: ctx.exp,
+                localAutoIncrement: ctx.easJsonCliConfig?.appVersionSource === eas_json_1.AppVersionSource.REMOTE
+                    ? false
+                    : ctx.buildProfile.autoIncrement,
+                vcsClient: ctx.vcsClient,
+                env: ctx.env,
+            });
+        },
+        prepareJobAsync: async (ctx, jobData) => {
+            return await (0, prepareJob_1.prepareJobAsync)(ctx, jobData);
+        },
+        sendBuildRequestAsync: async (appId, job, graphqlMetadata, buildParams) => {
+            const graphqlJob = (0, graphql_1.transformJob)(job);
+            return await BuildMutation_1.BuildMutation.createAndroidBuildAsync(ctx.graphqlClient, {
+                appId,
+                job: graphqlJob,
+                metadata: graphqlMetadata,
+                buildParams,
+            });
+        },
+    });
+}
+function shouldProvideCredentials(ctx) {
+    return !ctx.buildProfile.withoutCredentials;
+}
+async function ensureAndroidCredentialsAsync(ctx) {
+    if (!shouldProvideCredentials(ctx)) {
+        return;
+    }
+    const androidApplicationIdentifier = await (0, applicationId_1.getApplicationIdAsync)(ctx.projectDir, ctx.exp, ctx.vcsClient, ctx.android.gradleContext);
+    const provider = new AndroidCredentialsProvider_1.default(ctx.credentialsCtx, {
+        name: ctx.buildProfile.keystoreName,
+        app: {
+            account: (0, nullthrows_1.default)(ctx.user.accounts.find(a => a.name === ctx.accountName), `You do not have access to account: ${ctx.accountName}`),
+            projectName: ctx.projectName,
+            androidApplicationIdentifier,
+        },
+    });
+    const { credentialsSource } = ctx.buildProfile;
+    (0, credentials_1.logCredentialsSource)(credentialsSource, eas_build_job_1.Platform.ANDROID);
+    return {
+        credentials: await provider.getCredentialsAsync(credentialsSource),
+        source: credentialsSource,
+    };
+}
+function maybeWarnAboutNonStandardBuildType({ buildProfile, buildType, }) {
+    const shouldSuppressWarning = getenv_1.default.boolish('EAS_BUILD_NO_GRADLE_BUILD_TYPE_WARNING', false);
+    if (shouldSuppressWarning) {
+        return;
+    }
+    const knownValidBuildTypes = ['debug', 'release'];
+    if (!knownValidBuildTypes.includes(buildType)) {
+        log_1.default.warn(`Custom gradle command "${chalk_1.default.bold(buildProfile.gradleCommand)}" has non-standard build type: "${chalk_1.default.bold(buildType)}". Expected the command to end with "${chalk_1.default.bold('...Debug')}" or "${chalk_1.default.bold('...Release')}"`);
+        log_1.default.warn(`Ensure the command is spelled correctly and ${chalk_1.default.bold('build.gradle')} is configured correctly. To suppress this warning, set ${chalk_1.default.bold('EAS_BUILD_NO_GRADLE_BUILD_TYPE_WARNING=true')}.`);
+        log_1.default.warn((0, log_1.learnMore)('https://developer.android.com/build/build-variants#build-types'));
+    }
+}

package/build/build/android/graphql.d.ts

@@ -0,0 +1,3 @@
+import { Android } from '@expo/eas-build-job';
+import { AndroidJobInput } from '../../graphql/generated';
+export declare function transformJob(job: Android.Job): AndroidJobInput;

package/build/build/android/graphql.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformJob = transformJob;
+const eas_build_job_1 = require("@expo/eas-build-job");
+const generated_1 = require("../../graphql/generated");
+const graphql_1 = require("../graphql");
+function transformJob(job) {
+    return {
+        type: (0, graphql_1.transformWorkflow)(job.type),
+        triggeredBy: (0, graphql_1.transformBuildTrigger)(job.triggeredBy),
+        projectArchive: (0, graphql_1.transformProjectArchive)(job.projectArchive),
+        projectRootDirectory: job.projectRootDirectory,
+        updates: job.updates,
+        secrets: job.secrets,
+        builderEnvironment: job.builderEnvironment,
+        cache: job.cache,
+        version: job.version?.versionCode ? { versionCode: job.version.versionCode } : undefined,
+        gradleCommand: job.gradleCommand,
+        applicationArchivePath: job.applicationArchivePath,
+        buildArtifactPaths: job.buildArtifactPaths,
+        username: job.username,
+        buildType: job.buildType && transformBuildType(job.buildType),
+        developmentClient: job.developmentClient,
+        experimental: job.experimental,
+        mode: (0, graphql_1.transformBuildMode)(job.mode),
+        customBuildConfig: job.customBuildConfig,
+        environment: job.environment,
+        loggerLevel: job.loggerLevel
+            ? graphql_1.loggerLevelToGraphQLWorkerLoggerLevel[job.loggerLevel]
+            : undefined,
+    };
+}
+function transformBuildType(buildType) {
+    if (buildType === eas_build_job_1.Android.BuildType.APK) {
+        return generated_1.AndroidBuildType.Apk;
+    }
+    else {
+        return generated_1.AndroidBuildType.AppBundle;
+    }
+}

package/build/build/android/prepareJob.d.ts

@@ -0,0 +1,9 @@
+import { Android, ArchiveSource, Platform } from '@expo/eas-build-job';
+import { AndroidCredentials } from '../../credentials/android/AndroidCredentialsProvider';
+import { BuildContext } from '../context';
+interface JobData {
+    projectArchive: ArchiveSource;
+    credentials?: AndroidCredentials;
+}
+export declare function prepareJobAsync(ctx: BuildContext<Platform.ANDROID>, jobData: JobData): Promise<Android.Job>;
+export {};

package/build/build/android/prepareJob.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareJobAsync = prepareJobAsync;
+const tslib_1 = require("tslib");
+const eas_build_job_1 = require("@expo/eas-build-job");
+const path_1 = tslib_1.__importDefault(require("path"));
+const slash_1 = tslib_1.__importDefault(require("slash"));
+const customBuildConfig_1 = require("../../project/customBuildConfig");
+const User_1 = require("../../user/User");
+const cacheDefaults = {
+    disabled: false,
+    paths: [],
+};
+async function prepareJobAsync(ctx, jobData) {
+    const username = (0, User_1.getActorUsername)(ctx.user) ?? undefined;
+    const buildProfile = ctx.buildProfile;
+    const projectRootDirectory = (0, slash_1.default)(path_1.default.relative(await ctx.vcsClient.getRootPathAsync(), ctx.projectDir)) || '.';
+    const { credentials } = jobData;
+    const buildCredentials = credentials
+        ? {
+            buildCredentials: {
+                keystore: {
+                    dataBase64: credentials.keystore.keystore,
+                    keystorePassword: credentials.keystore.keystorePassword,
+                    keyAlias: credentials.keystore.keyAlias,
+                    keyPassword: credentials.keystore.keyPassword,
+                },
+            },
+        }
+        : {};
+    let buildType = buildProfile.buildType;
+    if (!buildType && !buildProfile.gradleCommand && buildProfile.distribution === 'internal') {
+        buildType = eas_build_job_1.Android.BuildType.APK;
+    }
+    const maybeCustomBuildConfigPath = buildProfile.config
+        ? (0, customBuildConfig_1.getCustomBuildConfigPathForJob)(buildProfile.config)
+        : undefined;
+    let buildMode;
+    if (buildProfile.config) {
+        buildMode = eas_build_job_1.BuildMode.CUSTOM;
+    }
+    else {
+        buildMode = eas_build_job_1.BuildMode.BUILD;
+    }
+    const job = {
+        type: ctx.workflow,
+        platform: eas_build_job_1.Platform.ANDROID,
+        projectRootDirectory,
+        projectArchive: jobData.projectArchive,
+        builderEnvironment: {
+            image: buildProfile.image,
+            node: buildProfile.node,
+            corepack: buildProfile.corepack,
+            pnpm: buildProfile.pnpm,
+            bun: buildProfile.bun,
+            yarn: buildProfile.yarn,
+            ndk: buildProfile.ndk,
+            env: {
+                ...buildProfile.env,
+                ...(ctx.isVerboseLoggingEnabled ? { EAS_VERBOSE: '1' } : {}),
+            },
+        },
+        cache: {
+            ...cacheDefaults,
+            ...buildProfile.cache,
+            clear: ctx.clearCache,
+        },
+        secrets: {
+            ...buildCredentials,
+        },
+        updates: { channel: buildProfile.channel },
+        developmentClient: buildProfile.developmentClient,
+        gradleCommand: buildProfile.gradleCommand,
+        applicationArchivePath: buildProfile.applicationArchivePath ?? buildProfile.artifactPath,
+        buildArtifactPaths: buildProfile.buildArtifactPaths,
+        environment: ctx.buildProfile.environment,
+        buildType,
+        username,
+        ...(ctx.android.versionCodeOverride && {
+            version: {
+                versionCode: ctx.android.versionCodeOverride,
+            },
+        }),
+        experimental: {
+            prebuildCommand: buildProfile.prebuildCommand,
+        },
+        mode: buildMode,
+        triggeredBy: eas_build_job_1.BuildTrigger.EAS_CLI,
+        ...(maybeCustomBuildConfigPath && {
+            customBuildConfig: {
+                path: maybeCustomBuildConfigPath,
+            },
+        }),
+        loggerLevel: ctx.loggerLevel,
+        // Technically, these are unused, but let's include them here for type consistency.
+        // See: https://github.com/expo/eas-build/pull/454
+        appId: ctx.projectId,
+        initiatingUserId: ctx.user.id,
+    };
+    return (0, eas_build_job_1.sanitizeBuildJob)(job);
+}

package/build/build/android/syncProjectConfiguration.d.ts

@@ -0,0 +1,12 @@
+import { ExpoConfig } from '@expo/config';
+import { Env } from '@expo/eas-build-job';
+import { AndroidVersionAutoIncrement } from '@expo/eas-json';
+import { Client } from '../../vcs/vcs';
+export declare function syncProjectConfigurationAsync({ projectDir, exp, localAutoIncrement, vcsClient, env, }: {
+    projectDir: string;
+    exp: ExpoConfig;
+    localAutoIncrement?: AndroidVersionAutoIncrement;
+    vcsClient: Client;
+    env: Env | undefined;
+}): Promise<void>;
+export declare function cleanUpOldEasBuildGradleScriptAsync(projectDir: string): Promise<void>;

package/build/build/android/syncProjectConfiguration.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncProjectConfigurationAsync = syncProjectConfigurationAsync;
+exports.cleanUpOldEasBuildGradleScriptAsync = cleanUpOldEasBuildGradleScriptAsync;
+const tslib_1 = require("tslib");
+const config_plugins_1 = require("@expo/config-plugins");
+const eas_build_job_1 = require("@expo/eas-build-job");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const version_1 = require("./version");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const projectUtils_1 = require("../../project/projectUtils");
+const workflow_1 = require("../../project/workflow");
+const UpdatesModule_1 = require("../../update/android/UpdatesModule");
+async function syncProjectConfigurationAsync({ projectDir, exp, localAutoIncrement, vcsClient, env, }) {
+    const workflow = await (0, workflow_1.resolveWorkflowAsync)(projectDir, eas_build_job_1.Platform.ANDROID, vcsClient);
+    const versionBumpStrategy = resolveVersionBumpStrategy(localAutoIncrement ?? false);
+    if (workflow === eas_build_job_1.Workflow.GENERIC) {
+        await cleanUpOldEasBuildGradleScriptAsync(projectDir);
+        if ((0, projectUtils_1.isExpoUpdatesInstalled)(projectDir)) {
+            await (0, UpdatesModule_1.syncUpdatesConfigurationAsync)({ projectDir, exp, workflow, env });
+        }
+        await (0, version_1.bumpVersionAsync)({ projectDir, exp, bumpStrategy: versionBumpStrategy });
+    }
+    else {
+        await (0, version_1.bumpVersionInAppJsonAsync)({ projectDir, exp, bumpStrategy: versionBumpStrategy });
+    }
+}
+function resolveVersionBumpStrategy(autoIncrement) {
+    if (autoIncrement === true) {
+        return version_1.BumpStrategy.VERSION_CODE;
+    }
+    else if (autoIncrement === false) {
+        return version_1.BumpStrategy.NOOP;
+    }
+    else if (autoIncrement === 'versionCode') {
+        return version_1.BumpStrategy.VERSION_CODE;
+    }
+    else {
+        return version_1.BumpStrategy.APP_VERSION;
+    }
+}
+// TODO: remove this after a few months
+async function cleanUpOldEasBuildGradleScriptAsync(projectDir) {
+    const easBuildGradlePath = path_1.default.join(projectDir, 'android', 'app', 'eas-build.gradle');
+    if (await fs_extra_1.default.pathExists(easBuildGradlePath)) {
+        log_1.default.withTick(`Removing ${chalk_1.default.bold('eas-build.gradle')} as it's not longer necessary`);
+        await fs_extra_1.default.remove(easBuildGradlePath);
+        const buildGradlePath = config_plugins_1.AndroidConfig.Paths.getAppBuildGradleFilePath(projectDir);
+        const buildGradleContents = await fs_extra_1.default.readFile(buildGradlePath, 'utf-8');
+        const buildGradleContentsWithoutApply = buildGradleContents.replace(/apply from: ["'].\/eas-build.gradle["']\n/, '');
+        if (buildGradleContentsWithoutApply !== buildGradleContents) {
+            await fs_extra_1.default.writeFile(buildGradlePath, buildGradleContentsWithoutApply);
+        }
+    }
+}

package/build/build/android/version.d.ts

@@ -0,0 +1,42 @@
+import { ExpoConfig } from '@expo/config';
+import { Platform } from '@expo/eas-build-job';
+import { BuildProfile } from '@expo/eas-json';
+import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
+import { Client } from '../../vcs/vcs';
+export declare enum BumpStrategy {
+    APP_VERSION = 0,
+    VERSION_CODE = 1,
+    NOOP = 2
+}
+export declare function bumpVersionAsync({ bumpStrategy, projectDir, exp, }: {
+    projectDir: string;
+    exp: ExpoConfig;
+    bumpStrategy: BumpStrategy;
+}): Promise<void>;
+export declare function bumpVersionInAppJsonAsync({ bumpStrategy, projectDir, exp, }: {
+    bumpStrategy: BumpStrategy;
+    projectDir: string;
+    exp: ExpoConfig;
+}): Promise<void>;
+export declare function maybeResolveVersionsAsync(projectDir: string, exp: ExpoConfig, buildProfile: BuildProfile<Platform.ANDROID>, vcsClient: Client): Promise<{
+    appVersion?: string;
+    appBuildVersion?: string;
+    isVersionInitialized?: boolean;
+}>;
+export declare function updateNativeVersionsAsync({ projectDir, version, versionCode, }: {
+    projectDir: string;
+    version?: string;
+    versionCode?: number;
+}): Promise<void>;
+/**
+ * Returns buildNumber that will be used for the next build. If current build profile
+ * has an 'autoIncrement' option set, it increments the version on server.
+ */
+export declare function resolveRemoteVersionCodeAsync(graphqlClient: ExpoGraphqlClient, { projectDir, projectId, exp, applicationId, buildProfile, vcsClient, }: {
+    projectDir: string;
+    projectId: string;
+    exp: ExpoConfig;
+    applicationId: string;
+    buildProfile: BuildProfile<Platform.ANDROID>;
+    vcsClient: Client;
+}): Promise<string>;