@ohos-ports/nx 23.2.1-beta.0 → 23.3.0-beta.0

package/dist/src/utils/catalog/pnpm-manager.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PnpmCatalogManager = void 0;
+const manager_1 = require("./manager");
+const manager_utils_1 = require("./manager-utils");
+const PNPM_WORKSPACE_FILENAME = 'pnpm-workspace.yaml';
+/**
+ * PNPM-specific catalog manager implementation
+ */
+class PnpmCatalogManager {
+    constructor() {
+        this.name = 'pnpm';
+        this.catalogProtocol = 'catalog:';
+        // Parsed fs-root definitions, cached per pass. See readCatalogDefinitions.
+        this.definitionsByRoot = new Map();
+    }
+    isCatalogReference(version) {
+        return version.startsWith(this.catalogProtocol);
+    }
+    parseCatalogReference(version) {
+        if (!this.isCatalogReference(version)) {
+            return null;
+        }
+        const catalogName = version.substring(this.catalogProtocol.length);
+        // Normalize both "catalog:" and "catalog:default" to the same representation
+        const isDefault = !catalogName || catalogName === 'default';
+        return {
+            catalogName: isDefault ? undefined : catalogName,
+            isDefaultCatalog: isDefault,
+        };
+    }
+    getCatalogDefinitionFilePaths() {
+        return [PNPM_WORKSPACE_FILENAME];
+    }
+    getCatalogDefinitions(treeOrRoot) {
+        return (0, manager_utils_1.readCatalogDefinitions)(PNPM_WORKSPACE_FILENAME, treeOrRoot, this.definitionsByRoot);
+    }
+    resolveCatalogReference(treeOrRoot, packageName, version) {
+        const catalogRef = this.parseCatalogReference(version);
+        if (!catalogRef) {
+            return null;
+        }
+        const catalogDefs = this.getCatalogDefinitions(treeOrRoot);
+        if (!catalogDefs) {
+            return null;
+        }
+        let catalogToUse;
+        if (catalogRef.isDefaultCatalog) {
+            // Check both locations for default catalog
+            catalogToUse = catalogDefs.catalog ?? catalogDefs.catalogs?.default;
+        }
+        else if (catalogRef.catalogName) {
+            catalogToUse = catalogDefs.catalogs?.[catalogRef.catalogName];
+        }
+        return catalogToUse?.[packageName] || null;
+    }
+    getCatalogReferencesForPackage(treeOrRoot, packageName) {
+        return (0, manager_1.collectCatalogReferencesForPackage)(this, treeOrRoot, packageName);
+    }
+    validateCatalogReference(treeOrRoot, packageName, version) {
+        const catalogRef = this.parseCatalogReference(version);
+        if (!catalogRef) {
+            throw new Error(`Invalid catalog reference syntax: "${version}". Expected format: "catalog:" or "catalog:name"`);
+        }
+        const catalogDefs = this.getCatalogDefinitions(treeOrRoot);
+        if (!catalogDefs) {
+            throw new Error((0, manager_1.formatCatalogError)(`Cannot get Pnpm catalog definitions. No ${PNPM_WORKSPACE_FILENAME} found in workspace root.`, [`Create a ${PNPM_WORKSPACE_FILENAME} file in your workspace root`]));
+        }
+        let catalogToUse;
+        if (catalogRef.isDefaultCatalog) {
+            const hasCatalog = !!catalogDefs.catalog;
+            const hasCatalogsDefault = !!catalogDefs.catalogs?.default;
+            // Error if both defined (matches pnpm behavior)
+            if (hasCatalog && hasCatalogsDefault) {
+                throw new Error("The 'default' catalog was defined multiple times. Use the 'catalog' field or 'catalogs.default', but not both.");
+            }
+            catalogToUse = catalogDefs.catalog ?? catalogDefs.catalogs?.default;
+            if (!catalogToUse) {
+                const availableCatalogs = Object.keys(catalogDefs.catalogs || {});
+                const suggestions = [
+                    `Define a default catalog in ${PNPM_WORKSPACE_FILENAME} under the "catalog" key`,
+                ];
+                if (availableCatalogs.length > 0) {
+                    suggestions.push(`Or select from the available named catalogs: ${availableCatalogs
+                        .map((c) => `"catalog:${c}"`)
+                        .join(', ')}`);
+                }
+                throw new Error((0, manager_1.formatCatalogError)(`No default catalog defined in ${PNPM_WORKSPACE_FILENAME}`, suggestions));
+            }
+        }
+        else if (catalogRef.catalogName) {
+            catalogToUse = catalogDefs.catalogs?.[catalogRef.catalogName];
+            if (!catalogToUse) {
+                const availableCatalogs = Object.keys(catalogDefs.catalogs || {}).filter((c) => c !== 'default');
+                const defaultCatalog = !!catalogDefs.catalog
+                    ? 'catalog'
+                    : !catalogDefs.catalogs?.default
+                        ? 'catalogs.default'
+                        : null;
+                const suggestions = [
+                    `Define the catalog in ${PNPM_WORKSPACE_FILENAME} under the "catalogs" key`,
+                ];
+                if (availableCatalogs.length > 0) {
+                    suggestions.push(`Or select from the available named catalogs: ${availableCatalogs
+                        .map((c) => `"catalog:${c}"`)
+                        .join(', ')}`);
+                }
+                if (defaultCatalog) {
+                    suggestions.push(`Or use the default catalog ("${defaultCatalog}")`);
+                }
+                throw new Error((0, manager_1.formatCatalogError)(`Catalog "${catalogRef.catalogName}" not found in ${PNPM_WORKSPACE_FILENAME}`, suggestions));
+            }
+        }
+        if (!catalogToUse[packageName]) {
+            let catalogName;
+            if (catalogRef.isDefaultCatalog) {
+                // Context-aware messaging based on which location exists
+                const hasCatalog = !!catalogDefs.catalog;
+                catalogName = hasCatalog
+                    ? 'default catalog ("catalog")'
+                    : 'default catalog ("catalogs.default")';
+            }
+            else {
+                catalogName = `catalog '${catalogRef.catalogName}'`;
+            }
+            const availablePackages = Object.keys(catalogToUse);
+            const suggestions = [
+                `Add "${packageName}" to ${catalogName} in ${PNPM_WORKSPACE_FILENAME}`,
+            ];
+            if (availablePackages.length > 0) {
+                suggestions.push(`Or select from the available packages in ${catalogName}: ${availablePackages
+                    .map((p) => `"${p}"`)
+                    .join(', ')}`);
+            }
+            throw new Error((0, manager_1.formatCatalogError)(`Package "${packageName}" not found in ${catalogName}`, suggestions));
+        }
+    }
+    updateCatalogVersions(treeOrRoot, updates) {
+        (0, manager_utils_1.updateCatalogVersionsInFile)(PNPM_WORKSPACE_FILENAME, treeOrRoot, updates);
+    }
+}
+exports.PnpmCatalogManager = PnpmCatalogManager;

package/dist/src/utils/catalog/types.d.ts

@@ -0,0 +1,15 @@
+export interface CatalogReference {
+    catalogName?: string;
+    isDefaultCatalog: boolean;
+}
+export interface CatalogReferenceMatch {
+    catalogRef: string;
+    versionSpec: string;
+}
+export interface CatalogEntry {
+    [packageName: string]: string;
+}
+export interface CatalogDefinitions {
+    catalog?: CatalogEntry;
+    catalogs?: Record<string, CatalogEntry>;
+}

package/dist/src/utils/catalog/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/utils/catalog/yarn-manager.d.ts

@@ -0,0 +1,26 @@
+import type { Tree } from '../../generators/tree';
+import { type CatalogManager } from './manager';
+import type { CatalogDefinitions, CatalogReference, CatalogReferenceMatch } from './types';
+/**
+ * Yarn Berry (v4.10+) catalog manager implementation.
+ *
+ * Unlike pnpm, the name "default" is not special: `catalog:` resolves only
+ * against `catalog`, and `catalog:default` against `catalogs.default`.
+ */
+export declare class YarnCatalogManager implements CatalogManager {
+    readonly name = "yarn";
+    readonly catalogProtocol = "catalog:";
+    private definitionsByRoot;
+    isCatalogReference(version: string): boolean;
+    parseCatalogReference(version: string): CatalogReference | null;
+    getCatalogDefinitionFilePaths(): string[];
+    getCatalogDefinitions(treeOrRoot: Tree | string): CatalogDefinitions | null;
+    resolveCatalogReference(treeOrRoot: Tree | string, packageName: string, version: string): string | null;
+    getCatalogReferencesForPackage(treeOrRoot: Tree | string, packageName: string): CatalogReferenceMatch[];
+    validateCatalogReference(treeOrRoot: Tree | string, packageName: string, version: string): void;
+    updateCatalogVersions(treeOrRoot: Tree | string, updates: Array<{
+        packageName: string;
+        version: string;
+        catalogName?: string;
+    }>): void;
+}

package/dist/src/utils/catalog/yarn-manager.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.YarnCatalogManager = void 0;
+const manager_1 = require("./manager");
+const manager_utils_1 = require("./manager-utils");
+const YARNRC_FILENAME = '.yarnrc.yml';
+/**
+ * Yarn Berry (v4.10+) catalog manager implementation.
+ *
+ * Unlike pnpm, the name "default" is not special: `catalog:` resolves only
+ * against `catalog`, and `catalog:default` against `catalogs.default`.
+ */
+class YarnCatalogManager {
+    constructor() {
+        this.name = 'yarn';
+        this.catalogProtocol = 'catalog:';
+        // Parsed fs-root definitions, cached per pass. See readCatalogDefinitions.
+        this.definitionsByRoot = new Map();
+    }
+    isCatalogReference(version) {
+        return version.startsWith(this.catalogProtocol);
+    }
+    parseCatalogReference(version) {
+        if (!this.isCatalogReference(version)) {
+            return null;
+        }
+        const catalogName = version.substring(this.catalogProtocol.length);
+        // Only an empty name selects the default catalog; unlike pnpm, "default"
+        // is a regular named catalog in yarn.
+        const isDefault = !catalogName;
+        return {
+            catalogName: isDefault ? undefined : catalogName,
+            isDefaultCatalog: isDefault,
+        };
+    }
+    getCatalogDefinitionFilePaths() {
+        return [YARNRC_FILENAME];
+    }
+    getCatalogDefinitions(treeOrRoot) {
+        return (0, manager_utils_1.readCatalogDefinitions)(YARNRC_FILENAME, treeOrRoot, this.definitionsByRoot);
+    }
+    resolveCatalogReference(treeOrRoot, packageName, version) {
+        const catalogRef = this.parseCatalogReference(version);
+        if (!catalogRef) {
+            return null;
+        }
+        const catalogDefs = this.getCatalogDefinitions(treeOrRoot);
+        if (!catalogDefs) {
+            return null;
+        }
+        let catalogToUse;
+        if (catalogRef.isDefaultCatalog) {
+            catalogToUse = catalogDefs.catalog;
+        }
+        else if (catalogRef.catalogName) {
+            catalogToUse = catalogDefs.catalogs?.[catalogRef.catalogName];
+        }
+        return catalogToUse?.[packageName] || null;
+    }
+    getCatalogReferencesForPackage(treeOrRoot, packageName) {
+        return (0, manager_1.collectCatalogReferencesForPackage)(this, treeOrRoot, packageName);
+    }
+    validateCatalogReference(treeOrRoot, packageName, version) {
+        const catalogRef = this.parseCatalogReference(version);
+        if (!catalogRef) {
+            throw new Error(`Invalid catalog reference syntax: "${version}". Expected format: "catalog:" or "catalog:name"`);
+        }
+        const catalogDefs = this.getCatalogDefinitions(treeOrRoot);
+        if (!catalogDefs) {
+            throw new Error((0, manager_1.formatCatalogError)(`Cannot get Yarn catalog definitions. No ${YARNRC_FILENAME} found in workspace root.`, [`Create a ${YARNRC_FILENAME} file in your workspace root`]));
+        }
+        let catalogToUse;
+        if (catalogRef.isDefaultCatalog) {
+            // Yarn's default catalog is only the `catalog` field; unlike pnpm,
+            // `catalogs.default` does not act as a fallback.
+            catalogToUse = catalogDefs.catalog;
+            if (!catalogToUse) {
+                const availableCatalogs = Object.keys(catalogDefs.catalogs || {});
+                const suggestions = [
+                    `Define a default catalog in ${YARNRC_FILENAME} under the "catalog" key`,
+                ];
+                if (availableCatalogs.length > 0) {
+                    suggestions.push(`Or select from the available named catalogs: ${availableCatalogs
+                        .map((c) => `"catalog:${c}"`)
+                        .join(', ')}`);
+                }
+                throw new Error((0, manager_1.formatCatalogError)(`No default catalog defined in ${YARNRC_FILENAME}`, suggestions));
+            }
+        }
+        else if (catalogRef.catalogName) {
+            catalogToUse = catalogDefs.catalogs?.[catalogRef.catalogName];
+            if (!catalogToUse) {
+                const availableCatalogs = Object.keys(catalogDefs.catalogs || {});
+                const suggestions = [
+                    `Define the catalog in ${YARNRC_FILENAME} under the "catalogs" key`,
+                ];
+                if (availableCatalogs.length > 0) {
+                    suggestions.push(`Or select from the available named catalogs: ${availableCatalogs
+                        .map((c) => `"catalog:${c}"`)
+                        .join(', ')}`);
+                }
+                if (catalogDefs.catalog) {
+                    suggestions.push(`Or use the default catalog ("catalog:")`);
+                }
+                throw new Error((0, manager_1.formatCatalogError)(`Catalog "${catalogRef.catalogName}" not found in ${YARNRC_FILENAME}`, suggestions));
+            }
+        }
+        if (!catalogToUse[packageName]) {
+            const catalogName = catalogRef.isDefaultCatalog
+                ? 'default catalog ("catalog")'
+                : `catalog '${catalogRef.catalogName}'`;
+            const availablePackages = Object.keys(catalogToUse);
+            const suggestions = [
+                `Add "${packageName}" to ${catalogName} in ${YARNRC_FILENAME}`,
+            ];
+            if (availablePackages.length > 0) {
+                suggestions.push(`Or select from the available packages in ${catalogName}: ${availablePackages
+                    .map((p) => `"${p}"`)
+                    .join(', ')}`);
+            }
+            throw new Error((0, manager_1.formatCatalogError)(`Package "${packageName}" not found in ${catalogName}`, suggestions));
+        }
+    }
+    updateCatalogVersions(treeOrRoot, updates) {
+        (0, manager_utils_1.updateCatalogVersionsInFile)(YARNRC_FILENAME, treeOrRoot, updates, {
+            aliasDefaultCatalog: false,
+        });
+    }
+}
+exports.YarnCatalogManager = YarnCatalogManager;

package/dist/src/utils/child-process.d.ts

@@ -0,0 +1,52 @@
+import { type ExecOptions, type ExecSyncOptions, type SpawnSyncOptions } from 'child_process';
+import { PackageManagerCommands } from './package-manager';
+import { ChildProcess } from '../native';
+export declare function getRunNxBaseCommand(packageManagerCommand?: PackageManagerCommands, cwd?: string): string;
+/**
+ * Locate an nx entry point to spawn for the workspace at `root`, so a caller
+ * can run it directly instead of going through a shell. `findInstalledNxBin`
+ * decides which one.
+ *
+ * Null means nothing may be spawned directly, leaving the caller to fall back
+ * to `getRunNxBaseCommand`. Null is therefore always safe: it costs the
+ * argument fidelity a direct spawn buys, never the ability to run.
+ */
+export declare function getNxBin(root?: string): string | null;
+/**
+ * The entry point the nx installed directly under `dir` names, with no ascent
+ * to `dir`'s ancestors. For an installation that declares nx itself, such as
+ * the temp CLI `nx migrate` builds, an ancestor's nx is never the right answer.
+ */
+export declare function readInstalledNxBin(dir: string): string | null;
+/**
+ * Run a nx command, passing the arguments through as an argv array.
+ *
+ * When `getNxBin` names an entry point, the child is spawned directly with no
+ * shell in between, so every argument reaches the child exactly as provided:
+ * shell metacharacters (`(`, `%`, `^`, spaces, quotes) are data, not syntax.
+ * Otherwise falls back to the package-manager + shell path, where every
+ * argument goes through `quoteShellArg` and the Windows limits it documents
+ * apply.
+ */
+export declare function runNxArgvSync(argv: string[], options?: SpawnSyncOptions & {
+    cwd?: string;
+    nxBin?: string;
+}): void;
+export declare function runNxSync(cmd: string, options?: ExecSyncOptions & {
+    cwd?: string;
+    packageManagerCommand?: PackageManagerCommands;
+}): void;
+export declare function runNxAsync(cmd: string, options?: ExecOptions & {
+    cwd?: string;
+    silent?: boolean;
+    packageManagerCommand?: PackageManagerCommands;
+}): Promise<void>;
+export declare class PseudoTtyProcess {
+    private childProcess;
+    isAlive: boolean;
+    exitCallbacks: any[];
+    constructor(childProcess: ChildProcess);
+    onExit(callback: (code: number) => void): void;
+    onOutput(callback: (message: string) => void): void;
+    kill(): void;
+}

package/dist/src/utils/child-process.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PseudoTtyProcess = void 0;
+exports.getRunNxBaseCommand = getRunNxBaseCommand;
+exports.getNxBin = getNxBin;
+exports.readInstalledNxBin = readInstalledNxBin;
+exports.runNxArgvSync = runNxArgvSync;
+exports.runNxSync = runNxSync;
+exports.runNxAsync = runNxAsync;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const package_manager_1 = require("./package-manager");
+const workspace_root_1 = require("./workspace-root");
+const exit_codes_1 = require("./exit-codes");
+const fileutils_1 = require("./fileutils");
+const shell_quoting_1 = require("./shell-quoting");
+function getRunNxBaseCommand(packageManagerCommand, cwd = process.cwd()) {
+    if ((0, fs_1.existsSync)((0, path_1.join)(workspace_root_1.workspaceRoot, 'package.json'))) {
+        if (!packageManagerCommand) {
+            // `readLocalNxVersion` (command-line/migrate/migrate.ts) mirrors this
+            // selector to predict which nx a spawn will run, for the workspaces
+            // `getNxBin` declines to resolve; keep the two in sync.
+            const pm = (0, package_manager_1.detectPackageManager)(workspace_root_1.workspaceRoot);
+            packageManagerCommand = (0, package_manager_1.getPackageManagerCommand)(pm, workspace_root_1.workspaceRoot);
+        }
+        return `${packageManagerCommand.exec} nx`;
+    }
+    else {
+        const offsetFromRoot = (0, path_1.relative)(cwd, (0, workspace_root_1.workspaceRootInner)(cwd, null));
+        if (process.platform === 'win32') {
+            return '.\\' + (0, path_1.join)(`${offsetFromRoot}`, 'nx.bat');
+        }
+        else {
+            return './' + (0, path_1.join)(`${offsetFromRoot}`, 'nx');
+        }
+    }
+}
+/**
+ * Locate an nx entry point to spawn for the workspace at `root`, so a caller
+ * can run it directly instead of going through a shell. `findInstalledNxBin`
+ * decides which one.
+ *
+ * Null means nothing may be spawned directly, leaving the caller to fall back
+ * to `getRunNxBaseCommand`. Null is therefore always safe: it costs the
+ * argument fidelity a direct spawn buys, never the ability to run.
+ */
+function getNxBin(root = workspace_root_1.workspaceRoot) {
+    // A workspace with no root package.json runs nx through the `./nx` wrapper,
+    // which reinstalls `.nx/installation` whenever it drifts from nx.json's
+    // `installation.version`. Spawning the resolved entry point would skip that
+    // sync, and a migration is precisely when the version changes.
+    if (!(0, fs_1.existsSync)((0, path_1.join)(root, 'package.json'))) {
+        return null;
+    }
+    return findInstalledNxBin(root);
+}
+/**
+ * The entry point the nx installed directly under `dir` names, with no ascent
+ * to `dir`'s ancestors. For an installation that declares nx itself, such as
+ * the temp CLI `nx migrate` builds, an ancestor's nx is never the right answer.
+ */
+function readInstalledNxBin(dir) {
+    const packageDir = (0, path_1.join)(dir, 'node_modules', 'nx');
+    const manifest = (0, path_1.join)(packageDir, 'package.json');
+    if (!(0, fs_1.existsSync)(manifest)) {
+        return null;
+    }
+    let bin;
+    try {
+        ({ bin } = (0, fileutils_1.readJsonFile)(manifest));
+    }
+    catch {
+        return null;
+    }
+    // npm accepts both the single-entry shorthand and the map form.
+    const entry = typeof bin === 'string' ? bin : bin?.nx;
+    return typeof entry === 'string' ? (0, path_1.join)(packageDir, entry) : null;
+}
+// Ascend to the nearest installed nx and take the entry point its `bin` field
+// names, which is the file a package manager links into `node_modules/.bin`.
+// Deliberately npx-shaped: npx and bun ascend unconditionally while pnpm and
+// yarn stop at an outer workspace, so this can name an nx those two would
+// decline to run.
+//
+// Deliberately not a resolver. Resolvers answer from NODE_PATH once their
+// explicit paths miss, and `nxCliPath` (command-line/migrate/migrate.ts) points
+// NODE_PATH at the temp installation before spawning it; they also answer
+// through package self-reference, which hands back the running nx whatever
+// `paths` they are given. Either one lets the temp installation hand off to
+// itself, which for `--run-migrations` re-enters the same hand-off and respawns
+// without end.
+function findInstalledNxBin(root) {
+    for (let dir = root;; dir = (0, path_1.dirname)(dir)) {
+        // The nearest install wins, so an unusable manifest there ends the search
+        // rather than deferring to an ancestor.
+        if ((0, fs_1.existsSync)((0, path_1.join)(dir, 'node_modules', 'nx', 'package.json'))) {
+            return readInstalledNxBin(dir);
+        }
+        if (dir === (0, path_1.dirname)(dir)) {
+            return null;
+        }
+    }
+}
+/**
+ * Run a nx command, passing the arguments through as an argv array.
+ *
+ * When `getNxBin` names an entry point, the child is spawned directly with no
+ * shell in between, so every argument reaches the child exactly as provided:
+ * shell metacharacters (`(`, `%`, `^`, spaces, quotes) are data, not syntax.
+ * Otherwise falls back to the package-manager + shell path, where every
+ * argument goes through `quoteShellArg` and the Windows limits it documents
+ * apply.
+ */
+function runNxArgvSync(argv, options) {
+    let { nxBin, ...spawnOptions } = options ?? {};
+    spawnOptions.cwd ??= process.cwd();
+    spawnOptions.windowsHide ??= true;
+    nxBin ??= getNxBin((0, workspace_root_1.workspaceRootInner)(spawnOptions.cwd, null) ?? workspace_root_1.workspaceRoot);
+    if (!nxBin) {
+        runNxSync(argv.map(shell_quoting_1.quoteShellArg).join(' '), spawnOptions);
+        return;
+    }
+    const result = (0, child_process_1.spawnSync)(process.execPath, [nxBin, ...argv], spawnOptions);
+    if (result.error) {
+        throw result.error;
+    }
+    if (result.status !== 0) {
+        const error = new Error(`Command failed: nx ${argv.join(' ')} (exit code ${result.status})`);
+        error.status = result.status ?? 1;
+        throw error;
+    }
+}
+function runNxSync(cmd, options) {
+    let { packageManagerCommand, ...execSyncOptions } = options ?? {};
+    execSyncOptions.cwd ??= process.cwd();
+    execSyncOptions.windowsHide ??= true;
+    const baseCmd = getRunNxBaseCommand(packageManagerCommand, execSyncOptions.cwd);
+    (0, child_process_1.execSync)(`${baseCmd} ${cmd}`, execSyncOptions);
+}
+async function runNxAsync(cmd, options) {
+    options ??= {};
+    options.cwd ??= process.cwd();
+    let { silent, packageManagerCommand, ...execSyncOptions } = options;
+    silent ??= true;
+    const baseCmd = getRunNxBaseCommand(packageManagerCommand, execSyncOptions.cwd);
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.exec)(`${baseCmd} ${cmd}`, { ...execSyncOptions, windowsHide: true }, (error, stdout, stderr) => {
+            if (error) {
+                reject(stderr || stdout || error.message);
+            }
+            else {
+                resolve();
+            }
+        });
+        if (!silent) {
+            child.stdout?.pipe(process.stdout);
+            child.stderr?.pipe(process.stderr);
+        }
+    });
+}
+class PseudoTtyProcess {
+    constructor(childProcess) {
+        this.childProcess = childProcess;
+        this.isAlive = true;
+        this.exitCallbacks = [];
+        childProcess.onExit((message) => {
+            this.isAlive = false;
+            const exitCode = (0, exit_codes_1.messageToCode)(message);
+            this.exitCallbacks.forEach((cb) => cb(exitCode));
+        });
+    }
+    onExit(callback) {
+        this.exitCallbacks.push(callback);
+    }
+    onOutput(callback) {
+        this.childProcess.onOutput(callback);
+    }
+    kill() {
+        try {
+            this.childProcess.kill();
+        }
+        catch {
+            // when the child process completes before we explicitly call kill, this will throw
+            // do nothing
+        }
+        finally {
+            if (this.isAlive == true) {
+                this.isAlive = false;
+            }
+        }
+    }
+}
+exports.PseudoTtyProcess = PseudoTtyProcess;

package/dist/src/utils/chunkify.d.ts

@@ -0,0 +1,11 @@
+export declare function chunkify(target: string[], maxChunkLength?: number): string[][];
+/**
+ * Get the maximum length of a command-line argument string based on current platform
+ *
+ * https://serverfault.com/questions/69430/what-is-the-maximum-length-of-a-command-line-in-mac-os-x
+ * https://support.microsoft.com/en-us/help/830473/command-prompt-cmd-exe-command-line-string-limitation
+ * https://unix.stackexchange.com/a/120652
+ *
+ * Taken from: https://github.com/lint-staged/lint-staged/blob/adf50b00669f6aac2eeca25dd28ff86a9a3c2a48/lib/index.js#L21-L37
+ */
+export declare function getMaxArgLength(): 8191 | 131072 | 262144;

package/dist/src/utils/chunkify.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chunkify = chunkify;
+exports.getMaxArgLength = getMaxArgLength;
+const TERMINAL_SIZE = getMaxArgLength();
+function chunkify(target, maxChunkLength = TERMINAL_SIZE - 500) {
+    const chunks = [];
+    let currentChunk = [];
+    let currentChunkLength = 0;
+    for (const file of target) {
+        const length = file.length;
+        if (
+        // Prevent empty chunk if first file path is longer than maxChunkLength
+        currentChunk.length &&
+            // +1 accounts for the space between file names
+            currentChunkLength + length + 1 >= maxChunkLength) {
+            chunks.push(currentChunk);
+            currentChunk = [];
+            currentChunkLength = 0;
+        }
+        currentChunk.push(file);
+        currentChunkLength += length + 1;
+    }
+    chunks.push(currentChunk);
+    return chunks;
+}
+/**
+ * Get the maximum length of a command-line argument string based on current platform
+ *
+ * https://serverfault.com/questions/69430/what-is-the-maximum-length-of-a-command-line-in-mac-os-x
+ * https://support.microsoft.com/en-us/help/830473/command-prompt-cmd-exe-command-line-string-limitation
+ * https://unix.stackexchange.com/a/120652
+ *
+ * Taken from: https://github.com/lint-staged/lint-staged/blob/adf50b00669f6aac2eeca25dd28ff86a9a3c2a48/lib/index.js#L21-L37
+ */
+function getMaxArgLength() {
+    switch (process.platform) {
+        case 'darwin':
+            return 262144;
+        case 'win32':
+            return 8191;
+        default:
+            return 131072;
+    }
+}

package/dist/src/utils/code-frames.d.ts

@@ -0,0 +1,14 @@
+type Location = {
+    column: number;
+    line: number;
+};
+type NodeLocation = {
+    end?: Location;
+    start?: Location;
+};
+export declare function codeFrameColumns(rawLines: string, loc: NodeLocation, opts?: {
+    linesAbove?: number;
+    linesBelow?: number;
+    highlight?: (rawLines: string) => string;
+}): string;
+export {};