@donotuse/eas-cli 18.5.0-rc.1

package/build/utils/image.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageTransparencyError = exports.ImageNonPngError = void 0;
+exports.ensurePNGIsNotTransparentAsync = ensurePNGIsNotTransparentAsync;
+exports.isPNGAsync = isPNGAsync;
+const tslib_1 = require("tslib");
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const pngjs_1 = require("pngjs");
+const fetch_1 = tslib_1.__importDefault(require("../fetch"));
+class ImageNonPngError extends Error {
+}
+exports.ImageNonPngError = ImageNonPngError;
+class ImageTransparencyError extends Error {
+}
+exports.ImageTransparencyError = ImageTransparencyError;
+async function ensurePNGIsNotTransparentAsync(imagePathOrURL) {
+    let hasAlreadyResolved = false;
+    const stream = await getImageStreamAsync(imagePathOrURL);
+    let metadata;
+    await new Promise((res, rej) => {
+        stream
+            .pipe(new pngjs_1.PNG({ filterType: 4 }))
+            .on('error', err => {
+            if (err.message.match(/Invalid file signature/)) {
+                rej(new ImageNonPngError());
+            }
+            else {
+                rej(err);
+            }
+        })
+            .on('metadata', _metadata => {
+            metadata = _metadata;
+            const { alpha } = metadata;
+            if (!alpha) {
+                hasAlreadyResolved = true;
+                if (stream instanceof fs_extra_1.default.ReadStream) {
+                    stream.close();
+                }
+                res();
+            }
+        })
+            .on('parsed', (png) => {
+            if (hasAlreadyResolved) {
+                return;
+            }
+            try {
+                // metadata should be set but assume the png is fine if it's not available
+                if (!metadata) {
+                    res();
+                    return;
+                }
+                validateAlphaChannelIsEmpty(png, { width: metadata.width, height: metadata.height });
+                res();
+            }
+            catch (err) {
+                rej(err);
+            }
+        });
+    });
+}
+async function isPNGAsync(imagePathOrURL) {
+    const stream = await getImageStreamAsync(imagePathOrURL);
+    return await new Promise((res, rej) => {
+        stream
+            .pipe(new pngjs_1.PNG({ filterType: 4 }))
+            .on('error', err => {
+            if (err.message.match(/Invalid file signature/)) {
+                res(false);
+            }
+            else {
+                rej(err);
+            }
+        })
+            .on('parsed', () => {
+            res(true);
+        });
+    });
+}
+async function getImageStreamAsync(imagePathOrURL) {
+    if (isURL(imagePathOrURL)) {
+        const response = await (0, fetch_1.default)(imagePathOrURL);
+        return response.body;
+    }
+    else {
+        return fs_extra_1.default.createReadStream(imagePathOrURL);
+    }
+}
+function isURL(imagePathOrURL) {
+    try {
+        // eslint-disable-next-line no-new
+        new URL(imagePathOrURL);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function validateAlphaChannelIsEmpty(data, { width, height }) {
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            const idx = (width * y + x) * 4;
+            if (data[idx + 3] !== 255) {
+                throw new ImageTransparencyError();
+            }
+        }
+    }
+}

package/build/utils/json.d.ts

@@ -0,0 +1,2 @@
+export declare function enableJsonOutput(): void;
+export declare function printJsonOnlyOutput(value: object): void;

package/build/utils/json.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enableJsonOutput = enableJsonOutput;
+exports.printJsonOnlyOutput = printJsonOnlyOutput;
+const tslib_1 = require("tslib");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const log_1 = tslib_1.__importDefault(require("../log"));
+let stdoutWrite;
+function enableJsonOutput() {
+    if (stdoutWrite) {
+        return;
+    }
+    stdoutWrite = process.stdout.write;
+    process.stdout.write = process.stderr.write.bind(process.stderr);
+}
+function printJsonOnlyOutput(value) {
+    (0, assert_1.default)(stdoutWrite, 'this should only be called with --json flag');
+    try {
+        process.stdout.write = stdoutWrite;
+        log_1.default.log(JSON.stringify(sanitizeValue(value), null, 2));
+    }
+    finally {
+        process.stdout.write = process.stderr.write.bind(process.stderr);
+    }
+}
+function sanitizeValue(value) {
+    if (Array.isArray(value)) {
+        return value.map(val => sanitizeValue(val));
+    }
+    else if (value && typeof value === 'object') {
+        const result = {};
+        Object.keys(value).forEach(key => {
+            if (key !== '__typename' && value[key] !== null) {
+                result[key] = sanitizeValue(value[key]);
+            }
+        });
+        return result;
+    }
+    else {
+        return value;
+    }
+}

package/build/utils/paths.d.ts

@@ -0,0 +1,7 @@
+export declare const getStateJsonPath: () => string;
+export declare const getEasBuildRunCacheDirectoryPath: () => string;
+export declare const getDataDirectory: () => string;
+export declare const getConfigDirectory: () => string;
+export declare const getCacheDirectory: () => string;
+export declare const getLogDirectory: () => string;
+export declare const getTmpDirectory: () => string;

package/build/utils/paths.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTmpDirectory = exports.getLogDirectory = exports.getCacheDirectory = exports.getConfigDirectory = exports.getDataDirectory = exports.getEasBuildRunCacheDirectoryPath = exports.getStateJsonPath = void 0;
+const tslib_1 = require("tslib");
+const env_paths_1 = tslib_1.__importDefault(require("env-paths"));
+const os_1 = require("os");
+const path = tslib_1.__importStar(require("path"));
+// The ~/.expo directory is used to store authentication sessions,
+// which are shared between EAS CLI and Expo CLI.
+function dotExpoHomeDirectory() {
+    const home = (0, os_1.homedir)();
+    if (!home) {
+        throw new Error("Can't determine your home directory; make sure your $HOME environment variable is set.");
+    }
+    let dirPath;
+    if (process.env.EXPO_STAGING) {
+        dirPath = path.join(home, '.expo-staging');
+    }
+    else if (process.env.EXPO_LOCAL) {
+        dirPath = path.join(home, '.expo-local');
+    }
+    else {
+        dirPath = path.join(home, '.expo');
+    }
+    return dirPath;
+}
+const getStateJsonPath = () => path.join(dotExpoHomeDirectory(), 'state.json');
+exports.getStateJsonPath = getStateJsonPath;
+const getEasBuildRunCacheDirectoryPath = () => path.join((0, exports.getTmpDirectory)(), 'eas-build-run-cache');
+exports.getEasBuildRunCacheDirectoryPath = getEasBuildRunCacheDirectoryPath;
+// Paths for storing things like data, config, cache, etc.
+// Should use the correct OS-specific paths (e.g. XDG base directory on Linux)
+const { data: DATA_PATH, config: CONFIG_PATH, cache: CACHE_PATH, log: LOG_PATH, temp: TEMP_PATH, } = (0, env_paths_1.default)('eas-cli');
+const getDataDirectory = () => DATA_PATH;
+exports.getDataDirectory = getDataDirectory;
+const getConfigDirectory = () => CONFIG_PATH;
+exports.getConfigDirectory = getConfigDirectory;
+const getCacheDirectory = () => CACHE_PATH;
+exports.getCacheDirectory = getCacheDirectory;
+const getLogDirectory = () => LOG_PATH;
+exports.getLogDirectory = getLogDirectory;
+const getTmpDirectory = () => TEMP_PATH;
+exports.getTmpDirectory = getTmpDirectory;

package/build/utils/plist.d.ts

@@ -0,0 +1,4 @@
+import { IOSConfig } from '@expo/config-plugins';
+export declare function readPlistAsync(plistPath: string): Promise<object | null>;
+export declare function writePlistAsync(plistPath: string, plistObject: IOSConfig.ExpoPlist | IOSConfig.InfoPlist): Promise<void>;
+export declare function parseBinaryPlistBuffer(contents: Buffer): any;

package/build/utils/plist.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readPlistAsync = readPlistAsync;
+exports.writePlistAsync = writePlistAsync;
+exports.parseBinaryPlistBuffer = parseBinaryPlistBuffer;
+const tslib_1 = require("tslib");
+const plist_1 = tslib_1.__importDefault(require("@expo/plist"));
+const bplist_parser_1 = tslib_1.__importDefault(require("bplist-parser"));
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const path_1 = tslib_1.__importDefault(require("path"));
+async function readPlistAsync(plistPath) {
+    if (await fs_extra_1.default.pathExists(plistPath)) {
+        const expoPlistContent = await fs_extra_1.default.readFile(plistPath, 'utf8');
+        try {
+            return plist_1.default.parse(expoPlistContent);
+        }
+        catch (err) {
+            err.message = `Failed to parse ${plistPath}. ${err.message}`;
+            throw err;
+        }
+    }
+    else {
+        return null;
+    }
+}
+async function writePlistAsync(plistPath, plistObject) {
+    const contents = plist_1.default.build(plistObject);
+    await fs_extra_1.default.mkdirp(path_1.default.dirname(plistPath));
+    await fs_extra_1.default.writeFile(plistPath, contents);
+}
+const CHAR_CHEVRON_OPEN = 60;
+const CHAR_B_LOWER = 98;
+function parseBinaryPlistBuffer(contents) {
+    if (contents[0] === CHAR_CHEVRON_OPEN) {
+        const info = plist_1.default.parse(contents.toString());
+        if (Array.isArray(info)) {
+            return info[0];
+        }
+        return info;
+    }
+    else if (contents[0] === CHAR_B_LOWER) {
+        const info = bplist_parser_1.default.parseBuffer(contents);
+        if (Array.isArray(info)) {
+            return info[0];
+        }
+        return info;
+    }
+    else {
+        throw new Error(`Cannot parse plist of type byte (0x${contents[0].toString(16)})`);
+    }
+}

package/build/utils/pollForBackgroundJobReceiptAsync.d.ts

@@ -0,0 +1,29 @@
+import { CombinedError } from '@urql/core';
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
+import { BackgroundJobReceiptDataFragment } from '../graphql/generated';
+export declare enum BackgroundJobReceiptPollErrorType {
+    NULL_RECEIPT = 0,
+    JOB_FAILED_NO_WILL_RETRY = 1,
+    TIMEOUT = 2
+}
+export type BackgroundJobReceiptPollErrorData = {
+    errorType: BackgroundJobReceiptPollErrorType.NULL_RECEIPT;
+} | {
+    errorType: BackgroundJobReceiptPollErrorType.JOB_FAILED_NO_WILL_RETRY;
+    receiptErrorMessage: string | undefined | null;
+} | {
+    errorType: BackgroundJobReceiptPollErrorType.TIMEOUT;
+};
+export declare class BackgroundJobReceiptPollError extends Error {
+    readonly errorData: BackgroundJobReceiptPollErrorData;
+    constructor(errorData: BackgroundJobReceiptPollErrorData);
+    static createErrorMessage(errorData: BackgroundJobReceiptPollErrorData): string;
+}
+export type BackgroundJobPollErrorCondition = (error: CombinedError) => {
+    errorIndicatesSuccess: boolean;
+};
+export declare function pollForBackgroundJobReceiptAsync(graphqlClient: ExpoGraphqlClient, backgroundJobReceipt: BackgroundJobReceiptDataFragment): Promise<BackgroundJobReceiptDataFragment>;
+export declare function pollForBackgroundJobReceiptAsync(graphqlClient: ExpoGraphqlClient, backgroundJobReceipt: BackgroundJobReceiptDataFragment, options?: {
+    onBackgroundJobReceiptPollError?: BackgroundJobPollErrorCondition;
+    pollInterval?: number;
+}): Promise<BackgroundJobReceiptDataFragment | null>;

package/build/utils/pollForBackgroundJobReceiptAsync.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BackgroundJobReceiptPollError = exports.BackgroundJobReceiptPollErrorType = void 0;
+exports.pollForBackgroundJobReceiptAsync = pollForBackgroundJobReceiptAsync;
+const core_1 = require("@urql/core");
+const set_interval_async_1 = require("set-interval-async");
+const generated_1 = require("../graphql/generated");
+const BackgroundJobReceiptQuery_1 = require("../graphql/queries/BackgroundJobReceiptQuery");
+var BackgroundJobReceiptPollErrorType;
+(function (BackgroundJobReceiptPollErrorType) {
+    BackgroundJobReceiptPollErrorType[BackgroundJobReceiptPollErrorType["NULL_RECEIPT"] = 0] = "NULL_RECEIPT";
+    BackgroundJobReceiptPollErrorType[BackgroundJobReceiptPollErrorType["JOB_FAILED_NO_WILL_RETRY"] = 1] = "JOB_FAILED_NO_WILL_RETRY";
+    BackgroundJobReceiptPollErrorType[BackgroundJobReceiptPollErrorType["TIMEOUT"] = 2] = "TIMEOUT";
+})(BackgroundJobReceiptPollErrorType || (exports.BackgroundJobReceiptPollErrorType = BackgroundJobReceiptPollErrorType = {}));
+class BackgroundJobReceiptPollError extends Error {
+    errorData;
+    constructor(errorData) {
+        super(BackgroundJobReceiptPollError.createErrorMessage(errorData));
+        this.errorData = errorData;
+    }
+    static createErrorMessage(errorData) {
+        switch (errorData.errorType) {
+            case BackgroundJobReceiptPollErrorType.NULL_RECEIPT:
+                return 'Background job receipt was null.';
+            case BackgroundJobReceiptPollErrorType.JOB_FAILED_NO_WILL_RETRY:
+                return `Background job failed with error: ${errorData.receiptErrorMessage}`;
+            case BackgroundJobReceiptPollErrorType.TIMEOUT:
+                return 'Background job timed out.';
+        }
+    }
+}
+exports.BackgroundJobReceiptPollError = BackgroundJobReceiptPollError;
+async function fetchBackgroundJobReceiptAsync(graphqlClient, receiptId) {
+    try {
+        return [await BackgroundJobReceiptQuery_1.BackgroundJobReceiptQuery.byIdAsync(graphqlClient, receiptId), null];
+    }
+    catch (error) {
+        if (error instanceof core_1.CombinedError) {
+            return [null, error];
+        }
+        throw error;
+    }
+}
+async function pollForBackgroundJobReceiptAsync(graphqlClient, backgroundJobReceipt, options) {
+    return await new Promise((resolve, reject) => {
+        let numChecks = 0;
+        const intervalHandle = (0, set_interval_async_1.setIntervalAsync)(async function pollForDeletionFinishedAsync() {
+            function failBackgroundDeletion(error) {
+                void (0, set_interval_async_1.clearIntervalAsync)(intervalHandle);
+                reject(error);
+            }
+            const [receipt, error] = await fetchBackgroundJobReceiptAsync(graphqlClient, backgroundJobReceipt.id);
+            if (!receipt) {
+                if (error instanceof core_1.CombinedError) {
+                    const errorResult = options?.onBackgroundJobReceiptPollError?.(error);
+                    if (errorResult?.errorIndicatesSuccess) {
+                        void (0, set_interval_async_1.clearIntervalAsync)(intervalHandle);
+                        resolve(null);
+                        return;
+                    }
+                }
+                failBackgroundDeletion(new BackgroundJobReceiptPollError({
+                    errorType: BackgroundJobReceiptPollErrorType.NULL_RECEIPT,
+                }));
+                return;
+            }
+            // job failed and will not retry
+            if (receipt.state === generated_1.BackgroundJobState.Failure && !receipt.willRetry) {
+                failBackgroundDeletion(new BackgroundJobReceiptPollError({
+                    errorType: BackgroundJobReceiptPollErrorType.JOB_FAILED_NO_WILL_RETRY,
+                    receiptErrorMessage: receipt.errorMessage,
+                }));
+                return;
+            }
+            // all else fails, stop polling after 90 checks. This should only happen if there's an
+            // issue with receipts not setting `willRetry` to false when they fail within a reasonable
+            // amount of time.
+            if (numChecks > 90) {
+                failBackgroundDeletion(new BackgroundJobReceiptPollError({
+                    errorType: BackgroundJobReceiptPollErrorType.TIMEOUT,
+                }));
+                return;
+            }
+            if (receipt.state === generated_1.BackgroundJobState.Success) {
+                void (0, set_interval_async_1.clearIntervalAsync)(intervalHandle);
+                resolve(receipt);
+                return;
+            }
+            numChecks++;
+        }, options?.pollInterval ?? 1000);
+    });
+}

package/build/utils/profiles.d.ts

@@ -0,0 +1,21 @@
+import { Platform } from '@expo/eas-build-job';
+import { BuildProfile, EasJsonAccessor, ProfileType, SubmitProfile } from '@expo/eas-json';
+type EasProfile<T extends ProfileType> = T extends 'build' ? BuildProfile<Platform> : SubmitProfile<Platform>;
+export type ProfileData<T extends ProfileType> = {
+    profile: EasProfile<T>;
+    platform: Platform;
+    profileName: string;
+};
+export declare function getProfilesAsync<T extends ProfileType>({ easJsonAccessor, platforms, profileName, type, projectDir, }: {
+    easJsonAccessor: EasJsonAccessor;
+    platforms: Platform[];
+    profileName?: string;
+    projectDir: string;
+    type: T;
+}): Promise<ProfileData<T>[]>;
+/**
+ * Only for testing purposes
+ */
+export declare function clearHasPrintedDeprecationWarnings(): void;
+export declare function maybePrintBuildProfileDeprecationWarningsAsync(easJsonAccessor: EasJsonAccessor, platform: Platform, profileName?: string): Promise<void>;
+export {};

package/build/utils/profiles.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProfilesAsync = getProfilesAsync;
+exports.clearHasPrintedDeprecationWarnings = clearHasPrintedDeprecationWarnings;
+exports.maybePrintBuildProfileDeprecationWarningsAsync = maybePrintBuildProfileDeprecationWarningsAsync;
+const tslib_1 = require("tslib");
+const eas_json_1 = require("@expo/eas-json");
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const log_1 = tslib_1.__importStar(require("../log"));
+async function getProfilesAsync({ easJsonAccessor, platforms, profileName, type, projectDir, }) {
+    const results = platforms.map(async function (platform) {
+        const profile = await readProfileWithOverridesAsync({
+            easJsonAccessor,
+            platform,
+            type,
+            profileName,
+            projectDir,
+        });
+        return {
+            profile,
+            profileName: profileName ?? 'production',
+            platform,
+        };
+    });
+    return await Promise.all(results);
+}
+async function maybeSetNodeVersionFromFileAsync(projectDir, profile) {
+    if (profile?.node) {
+        return;
+    }
+    const nodeVersion = await getNodeVersionFromFileAsync(projectDir);
+    if (nodeVersion) {
+        log_1.default.log(`The EAS build profile does not specify a Node.js version. Using the version specified in .nvmrc: ${nodeVersion} `);
+        profile.node = nodeVersion;
+    }
+}
+async function getNodeVersionFromFileAsync(projectDir) {
+    const nvmrcPath = path_1.default.join(projectDir, '.nvmrc');
+    if (!(await fs_extra_1.default.pathExists(nvmrcPath))) {
+        return;
+    }
+    let nodeVersion;
+    try {
+        nodeVersion = (await fs_extra_1.default.readFile(nvmrcPath, 'utf8')).toString().trim();
+    }
+    catch {
+        return undefined;
+    }
+    return nodeVersion;
+}
+async function readProfileWithOverridesAsync({ easJsonAccessor, platform, type, profileName, projectDir, }) {
+    if (type === 'build') {
+        const buildProfile = await eas_json_1.EasJsonUtils.getBuildProfileAsync(easJsonAccessor, platform, profileName);
+        await maybePrintBuildProfileDeprecationWarningsAsync(easJsonAccessor, platform, profileName);
+        await maybeSetNodeVersionFromFileAsync(projectDir, buildProfile);
+        return buildProfile;
+    }
+    else {
+        return (await eas_json_1.EasJsonUtils.getSubmitProfileAsync(easJsonAccessor, platform, profileName));
+    }
+}
+let hasPrintedDeprecationWarnings = false;
+/**
+ * Only for testing purposes
+ */
+function clearHasPrintedDeprecationWarnings() {
+    hasPrintedDeprecationWarnings = false;
+}
+async function maybePrintBuildProfileDeprecationWarningsAsync(easJsonAccessor, platform, profileName) {
+    if (hasPrintedDeprecationWarnings) {
+        return;
+    }
+    const deprecationWarnings = await eas_json_1.EasJsonUtils.getBuildProfileDeprecationWarningsAsync(easJsonAccessor, platform, profileName ?? 'production');
+    if (deprecationWarnings.length === 0) {
+        return;
+    }
+    log_1.default.newLine();
+    log_1.default.warn('Detected deprecated fields in eas.json:');
+    for (const warning of deprecationWarnings) {
+        const warnlog = warning.message.map(line => `\t${line}`).join('\n');
+        log_1.default.warn(warnlog);
+        if (warning.docsUrl) {
+            log_1.default.warn(`\t${(0, log_1.learnMore)(warning.docsUrl)}`);
+        }
+        log_1.default.newLine();
+    }
+    hasPrintedDeprecationWarnings = true;
+}

package/build/utils/progress.d.ts

@@ -0,0 +1,15 @@
+export type Progress = {
+    total: number;
+    percent: number;
+    transferred: number;
+};
+export type ProgressHandler = (props: {
+    progress?: Progress;
+    isComplete?: boolean;
+    error?: Error;
+}) => void;
+export declare function createProgressTracker({ total, message, completedMessage, }: {
+    total?: number;
+    message: string | ((ratio: number, total: number) => string);
+    completedMessage: string | ((duration: string) => string);
+}): ProgressHandler;

package/build/utils/progress.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProgressTracker = createProgressTracker;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const node_crypto_1 = require("node:crypto");
+const timer_1 = require("./timer");
+const ora_1 = require("../ora");
+function createProgressTracker({ total, message, completedMessage, }) {
+    let bar = null;
+    let calcTotal = total ?? 0;
+    let transferredSoFar = 0;
+    let current = 0;
+    const timerLabel = String((0, node_crypto_1.randomUUID)());
+    const getMessage = (v, total) => {
+        const ratio = Math.min(Math.max(v, 0), 1);
+        const percent = Math.floor(ratio * 100);
+        return typeof message === 'string'
+            ? `${message} ${percent.toFixed(0)}%`
+            : message(ratio, total);
+    };
+    return ({ progress, isComplete, error }) => {
+        if (progress) {
+            if (!bar && (progress.total !== undefined || total !== undefined)) {
+                calcTotal = total ?? progress.total;
+                bar = (0, ora_1.ora)(getMessage(0, calcTotal)).start();
+                (0, timer_1.startTimer)(timerLabel);
+            }
+            if (progress.total) {
+                calcTotal = progress.total;
+            }
+            if (bar) {
+                let percentage = 0;
+                if (progress.percent) {
+                    percentage = progress.percent;
+                }
+                else {
+                    current += progress.transferred - transferredSoFar;
+                    percentage = current / calcTotal;
+                }
+                bar.text = getMessage(percentage, calcTotal);
+            }
+            transferredSoFar = progress.transferred;
+        }
+        if (!bar) {
+            return;
+        }
+        if (isComplete) {
+            const duration = (0, timer_1.endTimer)(timerLabel);
+            const prettyTime = (0, timer_1.formatMilliseconds)(duration);
+            if (error) {
+                bar.fail();
+            }
+            else if (isComplete) {
+                if (typeof completedMessage === 'string') {
+                    bar.succeed(`${completedMessage} ${chalk_1.default.dim(prettyTime)}`);
+                }
+                else {
+                    bar.succeed(completedMessage(prettyTime));
+                }
+            }
+        }
+    };
+}

package/build/utils/promise.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Returns a promise that will be resolved after given ms milliseconds.
+ *
+ * @param ms A number of milliseconds to sleep.
+ * @returns A promise that resolves after the provided number of milliseconds.
+ */
+export declare function sleepAsync(ms: number): Promise<void>;

package/build/utils/promise.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleepAsync = sleepAsync;
+/**
+ * Returns a promise that will be resolved after given ms milliseconds.
+ *
+ * @param ms A number of milliseconds to sleep.
+ * @returns A promise that resolves after the provided number of milliseconds.
+ */
+async function sleepAsync(ms) {
+    await new Promise(res => setTimeout(res, ms));
+}

package/build/utils/prompts.d.ts

@@ -0,0 +1,32 @@
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
+import { EnvironmentSecretType, EnvironmentVariableVisibility } from '../graphql/generated';
+import { RequestedPlatform } from '../platform';
+export declare function getProjectEnvironmentVariableEnvironmentsAsync(graphqlClient: ExpoGraphqlClient, projectId: string): Promise<string[]>;
+export declare function promptVariableTypeAsync(nonInteractive: boolean, initialType?: EnvironmentSecretType): Promise<EnvironmentSecretType>;
+export declare function parseVisibility(stringVisibility: 'plaintext' | 'sensitive' | 'secret'): EnvironmentVariableVisibility;
+export declare function promptVariableVisibilityAsync(nonInteractive: boolean, selectedVisibility?: EnvironmentVariableVisibility | null): Promise<EnvironmentVariableVisibility>;
+type EnvironmentPromptArgs = {
+    nonInteractive: boolean;
+    selectedEnvironments?: string[];
+    graphqlClient?: ExpoGraphqlClient;
+    projectId?: string;
+    canEnterCustomEnvironment?: boolean;
+};
+export declare function promptVariableEnvironmentAsync(input: EnvironmentPromptArgs & {
+    multiple: true;
+}): Promise<string[]>;
+export declare function promptVariableEnvironmentAsync(input: EnvironmentPromptArgs & {
+    multiple?: false;
+}): Promise<string>;
+export declare function promptVariableValueAsync({ nonInteractive, required, hidden, filePath, initial, }: {
+    nonInteractive: boolean;
+    required?: boolean;
+    initial?: string | null;
+    filePath?: boolean;
+    hidden?: boolean;
+}): Promise<string>;
+export declare function promptVariableNameAsync(nonInteractive: boolean, initialValue?: string): Promise<string>;
+export declare function promptPlatformAsync({ message, }: {
+    message: string;
+}): Promise<RequestedPlatform>;
+export {};