@donotuse/eas-cli 18.5.0-rc.1

package/build/project/remoteVersionSource.d.ts

@@ -0,0 +1,17 @@
+import { ExpoConfig } from '@expo/config';
+import { Platform } from '@expo/eas-build-job';
+import { EasJson, EasJsonAccessor } from '@expo/eas-json';
+import { BuildFlags } from '../build/types';
+import { ProfileData } from '../utils/profiles';
+export declare enum AppVersionSourceUpdateOption {
+    SET_TO_REMOTE = 0,
+    SET_TO_LOCAL = 1,
+    ABORT = 2
+}
+export declare function ensureVersionSourceIsRemoteAsync(easJsonAccessor: EasJsonAccessor, { nonInteractive }: {
+    nonInteractive: boolean;
+}): Promise<void>;
+export declare function validateBuildProfileVersionSettingsAsync(profileInfo: ProfileData<'build'>, cliConfig: EasJson['cli'], projectDir: string, flags: BuildFlags): Promise<void>;
+export declare function validateAppConfigForRemoteVersionSource(exp: ExpoConfig, platform: Platform): void;
+export declare function getBuildVersionName(platform: Platform): string;
+export declare function ensureAppVersionSourceIsSetAsync(easJsonAccessor: EasJsonAccessor, easJsonCliConfig: EasJson['cli'] | undefined, nonInteractive: boolean): Promise<EasJson['cli'] | undefined>;

package/build/project/remoteVersionSource.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppVersionSourceUpdateOption = void 0;
+exports.ensureVersionSourceIsRemoteAsync = ensureVersionSourceIsRemoteAsync;
+exports.validateBuildProfileVersionSettingsAsync = validateBuildProfileVersionSettingsAsync;
+exports.validateAppConfigForRemoteVersionSource = validateAppConfigForRemoteVersionSource;
+exports.getBuildVersionName = getBuildVersionName;
+exports.ensureAppVersionSourceIsSetAsync = ensureAppVersionSourceIsSetAsync;
+const tslib_1 = require("tslib");
+const eas_build_job_1 = require("@expo/eas-build-job");
+const eas_json_1 = require("@expo/eas-json");
+const core_1 = require("@oclif/core");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const log_1 = tslib_1.__importStar(require("../log"));
+const prompts_1 = require("../prompts");
+var AppVersionSourceUpdateOption;
+(function (AppVersionSourceUpdateOption) {
+    AppVersionSourceUpdateOption[AppVersionSourceUpdateOption["SET_TO_REMOTE"] = 0] = "SET_TO_REMOTE";
+    AppVersionSourceUpdateOption[AppVersionSourceUpdateOption["SET_TO_LOCAL"] = 1] = "SET_TO_LOCAL";
+    AppVersionSourceUpdateOption[AppVersionSourceUpdateOption["ABORT"] = 2] = "ABORT";
+})(AppVersionSourceUpdateOption || (exports.AppVersionSourceUpdateOption = AppVersionSourceUpdateOption = {}));
+async function ensureVersionSourceIsRemoteAsync(easJsonAccessor, { nonInteractive }) {
+    let easJsonCliConfig = await eas_json_1.EasJsonUtils.getCliConfigAsync(easJsonAccessor);
+    if (easJsonCliConfig?.appVersionSource === undefined) {
+        easJsonCliConfig = await ensureAppVersionSourceIsSetAsync(easJsonAccessor, easJsonCliConfig ?? undefined, nonInteractive);
+    }
+    if (easJsonCliConfig?.appVersionSource === eas_json_1.AppVersionSource.REMOTE) {
+        return;
+    }
+    if (nonInteractive) {
+        throw new Error(`This project is not configured for using remote version source. Add ${chalk_1.default.bold('{"cli": { "appVersionSource": "remote" }}')} in eas.json or re-run this command without "--non-interactive" flag.`);
+    }
+    log_1.default.log(`The app version source defines whether the app version is stored locally in your project source (e.g. in app.json, Info.plist, or build.gradle) or remotely on EAS servers and only applied to the project at build time. To use this command, you will need to enable the remote version policy by adding  ${chalk_1.default.bold('{"cli": { "appVersionSource": "remote" }}')} in eas.json.`);
+    // TODO: add link to docs
+    const confirm = await (0, prompts_1.confirmAsync)({
+        message: 'Do you want to set app version source to remote now?',
+    });
+    if (!confirm) {
+        throw new Error('Aborting...');
+    }
+    await easJsonAccessor.readRawJsonAsync();
+    easJsonAccessor.patch(easJsonRawObject => {
+        easJsonRawObject.cli = { ...easJsonRawObject?.cli, appVersionSource: eas_json_1.AppVersionSource.REMOTE };
+        return easJsonRawObject;
+    });
+    await easJsonAccessor.writeAsync();
+    log_1.default.withTick('Updated eas.json');
+}
+async function validateBuildProfileVersionSettingsAsync(profileInfo, cliConfig, projectDir, flags) {
+    if (cliConfig?.appVersionSource === undefined &&
+        profileInfo.profile.autoIncrement !== 'version') {
+        if (profileInfo.profile.autoIncrement !== true) {
+            log_1.default.warn(`The field "cli.appVersionSource" is not set, but it will be required in the future. ${(0, log_1.learnMore)('https://docs.expo.dev/build-reference/app-versions/')}`);
+        }
+        else {
+            const easJsonAccessor = eas_json_1.EasJsonAccessor.fromProjectPath(projectDir);
+            cliConfig = await ensureAppVersionSourceIsSetAsync(easJsonAccessor, cliConfig, flags.nonInteractive);
+        }
+    }
+    if (cliConfig?.appVersionSource !== eas_json_1.AppVersionSource.REMOTE) {
+        return;
+    }
+    if (profileInfo.profile.autoIncrement === 'version') {
+        throw new Error(`${chalk_1.default.bold('{"autoIncrement": "version"}')} is not supported when app version source is set to remote.`);
+    }
+}
+function validateAppConfigForRemoteVersionSource(exp, platform) {
+    if (typeof exp.runtimeVersion === 'object' && exp.runtimeVersion?.policy === 'nativeVersion') {
+        throw new Error(`${chalk_1.default.bold('nativeVersion')} policy for ${chalk_1.default.bold('runtimeVersion')} is currently not supported when version source is set to remote. Switch policy e.g. to ${chalk_1.default.bold('appVersion')} or define version explicitly.`);
+    }
+    if (platform === eas_build_job_1.Platform.IOS && exp.ios?.buildNumber !== undefined) {
+        log_1.default.warn(`${chalk_1.default.bold('ios.buildNumber')} field in app config is ignored when version source is set to remote, but this value will still be in the manifest available via ${chalk_1.default.bold('expo-constants')}. It's recommended to remove this value from app config.`);
+    }
+    if (platform === eas_build_job_1.Platform.ANDROID && exp.android?.versionCode !== undefined) {
+        log_1.default.warn(`${chalk_1.default.bold('android.versionCode')} field in app config is ignored when version source is set to remote, but this value will still be in the manifest available via ${chalk_1.default.bold('expo-constants')}. It's recommended to remove this value from app config.`);
+    }
+}
+function getBuildVersionName(platform) {
+    if (platform === eas_build_job_1.Platform.ANDROID) {
+        return 'versionCode';
+    }
+    else {
+        return 'buildNumber';
+    }
+}
+async function ensureAppVersionSourceIsSetAsync(easJsonAccessor, easJsonCliConfig, nonInteractive) {
+    let selectOption, updateEasJson;
+    if (nonInteractive) {
+        log_1.default.warn(`The field "cli.appVersionSource" is not set, but it will be required in the future Proceeding with the default "local" value. ${(0, log_1.learnMore)('https://docs.expo.dev/build-reference/app-versions/')}`);
+        selectOption = AppVersionSourceUpdateOption.SET_TO_LOCAL;
+        updateEasJson = false;
+    }
+    else {
+        log_1.default.log('Since EAS CLI version `12.0.0` explicitly specifying app version source is required. Please select your app version source:');
+        log_1.default.log(`\t1) With the "local" app version source and "autoIncrement" option enabled, the build number/version code is sourced from local project files and incremented automatically if possible, by editing local project files. ${(0, log_1.learnMore)('https://docs.expo.dev/build-reference/app-versions/#local-version-source')}`);
+        log_1.default.log(`\t2) With the "remote" app version source and "autoIncrement" option enabled, the build number/version code is stored on EAS servers and updated every time you create a new build. Remote auto-incrementation won't edit the version in the local project files, but instead, the new version will be injected automatically during the build process. ${(0, log_1.learnMore)('https://docs.expo.dev/build-reference/app-versions/#remote-version-source')}`);
+        log_1.default.log(`Until now, this project has been using the "local" version source (which was the previous default). App version source can now be set for you automatically, or you can configure it manually by setting the "appVersionSource" value in your eas.json.`);
+        selectOption = await (0, prompts_1.selectAsync)(`What would you like to do?`, [
+            {
+                title: 'Update eas.json to use the default "remote" version source (recommended)',
+                value: AppVersionSourceUpdateOption.SET_TO_REMOTE,
+            },
+            {
+                title: 'Update eas.json to use "local" version source (old behavior)',
+                value: AppVersionSourceUpdateOption.SET_TO_LOCAL,
+            },
+            {
+                title: "Don't update eas.json, abort command and configure manually",
+                value: AppVersionSourceUpdateOption.ABORT,
+            },
+        ]);
+        updateEasJson = true;
+    }
+    if (selectOption === AppVersionSourceUpdateOption.SET_TO_LOCAL) {
+        if (updateEasJson) {
+            await easJsonAccessor.readRawJsonAsync();
+            easJsonAccessor.patch(easJsonRawObject => {
+                easJsonRawObject.cli = {
+                    ...easJsonRawObject?.cli,
+                    appVersionSource: eas_json_1.AppVersionSource.LOCAL,
+                };
+                return easJsonRawObject;
+            });
+            await easJsonAccessor.writeAsync();
+        }
+        if (easJsonCliConfig) {
+            easJsonCliConfig.appVersionSource = eas_json_1.AppVersionSource.LOCAL;
+        }
+        log_1.default.withTick('Updated eas.json');
+    }
+    else if (selectOption === AppVersionSourceUpdateOption.SET_TO_REMOTE) {
+        if (updateEasJson) {
+            await easJsonAccessor.readRawJsonAsync();
+            easJsonAccessor.patch(easJsonRawObject => {
+                easJsonRawObject.cli = {
+                    ...easJsonRawObject?.cli,
+                    appVersionSource: eas_json_1.AppVersionSource.REMOTE,
+                };
+                return easJsonRawObject;
+            });
+            await easJsonAccessor.writeAsync();
+        }
+        if (easJsonCliConfig) {
+            easJsonCliConfig.appVersionSource = eas_json_1.AppVersionSource.REMOTE;
+        }
+        log_1.default.withTick('Updated eas.json');
+    }
+    else {
+        log_1.default.warn(`You'll need to configure ${chalk_1.default.bold('appVersionSource')} manually. ${(0, log_1.learnMore)('https://docs.expo.dev/build-reference/app-versions/')}`);
+        core_1.Errors.error('Aborted.', { exit: 1 });
+    }
+    return easJsonCliConfig;
+}

package/build/project/resolveRuntimeVersionAsync.d.ts

@@ -0,0 +1,31 @@
+import { ExpoConfig } from '@expo/config';
+import { Env, Workflow } from '@expo/eas-build-job';
+export declare function resolveRuntimeVersionUsingCLIAsync({ platform, workflow, projectDir, env, cwd, }: {
+    platform: 'ios' | 'android';
+    workflow: Workflow;
+    projectDir: string;
+    env: Env | undefined;
+    cwd?: string;
+}): Promise<{
+    runtimeVersion: string | null;
+    expoUpdatesRuntimeFingerprint: {
+        fingerprintSources: object[];
+        isDebugFingerprintSource: boolean;
+    } | null;
+    expoUpdatesRuntimeFingerprintHash: string | null;
+}>;
+export declare function resolveRuntimeVersionAsync({ exp, platform, workflow, projectDir, env, cwd, }: {
+    exp: ExpoConfig;
+    platform: 'ios' | 'android';
+    workflow: Workflow;
+    projectDir: string;
+    env: Env | undefined;
+    cwd?: string;
+}): Promise<{
+    runtimeVersion: string | null;
+    expoUpdatesRuntimeFingerprint: {
+        fingerprintSources: object[];
+        isDebugFingerprintSource: boolean;
+    } | null;
+    expoUpdatesRuntimeFingerprintHash: string | null;
+} | null>;

package/build/project/resolveRuntimeVersionAsync.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRuntimeVersionUsingCLIAsync = resolveRuntimeVersionUsingCLIAsync;
+exports.resolveRuntimeVersionAsync = resolveRuntimeVersionAsync;
+const tslib_1 = require("tslib");
+const config_plugins_1 = require("@expo/config-plugins");
+const projectUtils_1 = require("./projectUtils");
+const log_1 = tslib_1.__importDefault(require("../log"));
+const expoUpdatesCli_1 = require("../utils/expoUpdatesCli");
+async function resolveRuntimeVersionUsingCLIAsync({ platform, workflow, projectDir, env, cwd, }) {
+    log_1.default.debug('Using expo-updates runtimeversion:resolve CLI for runtime version resolution');
+    const useDebugFingerprintSource = log_1.default.isDebug;
+    const extraArgs = useDebugFingerprintSource ? ['--debug'] : [];
+    const resolvedRuntimeVersionJSONResult = await (0, expoUpdatesCli_1.expoUpdatesCommandAsync)(projectDir, ['runtimeversion:resolve', '--platform', platform, '--workflow', workflow, ...extraArgs], { env, cwd });
+    const runtimeVersionResult = JSON.parse(resolvedRuntimeVersionJSONResult);
+    log_1.default.debug('runtimeversion:resolve output:');
+    log_1.default.debug(resolvedRuntimeVersionJSONResult);
+    return {
+        runtimeVersion: runtimeVersionResult.runtimeVersion ?? null,
+        expoUpdatesRuntimeFingerprint: runtimeVersionResult.fingerprintSources
+            ? {
+                fingerprintSources: runtimeVersionResult.fingerprintSources,
+                isDebugFingerprintSource: useDebugFingerprintSource,
+            }
+            : null,
+        expoUpdatesRuntimeFingerprintHash: runtimeVersionResult.fingerprintSources
+            ? runtimeVersionResult.runtimeVersion
+            : null,
+    };
+}
+async function resolveRuntimeVersionAsync({ exp, platform, workflow, projectDir, env, cwd, }) {
+    if (!(await (0, projectUtils_1.isModernExpoUpdatesCLIWithRuntimeVersionCommandSupportedAsync)(projectDir))) {
+        // fall back to the previous behavior (using the @expo/config-plugins eas-cli dependency rather
+        // than the versioned @expo/config-plugins dependency in the project)
+        return {
+            runtimeVersion: await config_plugins_1.Updates.getRuntimeVersionNullableAsync(projectDir, exp, platform),
+            expoUpdatesRuntimeFingerprint: null,
+            expoUpdatesRuntimeFingerprintHash: null,
+        };
+    }
+    try {
+        return await resolveRuntimeVersionUsingCLIAsync({ platform, workflow, projectDir, env, cwd });
+    }
+    catch (e) {
+        // if expo-updates is not installed, there's no need for a runtime version in the build
+        if (e instanceof expoUpdatesCli_1.ExpoUpdatesCLIModuleNotFoundError) {
+            return null;
+        }
+        throw e;
+    }
+}

package/build/project/uploadAccountScopedFileAsync.d.ts

@@ -0,0 +1,14 @@
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
+/**
+ * Uploads a file to GCS as account-scoped object.
+ * Used in workflows. Takes care of logging progress.
+ * (Uses file name when mentioning file in logs.)
+ */
+export declare function uploadAccountScopedFileAsync({ graphqlClient, accountId, filePath, maxSizeBytes, }: {
+    graphqlClient: ExpoGraphqlClient;
+    accountId: string;
+    filePath: string;
+    maxSizeBytes: number;
+}): Promise<{
+    fileBucketKey: string;
+}>;

package/build/project/uploadAccountScopedFileAsync.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadAccountScopedFileAsync = uploadAccountScopedFileAsync;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const node_fs_1 = tslib_1.__importDefault(require("node:fs"));
+const node_path_1 = tslib_1.__importDefault(require("node:path"));
+const generated_1 = require("../graphql/generated");
+const uploads_1 = require("../uploads");
+const files_1 = require("../utils/files");
+const progress_1 = require("../utils/progress");
+/**
+ * Uploads a file to GCS as account-scoped object.
+ * Used in workflows. Takes care of logging progress.
+ * (Uses file name when mentioning file in logs.)
+ */
+async function uploadAccountScopedFileAsync({ graphqlClient, accountId, filePath, maxSizeBytes, }) {
+    const fileName = node_path_1.default.basename(filePath);
+    const fileStat = await node_fs_1.default.promises.stat(filePath);
+    if (fileStat.size > maxSizeBytes) {
+        throw new Error(`File is too big. Maximum allowed size is ${(0, files_1.formatBytes)(maxSizeBytes)}.`);
+    }
+    const fileBucketKey = await (0, uploads_1.uploadAccountScopedFileAtPathToGCSAsync)(graphqlClient, {
+        accountId,
+        type: generated_1.AccountUploadSessionType.WorkflowsProjectSources,
+        path: filePath,
+        handleProgressEvent: (0, progress_1.createProgressTracker)({
+            total: fileStat.size,
+            message: ratio => `Uploading ${fileName} to EAS (${(0, files_1.formatBytes)(fileStat.size * ratio)} / ${(0, files_1.formatBytes)(fileStat.size)})`,
+            completedMessage: (duration) => `Uploaded ${fileName} to EAS ${chalk_1.default.dim(duration)}`,
+        }),
+    });
+    return { fileBucketKey };
+}

package/build/project/uploadAccountScopedProjectSourceAsync.d.ts

@@ -0,0 +1,13 @@
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
+import { Client } from '../vcs/vcs';
+/**
+ * Archives the project and uploads it to GCS as account-scoped object.
+ * Used in workflows. Takes care of logging progress and cleaning up the tarball.
+ */
+export declare function uploadAccountScopedProjectSourceAsync({ graphqlClient, vcsClient, accountId, }: {
+    graphqlClient: ExpoGraphqlClient;
+    vcsClient: Client;
+    accountId: string;
+}): Promise<{
+    projectArchiveBucketKey: string;
+}>;

package/build/project/uploadAccountScopedProjectSourceAsync.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadAccountScopedProjectSourceAsync = uploadAccountScopedProjectSourceAsync;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const node_fs_1 = tslib_1.__importDefault(require("node:fs"));
+const repository_1 = require("../build/utils/repository");
+const generated_1 = require("../graphql/generated");
+const log_1 = tslib_1.__importStar(require("../log"));
+const uploads_1 = require("../uploads");
+const files_1 = require("../utils/files");
+const progress_1 = require("../utils/progress");
+/**
+ * Archives the project and uploads it to GCS as account-scoped object.
+ * Used in workflows. Takes care of logging progress and cleaning up the tarball.
+ */
+async function uploadAccountScopedProjectSourceAsync({ graphqlClient, vcsClient, accountId, }) {
+    let projectTarballPath;
+    try {
+        log_1.default.newLine();
+        log_1.default.log(`Compressing project files and uploading to EAS. ${(0, log_1.learnMore)('https://expo.fyi/eas-build-archive')}`);
+        const projectTarball = await (0, repository_1.makeProjectTarballAsync)(vcsClient);
+        projectTarballPath = projectTarball.path;
+        (0, repository_1.maybeWarnAboutProjectTarballSize)(projectTarball.size);
+        (0, repository_1.assertProjectTarballSizeDoesNotExceedLimit)(projectTarball.size);
+        const projectArchiveBucketKey = await (0, uploads_1.uploadAccountScopedFileAtPathToGCSAsync)(graphqlClient, {
+            accountId,
+            type: generated_1.AccountUploadSessionType.WorkflowsProjectSources,
+            path: projectTarball.path,
+            handleProgressEvent: (0, progress_1.createProgressTracker)({
+                total: projectTarball.size,
+                message: ratio => `Uploading project archive to EAS (${(0, files_1.formatBytes)(projectTarball.size * ratio)} / ${(0, files_1.formatBytes)(projectTarball.size)})`,
+                completedMessage: (duration) => `Uploaded project archive to EAS ${chalk_1.default.dim(duration)}`,
+            }),
+        });
+        return { projectArchiveBucketKey };
+    }
+    finally {
+        if (projectTarballPath) {
+            await node_fs_1.default.promises.rm(projectTarballPath);
+        }
+    }
+}

package/build/project/workflow.d.ts

@@ -0,0 +1,5 @@
+import { Platform, Workflow } from '@expo/eas-build-job';
+import { Client } from '../vcs/vcs';
+export declare function resolveWorkflowAsync(projectDir: string, platform: Platform, vcsClient: Client): Promise<Workflow>;
+export declare function resolveWorkflowPerPlatformAsync(projectDir: string, vcsClient: Client): Promise<Record<Platform, Workflow>>;
+export declare function hasIgnoredIosProjectAsync(projectDir: string, vcsClient: Client): Promise<boolean>;

package/build/project/workflow.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveWorkflowAsync = resolveWorkflowAsync;
+exports.resolveWorkflowPerPlatformAsync = resolveWorkflowPerPlatformAsync;
+exports.hasIgnoredIosProjectAsync = hasIgnoredIosProjectAsync;
+const tslib_1 = require("tslib");
+const config_plugins_1 = require("@expo/config-plugins");
+const eas_build_job_1 = require("@expo/eas-build-job");
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const path_1 = tslib_1.__importDefault(require("path"));
+async function resolveWorkflowAsync(projectDir, platform, vcsClient) {
+    let platformWorkflowMarkers;
+    try {
+        platformWorkflowMarkers =
+            platform === eas_build_job_1.Platform.ANDROID
+                ? [
+                    path_1.default.join(projectDir, 'android/app/build.gradle'),
+                    await config_plugins_1.AndroidConfig.Paths.getAndroidManifestAsync(projectDir),
+                ]
+                : [config_plugins_1.IOSConfig.Paths.getPBXProjectPath(projectDir)];
+    }
+    catch {
+        return eas_build_job_1.Workflow.MANAGED;
+    }
+    const vcsRootPath = path_1.default.normalize(await vcsClient.getRootPathAsync());
+    for (const marker of platformWorkflowMarkers) {
+        if ((await fs_extra_1.default.pathExists(marker)) &&
+            !(await vcsClient.isFileIgnoredAsync(path_1.default.relative(vcsRootPath, marker)))) {
+            return eas_build_job_1.Workflow.GENERIC;
+        }
+    }
+    return eas_build_job_1.Workflow.MANAGED;
+}
+async function resolveWorkflowPerPlatformAsync(projectDir, vcsClient) {
+    const [android, ios] = await Promise.all([
+        resolveWorkflowAsync(projectDir, eas_build_job_1.Platform.ANDROID, vcsClient),
+        resolveWorkflowAsync(projectDir, eas_build_job_1.Platform.IOS, vcsClient),
+    ]);
+    return { android, ios };
+}
+async function hasIgnoredIosProjectAsync(projectDir, vcsClient) {
+    const vcsRootPath = path_1.default.normalize(await vcsClient.getRootPathAsync());
+    try {
+        const pbxProjectPath = config_plugins_1.IOSConfig.Paths.getPBXProjectPath(projectDir);
+        return await vcsClient.isFileIgnoredAsync(path_1.default.relative(vcsRootPath, pbxProjectPath));
+    }
+    finally {
+        return false;
+    }
+}

package/build/prompts.d.ts

@@ -0,0 +1,22 @@
+import { Answers, Choice, Options, PromptType } from 'prompts';
+import { Question } from './easMultiselect';
+export { PromptType, Question, Choice };
+export interface ExpoChoice<T> extends Choice {
+    value: T;
+}
+type NamelessQuestion = Omit<Question<'value'>, 'name' | 'type'>;
+export declare function promptAsync<T extends string = string>(questions: Question<T> | Question<T>[], options?: Options): Promise<Answers<T>>;
+export declare function confirmAsync(question: NamelessQuestion, options?: Options): Promise<boolean>;
+export declare function selectAsync<T>(message: string, choices: ExpoChoice<T>[], config?: {
+    options?: Options;
+    initial?: T;
+    warningMessageForDisabledEntries?: string;
+}): Promise<T>;
+/**
+ * Create a more dynamic yes/no confirmation that can be cancelled.
+ *
+ * @param questions
+ * @param options
+ */
+export declare function toggleConfirmAsync(questions: NamelessQuestion, options?: Options): Promise<boolean>;
+export declare function pressAnyKeyToContinueAsync(): Promise<void>;

package/build/prompts.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptAsync = promptAsync;
+exports.confirmAsync = confirmAsync;
+exports.selectAsync = selectAsync;
+exports.toggleConfirmAsync = toggleConfirmAsync;
+exports.pressAnyKeyToContinueAsync = pressAnyKeyToContinueAsync;
+const tslib_1 = require("tslib");
+const os_1 = require("os");
+const prompts_1 = tslib_1.__importStar(require("prompts"));
+const easMultiselect_1 = require("./easMultiselect");
+if (prompts_1.prompts) {
+    prompts_1.prompts.multiselect = easMultiselect_1.easMultiselect;
+}
+async function promptAsync(questions, options = {}) {
+    if (!process.stdin.isTTY && !global.test) {
+        const message = Array.isArray(questions) ? questions[0]?.message : questions.message;
+        throw new Error(`Input is required, but stdin is not readable. Failed to display prompt: ${message}`);
+    }
+    return await (0, prompts_1.default)(questions, {
+        onCancel() {
+            process.exit(os_1.constants.signals.SIGINT + 128); // Exit code 130 used when process is interrupted with ctrl+c.
+        },
+        ...options,
+    });
+}
+async function confirmAsync(question, options) {
+    const { value } = await promptAsync({
+        initial: true,
+        ...question,
+        name: 'value',
+        type: 'confirm',
+    }, options);
+    return value;
+}
+async function selectAsync(message, choices, config) {
+    const initial = config?.initial ? choices.findIndex(({ value }) => value === config.initial) : 0;
+    const { value } = await promptAsync({
+        message,
+        choices,
+        initial,
+        name: 'value',
+        type: 'select',
+        warn: config?.warningMessageForDisabledEntries,
+    }, config?.options ?? {});
+    return value ?? null;
+}
+/**
+ * Create a more dynamic yes/no confirmation that can be cancelled.
+ *
+ * @param questions
+ * @param options
+ */
+async function toggleConfirmAsync(questions, options) {
+    const { value } = await promptAsync({
+        active: 'yes',
+        inactive: 'no',
+        ...questions,
+        name: 'value',
+        type: 'toggle',
+    }, options);
+    return value ?? null;
+}
+async function pressAnyKeyToContinueAsync() {
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding('utf8');
+    await new Promise(res => {
+        process.stdin.on('data', key => {
+            if (String(key) === '\u0003') {
+                process.exit(os_1.constants.signals.SIGINT + 128); // ctrl-c
+            }
+            res();
+        });
+    });
+}

package/build/rollout/actions/CreateRollout.d.ts

@@ -0,0 +1,24 @@
+import { EASUpdateAction, EASUpdateContext } from '../../eas-update/utils';
+import { UpdateChannelBasicInfoFragment } from '../../graphql/generated';
+export type NonInteractiveOptions = {
+    branchNameToRollout: string;
+    percent: number;
+    runtimeVersion: string;
+};
+/**
+ * Create a rollout for the project.
+ */
+export declare class CreateRollout implements EASUpdateAction<UpdateChannelBasicInfoFragment> {
+    private readonly channelInfo;
+    private readonly options;
+    constructor(channelInfo: UpdateChannelBasicInfoFragment, options?: Partial<NonInteractiveOptions>);
+    runAsync(ctx: EASUpdateContext): Promise<UpdateChannelBasicInfoFragment>;
+    private confirmCreationAsync;
+    private getChannelObjectAsync;
+    private getLatestUpdateGroupOnBranchAsync;
+    private selectRuntimeVersionAsync;
+    private selectRuntimeVersionFromAlternativeSourceAsync;
+    private selectRuntimeVersionFromProjectConfigAsync;
+    private selectBranchAsync;
+    private resolveBranchNameAsync;
+}