@expo/package-manager 0.0.0-canary-20231122-1af9191

package/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-present 650 Industries, Inc. (aka Expo)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -0,0 +1,41 @@
+<!-- Title -->
+<h1 align="center">
+👋 Welcome to <br><code>@expo/package-manager</code>
+</h1>
+
+<p align="center">A library for installing and finding packages in a project.</p>
+
+<!-- Header -->
+
+<p align="center">
+  <img src="https://flat.badgen.net/packagephobia/install/@expo/package-manager">
+
+  <a href="https://www.npmjs.com/package/@expo/package-manager">
+    <img src="https://flat.badgen.net/npm/dw/@expo/package-manager" target="_blank" />
+  </a>
+</p>
+
+---
+
+<!-- Body -->
+
+## 🏁 Setup
+
+Install `@expo/package-manager` in your project.
+
+```sh
+yarn add @expo/package-manager
+```
+
+## ⚽️ Usage
+
+```ts
+import * as PackageManager from '@expo/package-manager';
+
+const manager = PackageManager.createForProject(projectRoot);
+
+await Promise.all([
+  manager.addDevAsync(['@expo/webpack-config']),
+  manager.addAsync(['expo', 'expo-camera']),
+]);
+```

package/build/PackageManager.d.ts

@@ -0,0 +1,46 @@
+import { SpawnOptions, SpawnPromise, SpawnResult } from '@expo/spawn-async';
+import { PendingSpawnPromise } from './utils/spawn';
+export interface PackageManagerOptions extends SpawnOptions {
+    /**
+     * If the package manager should run in silent mode.
+     * Note, this will hide possible error output from executed commands.
+     * When running in silent mode, make sure you handle them properly.
+     */
+    silent?: boolean;
+    /**
+     * The logging method used to communicate the command which is executed.
+     * Without `silent`, this defaults to `console.log`.
+     * When `silent` is set to `true`, this defaults to a no-op.
+     */
+    log?: (...args: any[]) => void;
+}
+export interface PackageManager {
+    /** The options for this package manager */
+    readonly options: PackageManagerOptions;
+    /** Run any command using the package manager */
+    runAsync(command: string[]): SpawnPromise<SpawnResult>;
+    /** Get the version of the used package manager */
+    versionAsync(): Promise<string>;
+    /** Get a single configuration property from the package manager */
+    getConfigAsync(key: string): Promise<string>;
+    /** Remove the lock file within the project, if any */
+    removeLockfileAsync(): Promise<void>;
+    /** Get the workspace root package manager, if this project is within a workspace/monorepo */
+    workspaceRoot(): PackageManager | null;
+    /** Install all current dependencies using the package manager */
+    installAsync(): Promise<SpawnResult> | SpawnPromise<SpawnResult> | PendingSpawnPromise<SpawnResult>;
+    /** Uninstall all current dependencies by removing the folder containing the packages */
+    uninstallAsync(): Promise<void>;
+    /** Add a normal dependency to the project */
+    addAsync(namesOrFlags: string[]): SpawnPromise<SpawnResult> | PendingSpawnPromise<SpawnResult>;
+    /** Add a development dependency to the project */
+    addDevAsync(namesOrFlags: string[]): SpawnPromise<SpawnResult> | PendingSpawnPromise<SpawnResult>;
+    /** Add a global dependency to the environment */
+    addGlobalAsync(namesOrFlags: string[]): SpawnPromise<SpawnResult> | PendingSpawnPromise<SpawnResult>;
+    /** Remove a normal dependency from the project */
+    removeAsync(namesOrFlags: string[]): SpawnPromise<SpawnResult> | PendingSpawnPromise<SpawnResult>;
+    /** Remove a development dependency from the project */
+    removeDevAsync(namesOrFlags: string[]): SpawnPromise<SpawnResult> | PendingSpawnPromise<SpawnResult>;
+    /** Remove a global dependency from the environments */
+    removeGlobalAsync(namesOrFlags: string[]): SpawnPromise<SpawnResult> | PendingSpawnPromise<SpawnResult>;
+}

package/build/PackageManager.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=PackageManager.js.map

package/build/PackageManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PackageManager.js","sourceRoot":"","sources":["../src/PackageManager.ts"],"names":[],"mappings":""}

package/build/index.d.ts

@@ -0,0 +1,9 @@
+export * from './PackageManager';
+export * from './ios/CocoaPodsPackageManager';
+export * from './node/NpmPackageManager';
+export * from './node/PnpmPackageManager';
+export * from './node/YarnPackageManager';
+export * from './node/BunPackageManager';
+export * from './utils/nodeManagers';
+export * from './utils/nodeWorkspaces';
+export { isYarnOfflineAsync } from './utils/yarn';

package/build/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isYarnOfflineAsync = void 0;
+__exportStar(require("./PackageManager"), exports);
+__exportStar(require("./ios/CocoaPodsPackageManager"), exports);
+__exportStar(require("./node/NpmPackageManager"), exports);
+__exportStar(require("./node/PnpmPackageManager"), exports);
+__exportStar(require("./node/YarnPackageManager"), exports);
+__exportStar(require("./node/BunPackageManager"), exports);
+__exportStar(require("./utils/nodeManagers"), exports);
+__exportStar(require("./utils/nodeWorkspaces"), exports);
+var yarn_1 = require("./utils/yarn");
+Object.defineProperty(exports, "isYarnOfflineAsync", { enumerable: true, get: function () { return yarn_1.isYarnOfflineAsync; } });
+//# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,mDAAiC;AAEjC,gEAA8C;AAE9C,2DAAyC;AACzC,4DAA0C;AAC1C,4DAA0C;AAC1C,2DAAyC;AAEzC,uDAAqC;AACrC,yDAAuC;AACvC,qCAAkD;AAAzC,0GAAA,kBAAkB,OAAA"}

package/build/ios/CocoaPodsPackageManager.d.ts

@@ -0,0 +1,74 @@
+import spawnAsync, { SpawnOptions, SpawnResult } from '@expo/spawn-async';
+import { Ora } from 'ora';
+export type CocoaPodsErrorCode = 'NON_INTERACTIVE' | 'NO_CLI' | 'COMMAND_FAILED';
+export declare class CocoaPodsError extends Error {
+    code: CocoaPodsErrorCode;
+    cause?: Error | undefined;
+    readonly name = "CocoaPodsError";
+    readonly isPackageManagerError = true;
+    constructor(message: string, code: CocoaPodsErrorCode, cause?: Error | undefined);
+}
+export declare function extractMissingDependencyError(errorOutput: string): [string, string] | null;
+export declare class CocoaPodsPackageManager {
+    options: SpawnOptions;
+    private silent;
+    static getPodProjectRoot(projectRoot: string): string | null;
+    static isUsingPods(projectRoot: string): boolean;
+    static gemInstallCLIAsync(nonInteractive?: boolean, spawnOptions?: SpawnOptions): Promise<void>;
+    static brewLinkCLIAsync(spawnOptions?: SpawnOptions): Promise<void>;
+    static brewInstallCLIAsync(spawnOptions?: SpawnOptions): Promise<void>;
+    static installCLIAsync({ nonInteractive, spawnOptions, }: {
+        nonInteractive?: boolean;
+        spawnOptions?: SpawnOptions;
+    }): Promise<boolean>;
+    static isAvailable(projectRoot: string, silent: boolean): boolean;
+    static isCLIInstalledAsync(spawnOptions?: SpawnOptions): Promise<boolean>;
+    constructor({ cwd, silent }: {
+        cwd: string;
+        silent?: boolean;
+    });
+    get name(): string;
+    /** Runs `pod install` and attempts to automatically run known troubleshooting steps automatically. */
+    installAsync({ spinner }?: {
+        spinner?: Ora;
+    }): Promise<void>;
+    isCLIInstalledAsync(): Promise<boolean>;
+    installCLIAsync(): Promise<boolean>;
+    handleInstallErrorAsync({ error, shouldUpdate, updatedPackages, spinner, }: {
+        error: any;
+        spinner?: Ora;
+        shouldUpdate?: boolean;
+        updatedPackages?: string[];
+    }): Promise<spawnAsync.SpawnResult>;
+    private _installAsync;
+    private runInstallTypeCommandAsync;
+    addWithParametersAsync(names: string[], parameters: string[]): Promise<void>;
+    addAsync(names?: string[]): void;
+    addDevAsync(names?: string[]): void;
+    addGlobalAsync(names?: string[]): void;
+    removeAsync(names?: string[]): void;
+    removeDevAsync(names?: string[]): void;
+    removeGlobalAsync(names?: string[]): void;
+    versionAsync(): Promise<string>;
+    configAsync(key: string): Promise<string>;
+    removeLockfileAsync(): Promise<void>;
+    uninstallAsync(): Promise<void>;
+    private podRepoUpdateAsync;
+    _runAsync(args: string[]): Promise<SpawnResult>;
+}
+export declare function getPodUpdateMessage(output: string): {
+    updatePackage: string | null;
+    shouldUpdateRepo: boolean;
+};
+export declare function getPodRepoUpdateMessage(errorOutput: string): {
+    updatePackage: string | null;
+    shouldUpdateRepo: boolean;
+    message: string;
+};
+/**
+ * Format the CocoaPods CLI install error.
+ *
+ * @param error Error from CocoaPods CLI `pod install` command.
+ * @returns
+ */
+export declare function getImprovedPodInstallError(error: SpawnResult & Error, { cwd }: Pick<SpawnOptions, 'cwd'>): Error;

package/build/ios/CocoaPodsPackageManager.js

@@ -0,0 +1,404 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getImprovedPodInstallError = exports.getPodRepoUpdateMessage = exports.getPodUpdateMessage = exports.CocoaPodsPackageManager = exports.extractMissingDependencyError = exports.CocoaPodsError = void 0;
+const spawn_async_1 = __importDefault(require("@expo/spawn-async"));
+const chalk_1 = __importDefault(require("chalk"));
+const fs_1 = require("fs");
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const spawn_1 = require("../utils/spawn");
+class CocoaPodsError extends Error {
+    code;
+    cause;
+    name = 'CocoaPodsError';
+    isPackageManagerError = true;
+    constructor(message, code, cause) {
+        super(cause ? `${message}\n└─ Cause: ${cause.message}` : message);
+        this.code = code;
+        this.cause = cause;
+    }
+}
+exports.CocoaPodsError = CocoaPodsError;
+function extractMissingDependencyError(errorOutput) {
+    // [!] Unable to find a specification for `expo-dev-menu-interface` depended upon by `expo-dev-launcher`
+    const results = errorOutput.match(/Unable to find a specification for ['"`]([\w-_\d\s]+)['"`] depended upon by ['"`]([\w-_\d\s]+)['"`]/);
+    if (results) {
+        return [results[1], results[2]];
+    }
+    return null;
+}
+exports.extractMissingDependencyError = extractMissingDependencyError;
+class CocoaPodsPackageManager {
+    options;
+    silent;
+    static getPodProjectRoot(projectRoot) {
+        if (CocoaPodsPackageManager.isUsingPods(projectRoot))
+            return projectRoot;
+        const iosProject = path_1.default.join(projectRoot, 'ios');
+        if (CocoaPodsPackageManager.isUsingPods(iosProject))
+            return iosProject;
+        const macOsProject = path_1.default.join(projectRoot, 'macos');
+        if (CocoaPodsPackageManager.isUsingPods(macOsProject))
+            return macOsProject;
+        return null;
+    }
+    static isUsingPods(projectRoot) {
+        return (0, fs_1.existsSync)(path_1.default.join(projectRoot, 'Podfile'));
+    }
+    static async gemInstallCLIAsync(nonInteractive = false, spawnOptions = { stdio: 'inherit' }) {
+        const options = ['install', 'cocoapods', '--no-document'];
+        try {
+            // In case the user has run sudo before running the command we can properly install CocoaPods without prompting for an interaction.
+            await (0, spawn_async_1.default)('gem', options, spawnOptions);
+        }
+        catch (error) {
+            if (nonInteractive) {
+                throw new CocoaPodsError('Failed to install CocoaPods CLI with gem (recommended)', 'COMMAND_FAILED', error);
+            }
+            // If the user doesn't have permission then we can prompt them to use sudo.
+            await (0, spawn_1.spawnSudoAsync)(['gem', ...options], spawnOptions);
+        }
+    }
+    static async brewLinkCLIAsync(spawnOptions = { stdio: 'inherit' }) {
+        await (0, spawn_async_1.default)('brew', ['link', 'cocoapods'], spawnOptions);
+    }
+    static async brewInstallCLIAsync(spawnOptions = { stdio: 'inherit' }) {
+        await (0, spawn_async_1.default)('brew', ['install', 'cocoapods'], spawnOptions);
+    }
+    static async installCLIAsync({ nonInteractive = false, spawnOptions = { stdio: 'inherit' }, }) {
+        if (!spawnOptions) {
+            spawnOptions = { stdio: 'inherit' };
+        }
+        const silent = !!spawnOptions.ignoreStdio;
+        try {
+            !silent && console.log(`\u203A Attempting to install CocoaPods CLI with Gem`);
+            await CocoaPodsPackageManager.gemInstallCLIAsync(nonInteractive, spawnOptions);
+            !silent && console.log(`\u203A Successfully installed CocoaPods CLI with Gem`);
+            return true;
+        }
+        catch (error) {
+            if (!silent) {
+                console.log(chalk_1.default.yellow(`\u203A Failed to install CocoaPods CLI with Gem`));
+                console.log(chalk_1.default.red(error.stderr ?? error.message));
+                console.log(`\u203A Attempting to install CocoaPods CLI with Homebrew`);
+            }
+            try {
+                await CocoaPodsPackageManager.brewInstallCLIAsync(spawnOptions);
+                if (!(await CocoaPodsPackageManager.isCLIInstalledAsync(spawnOptions))) {
+                    try {
+                        await CocoaPodsPackageManager.brewLinkCLIAsync(spawnOptions);
+                        // Still not available after linking? Bail out
+                        if (!(await CocoaPodsPackageManager.isCLIInstalledAsync(spawnOptions))) {
+                            throw new CocoaPodsError('CLI could not be installed automatically with gem or Homebrew, please install CocoaPods manually and try again', 'NO_CLI', error);
+                        }
+                    }
+                    catch (error) {
+                        throw new CocoaPodsError('Homebrew installation appeared to succeed but CocoaPods CLI not found in PATH and unable to link.', 'NO_CLI', error);
+                    }
+                }
+                !silent && console.log(`\u203A Successfully installed CocoaPods CLI with Homebrew`);
+                return true;
+            }
+            catch (error) {
+                !silent &&
+                    console.warn(chalk_1.default.yellow(`\u203A Failed to install CocoaPods with Homebrew. Please install CocoaPods CLI manually and try again.`));
+                throw new CocoaPodsError(`Failed to install CocoaPods with Homebrew. Please install CocoaPods CLI manually and try again.`, 'NO_CLI', error);
+            }
+        }
+    }
+    static isAvailable(projectRoot, silent) {
+        if (process.platform !== 'darwin') {
+            !silent && console.log(chalk_1.default.red('CocoaPods is only supported on macOS machines'));
+            return false;
+        }
+        if (!CocoaPodsPackageManager.isUsingPods(projectRoot)) {
+            !silent && console.log(chalk_1.default.yellow('CocoaPods is not supported in this project'));
+            return false;
+        }
+        return true;
+    }
+    static async isCLIInstalledAsync(spawnOptions = { stdio: 'inherit' }) {
+        try {
+            await (0, spawn_async_1.default)('pod', ['--version'], spawnOptions);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    constructor({ cwd, silent }) {
+        this.silent = !!silent;
+        this.options = {
+            cwd,
+            // We use pipe by default instead of inherit so that we can capture stderr/stdout and process it for errors.
+            // Later we'll also pipe the stdout/stderr to the terminal when silent is false.
+            stdio: 'pipe',
+        };
+    }
+    get name() {
+        return 'CocoaPods';
+    }
+    /** Runs `pod install` and attempts to automatically run known troubleshooting steps automatically. */
+    async installAsync({ spinner } = {}) {
+        await this._installAsync({ spinner });
+    }
+    isCLIInstalledAsync() {
+        return CocoaPodsPackageManager.isCLIInstalledAsync(this.options);
+    }
+    installCLIAsync() {
+        return CocoaPodsPackageManager.installCLIAsync({
+            nonInteractive: true,
+            spawnOptions: this.options,
+        });
+    }
+    async handleInstallErrorAsync({ error, shouldUpdate = true, updatedPackages = [], spinner, }) {
+        // Unknown errors are rethrown.
+        if (!error.output) {
+            throw error;
+        }
+        // To emulate a `pod install --repo-update` error, enter your `ios/Podfile.lock` and change one of `PODS` version numbers to some lower value.
+        // const isPodRepoUpdateError = shouldPodRepoUpdate(output);
+        if (!shouldUpdate) {
+            // If we can't automatically fix the error, we'll just rethrow it with some known troubleshooting info.
+            throw getImprovedPodInstallError(error, {
+                cwd: this.options.cwd,
+            });
+        }
+        // Collect all of the spawn info.
+        const errorOutput = error.output.join(os_1.default.EOL).trim();
+        // Extract useful information from the error message and push it to the spinner.
+        const { updatePackage, shouldUpdateRepo } = getPodUpdateMessage(errorOutput);
+        if (!updatePackage || updatedPackages.includes(updatePackage)) {
+            // `pod install --repo-update`...
+            // Attempt to install again but this time with install --repo-update enabled.
+            return await this._installAsync({
+                spinner,
+                shouldRepoUpdate: true,
+                // Include a boolean to ensure pod install --repo-update isn't invoked in the unlikely case where the pods fail to update.
+                shouldUpdate: false,
+                updatedPackages,
+            });
+        }
+        // Store the package we should update to prevent a loop.
+        updatedPackages.push(updatePackage);
+        // If a single package is broken, we'll try to update it.
+        // You can manually test this by changing a version number in your `Podfile.lock`.
+        // Attempt `pod update <package> <--no-repo-update>` and then try again.
+        return await this.runInstallTypeCommandAsync(['update', updatePackage, shouldUpdateRepo ? '' : '--no-repo-update'].filter(Boolean), {
+            formatWarning() {
+                const updateMessage = `Failed to update ${chalk_1.default.bold(updatePackage)}. Attempting to update the repo instead.`;
+                return updateMessage;
+            },
+            spinner,
+            updatedPackages,
+        });
+        // // If update succeeds, we'll try to install again (skipping `pod install --repo-update`).
+        // return await this._installAsync({
+        //   spinner,
+        //   shouldUpdate: false,
+        //   updatedPackages,
+        // });
+    }
+    async _installAsync({ shouldRepoUpdate, ...props } = {}) {
+        return await this.runInstallTypeCommandAsync(['install', shouldRepoUpdate ? '--repo-update' : ''].filter(Boolean), {
+            formatWarning(error) {
+                // Extract useful information from the error message and push it to the spinner.
+                return getPodRepoUpdateMessage(error.output.join(os_1.default.EOL).trim()).message;
+            },
+            ...props,
+        });
+    }
+    async runInstallTypeCommandAsync(command, { formatWarning, ...props } = {}) {
+        try {
+            return await this._runAsync(command);
+        }
+        catch (error) {
+            if (formatWarning) {
+                const warning = formatWarning(error);
+                if (props.spinner) {
+                    props.spinner.text = chalk_1.default.bold(warning);
+                }
+                if (!this.silent) {
+                    console.warn(chalk_1.default.yellow(warning));
+                }
+            }
+            return await this.handleInstallErrorAsync({ error, ...props });
+        }
+    }
+    async addWithParametersAsync(names, parameters) {
+        throw new Error('Unimplemented');
+    }
+    addAsync(names = []) {
+        throw new Error('Unimplemented');
+    }
+    addDevAsync(names = []) {
+        throw new Error('Unimplemented');
+    }
+    addGlobalAsync(names = []) {
+        throw new Error('Unimplemented');
+    }
+    removeAsync(names = []) {
+        throw new Error('Unimplemented');
+    }
+    removeDevAsync(names = []) {
+        throw new Error('Unimplemented');
+    }
+    removeGlobalAsync(names = []) {
+        throw new Error('Unimplemented');
+    }
+    async versionAsync() {
+        const { stdout } = await (0, spawn_async_1.default)('pod', ['--version'], this.options);
+        return stdout.trim();
+    }
+    async configAsync(key) {
+        throw new Error('Unimplemented');
+    }
+    async removeLockfileAsync() {
+        throw new Error('Unimplemented');
+    }
+    async uninstallAsync() {
+        throw new Error('Unimplemented');
+    }
+    // Private
+    async podRepoUpdateAsync() {
+        try {
+            await this._runAsync(['repo', 'update']);
+        }
+        catch (error) {
+            error.message = error.message || (error.stderr ?? error.stdout);
+            throw new CocoaPodsError('The command `pod install --repo-update` failed', 'COMMAND_FAILED', error);
+        }
+    }
+    // Exposed for testing
+    async _runAsync(args) {
+        if (!this.silent) {
+            console.log(`> pod ${args.join(' ')}`);
+        }
+        const promise = (0, spawn_async_1.default)('pod', [
+            ...args,
+            // Enables colors while collecting output.
+            '--ansi',
+        ], {
+            // Add the cwd and other options to the spawn options.
+            ...this.options,
+            // We use pipe by default instead of inherit so that we can capture stderr/stdout and process it for errors.
+            // This is particularly required for the `pod install --repo-update` error.
+            // Later we'll also pipe the stdout/stderr to the terminal when silent is false,
+            // currently this means we lose out on the ansi colors unless passing the `--ansi` flag to every command.
+            stdio: 'pipe',
+        });
+        if (!this.silent) {
+            // If not silent, pipe the stdout/stderr to the terminal.
+            // We only do this when the `stdio` is set to `pipe` (collect the results for parsing), `inherit` won't contain `promise.child`.
+            if (promise.child.stdout) {
+                promise.child.stdout.pipe(process.stdout);
+            }
+        }
+        return await promise;
+    }
+}
+exports.CocoaPodsPackageManager = CocoaPodsPackageManager;
+/** When pods are outdated, they'll throw an error informing you to run "pod install --repo-update" */
+function shouldPodRepoUpdate(errorOutput) {
+    const output = errorOutput;
+    const isPodRepoUpdateError = output.includes('pod repo update') || output.includes('--no-repo-update');
+    return isPodRepoUpdateError;
+}
+function getPodUpdateMessage(output) {
+    const props = output.match(/run ['"`]pod update ([\w-_\d/]+)( --no-repo-update)?['"`] to apply changes/);
+    return {
+        updatePackage: props?.[1] ?? null,
+        shouldUpdateRepo: !props?.[2],
+    };
+}
+exports.getPodUpdateMessage = getPodUpdateMessage;
+function getPodRepoUpdateMessage(errorOutput) {
+    const warningInfo = extractMissingDependencyError(errorOutput);
+    const brokenPackage = getPodUpdateMessage(errorOutput);
+    let message;
+    if (warningInfo) {
+        message = `Couldn't install: ${warningInfo[1]} » ${chalk_1.default.underline(warningInfo[0])}.`;
+    }
+    else if (brokenPackage?.updatePackage) {
+        message = `Couldn't install: ${brokenPackage?.updatePackage}.`;
+    }
+    else {
+        message = `Couldn't install Pods.`;
+    }
+    message += ` Updating the Pods project and trying again...`;
+    return { message, ...brokenPackage };
+}
+exports.getPodRepoUpdateMessage = getPodRepoUpdateMessage;
+/**
+ * Format the CocoaPods CLI install error.
+ *
+ * @param error Error from CocoaPods CLI `pod install` command.
+ * @returns
+ */
+function getImprovedPodInstallError(error, { cwd = process.cwd() }) {
+    // Collect all of the spawn info.
+    const errorOutput = error.output.join(os_1.default.EOL).trim();
+    if (error.stdout.match(/No [`'"]Podfile[`'"] found in the project directory/)) {
+        // Ran pod install but no Podfile was found.
+        error.message = `No Podfile found in directory: ${cwd}. Ensure CocoaPods is setup any try again.`;
+    }
+    else if (shouldPodRepoUpdate(errorOutput)) {
+        // Ran pod install but the install --repo-update step failed.
+        const warningInfo = extractMissingDependencyError(errorOutput);
+        let reason;
+        if (warningInfo) {
+            reason = `Couldn't install: ${warningInfo[1]} » ${chalk_1.default.underline(warningInfo[0])}`;
+        }
+        else {
+            reason = `This is often due to native package versions mismatching`;
+        }
+        // Attempt to provide a helpful message about the missing NPM dependency (containing a CocoaPod) since React Native
+        // developers will almost always be using autolinking and not interacting with CocoaPods directly.
+        let solution;
+        if (warningInfo?.[0]) {
+            // If the missing package is named `expo-dev-menu`, `react-native`, etc. then it might not be installed in the project.
+            if (warningInfo[0].match(/^(?:@?expo|@?react)(-|\/)/)) {
+                solution = `Ensure the node module "${warningInfo[0]}" is installed in your project, then run 'npx pod-install' to try again.`;
+            }
+            else {
+                solution = `Ensure the CocoaPod "${warningInfo[0]}" is installed in your project, then run 'npx pod-install' to try again.`;
+            }
+        }
+        else {
+            // Brute force
+            solution = `Try deleting the 'ios/Pods' folder or the 'ios/Podfile.lock' file and running 'npx pod-install' to resolve.`;
+        }
+        error.message = `${reason}. ${solution}`;
+        // Attempt to provide the troubleshooting info from CocoaPods CLI at the bottom of the error message.
+        if (error.stdout) {
+            const cocoapodsDebugInfo = error.stdout.split(os_1.default.EOL);
+            // The troubleshooting info starts with `[!]`, capture everything after that.
+            const firstWarning = cocoapodsDebugInfo.findIndex((v) => v.startsWith('[!]'));
+            if (firstWarning !== -1) {
+                const warning = cocoapodsDebugInfo.slice(firstWarning).join(os_1.default.EOL);
+                error.message += `\n\n${chalk_1.default.gray(warning)}`;
+            }
+        }
+        return new CocoaPodsError('Command `pod install --repo-update` failed.', 'COMMAND_FAILED', error);
+    }
+    else {
+        let stderr = error.stderr.trim();
+        // CocoaPods CLI prints the useful error to stdout...
+        const usefulError = error.stdout.match(/\[!\]\s((?:.|\n)*)/)?.[1];
+        // If there is a useful error message then prune the less useful info.
+        if (usefulError) {
+            // Delete unhelpful CocoaPods CLI error message.
+            if (error.message?.match(/pod exited with non-zero code: 1/)) {
+                error.message = '';
+            }
+            stderr = null;
+        }
+        error.message = [usefulError, error.message, stderr].filter(Boolean).join('\n');
+    }
+    return new CocoaPodsError('Command `pod install` failed.', 'COMMAND_FAILED', error);
+}
+exports.getImprovedPodInstallError = getImprovedPodInstallError;
+//# sourceMappingURL=CocoaPodsPackageManager.js.map