@depup/nx 22.5.4-depup.0

package/src/utils/catalog/pnpm-manager.d.ts

@@ -0,0 +1,23 @@
+import type { Tree } from '../../generators/tree';
+import type { PnpmWorkspaceYaml } from '../pnpm-workspace';
+import type { CatalogManager } from './manager';
+import type { CatalogReference } from './types';
+/**
+ * PNPM-specific catalog manager implementation
+ */
+export declare class PnpmCatalogManager implements CatalogManager {
+    readonly name = "pnpm";
+    readonly catalogProtocol = "catalog:";
+    isCatalogReference(version: string): boolean;
+    parseCatalogReference(version: string): CatalogReference | null;
+    getCatalogDefinitionFilePaths(): string[];
+    getCatalogDefinitions(treeOrRoot: Tree | string): PnpmWorkspaceYaml | null;
+    resolveCatalogReference(treeOrRoot: Tree | string, packageName: string, version: string): string | null;
+    validateCatalogReference(treeOrRoot: Tree | string, packageName: string, version: string): void;
+    updateCatalogVersions(treeOrRoot: Tree | string, updates: Array<{
+        packageName: string;
+        version: string;
+        catalogName?: string;
+    }>): void;
+}
+//# sourceMappingURL=pnpm-manager.d.ts.map

package/src/utils/catalog/pnpm-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pnpm-manager.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/utils/catalog/pnpm-manager.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAGlD,OAAO,KAAK,EAAoB,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAC7E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAChD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEhD;;GAEG;AACH,qBAAa,kBAAmB,YAAW,cAAc;IACvD,QAAQ,CAAC,IAAI,UAAU;IACvB,QAAQ,CAAC,eAAe,cAAc;IAEtC,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAI5C,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI;IAe/D,6BAA6B,IAAI,MAAM,EAAE;IAIzC,qBAAqB,CAAC,UAAU,EAAE,IAAI,GAAG,MAAM,GAAG,iBAAiB,GAAG,IAAI;IAe1E,uBAAuB,CACrB,UAAU,EAAE,IAAI,GAAG,MAAM,EACzB,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,GACd,MAAM,GAAG,IAAI;IAuBhB,wBAAwB,CACtB,UAAU,EAAE,IAAI,GAAG,MAAM,EACzB,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,GACd,IAAI;IA0HP,qBAAqB,CACnB,UAAU,EAAE,IAAI,GAAG,MAAM,EACzB,OAAO,EAAE,KAAK,CAAC;QACb,WAAW,EAAE,MAAM,CAAC;QACpB,OAAO,EAAE,MAAM,CAAC;QAChB,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB,CAAC,GACD,IAAI;CAgFR"}

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

@@ -0,0 +1,260 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PnpmCatalogManager = void 0;
+const js_yaml_1 = require("@zkochan/js-yaml");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const fileutils_1 = require("../fileutils");
+const output_1 = require("../output");
+/**
+ * PNPM-specific catalog manager implementation
+ */
+class PnpmCatalogManager {
+    constructor() {
+        this.name = 'pnpm';
+        this.catalogProtocol = 'catalog:';
+    }
+    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.yaml'];
+    }
+    getCatalogDefinitions(treeOrRoot) {
+        if (typeof treeOrRoot === 'string') {
+            const pnpmWorkspacePath = (0, node_path_1.join)(treeOrRoot, 'pnpm-workspace.yaml');
+            if (!(0, node_fs_1.existsSync)(pnpmWorkspacePath)) {
+                return null;
+            }
+            return readYamlFileFromFs(pnpmWorkspacePath);
+        }
+        else {
+            if (!treeOrRoot.exists('pnpm-workspace.yaml')) {
+                return null;
+            }
+            return readYamlFileFromTree(treeOrRoot, 'pnpm-workspace.yaml');
+        }
+    }
+    resolveCatalogReference(treeOrRoot, packageName, version) {
+        const catalogRef = this.parseCatalogReference(version);
+        if (!catalogRef) {
+            return null;
+        }
+        const workspaceConfig = this.getCatalogDefinitions(treeOrRoot);
+        if (!workspaceConfig) {
+            return null;
+        }
+        let catalogToUse;
+        if (catalogRef.isDefaultCatalog) {
+            // Check both locations for default catalog
+            catalogToUse =
+                workspaceConfig.catalog ?? workspaceConfig.catalogs?.default;
+        }
+        else if (catalogRef.catalogName) {
+            catalogToUse = workspaceConfig.catalogs?.[catalogRef.catalogName];
+        }
+        return catalogToUse?.[packageName] || null;
+    }
+    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 workspaceConfig = this.getCatalogDefinitions(treeOrRoot);
+        if (!workspaceConfig) {
+            throw new Error(formatCatalogError('Cannot get Pnpm catalog definitions. No pnpm-workspace.yaml found in workspace root.', ['Create a pnpm-workspace.yaml file in your workspace root']));
+        }
+        let catalogToUse;
+        if (catalogRef.isDefaultCatalog) {
+            const hasCatalog = !!workspaceConfig.catalog;
+            const hasCatalogsDefault = !!workspaceConfig.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 =
+                workspaceConfig.catalog ?? workspaceConfig.catalogs?.default;
+            if (!catalogToUse) {
+                const availableCatalogs = Object.keys(workspaceConfig.catalogs || {});
+                const suggestions = [
+                    'Define a default catalog in pnpm-workspace.yaml 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(formatCatalogError('No default catalog defined in pnpm-workspace.yaml', suggestions));
+            }
+        }
+        else if (catalogRef.catalogName) {
+            catalogToUse = workspaceConfig.catalogs?.[catalogRef.catalogName];
+            if (!catalogToUse) {
+                const availableCatalogs = Object.keys(workspaceConfig.catalogs || {}).filter((c) => c !== 'default');
+                const defaultCatalog = !!workspaceConfig.catalog
+                    ? 'catalog'
+                    : !workspaceConfig.catalogs?.default
+                        ? 'catalogs.default'
+                        : null;
+                const suggestions = [
+                    'Define the catalog in pnpm-workspace.yaml 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(formatCatalogError(`Catalog "${catalogRef.catalogName}" not found in pnpm-workspace.yaml`, suggestions));
+            }
+        }
+        if (!catalogToUse[packageName]) {
+            let catalogName;
+            if (catalogRef.isDefaultCatalog) {
+                // Context-aware messaging based on which location exists
+                const hasCatalog = !!workspaceConfig.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.yaml`,
+            ];
+            if (availablePackages.length > 0) {
+                suggestions.push(`Or select from the available packages in ${catalogName}: ${availablePackages
+                    .map((p) => `"${p}"`)
+                    .join(', ')}`);
+            }
+            throw new Error(formatCatalogError(`Package "${packageName}" not found in ${catalogName}`, suggestions));
+        }
+    }
+    updateCatalogVersions(treeOrRoot, updates) {
+        let checkExists;
+        let readYaml;
+        let writeYaml;
+        if (typeof treeOrRoot === 'string') {
+            const workspaceYamlPath = (0, node_path_1.join)(treeOrRoot, 'pnpm-workspace.yaml');
+            checkExists = () => (0, node_fs_1.existsSync)(workspaceYamlPath);
+            readYaml = () => (0, node_fs_1.readFileSync)(workspaceYamlPath, 'utf-8');
+            writeYaml = (content) => (0, node_fs_1.writeFileSync)(workspaceYamlPath, content, 'utf-8');
+        }
+        else {
+            checkExists = () => treeOrRoot.exists('pnpm-workspace.yaml');
+            readYaml = () => treeOrRoot.read('pnpm-workspace.yaml', 'utf-8');
+            writeYaml = (content) => treeOrRoot.write('pnpm-workspace.yaml', content);
+        }
+        if (!checkExists()) {
+            output_1.output.warn({
+                title: 'No pnpm-workspace.yaml found',
+                bodyLines: [
+                    'Cannot update catalog versions without a pnpm-workspace.yaml file.',
+                    'Create a pnpm-workspace.yaml file to use catalogs.',
+                ],
+            });
+            return;
+        }
+        try {
+            const workspaceContent = readYaml();
+            const workspaceData = (0, js_yaml_1.load)(workspaceContent) || {};
+            let hasChanges = false;
+            for (const update of updates) {
+                const { packageName, version, catalogName } = update;
+                const normalizedCatalogName = catalogName === 'default' ? undefined : catalogName;
+                let targetCatalog;
+                if (!normalizedCatalogName) {
+                    // Default catalog - update whichever exists, prefer catalog over catalogs.default
+                    if (workspaceData.catalog) {
+                        targetCatalog = workspaceData.catalog;
+                    }
+                    else if (workspaceData.catalogs?.default) {
+                        targetCatalog = workspaceData.catalogs.default;
+                    }
+                    else {
+                        // Neither exists, create catalog (shorthand syntax)
+                        workspaceData.catalog ??= {};
+                        targetCatalog = workspaceData.catalog;
+                    }
+                }
+                else {
+                    // Named catalog
+                    workspaceData.catalogs ??= {};
+                    workspaceData.catalogs[normalizedCatalogName] ??= {};
+                    targetCatalog = workspaceData.catalogs[normalizedCatalogName];
+                }
+                if (targetCatalog[packageName] !== version) {
+                    targetCatalog[packageName] = version;
+                    hasChanges = true;
+                }
+            }
+            if (hasChanges) {
+                writeYaml((0, js_yaml_1.dump)(workspaceData, {
+                    indent: 2,
+                    quotingType: '"',
+                    forceQuotes: true,
+                }));
+            }
+        }
+        catch (error) {
+            output_1.output.error({
+                title: 'Failed to update catalog versions',
+                bodyLines: [error instanceof Error ? error.message : String(error)],
+            });
+            throw error;
+        }
+    }
+}
+exports.PnpmCatalogManager = PnpmCatalogManager;
+function readYamlFileFromFs(path) {
+    try {
+        return (0, fileutils_1.readYamlFile)(path);
+    }
+    catch (error) {
+        output_1.output.warn({
+            title: 'Unable to parse pnpm-workspace.yaml',
+            bodyLines: [error.toString()],
+        });
+        return null;
+    }
+}
+function readYamlFileFromTree(tree, path) {
+    const content = tree.read(path, 'utf-8');
+    const { load } = require('@zkochan/js-yaml');
+    try {
+        return load(content, { filename: path });
+    }
+    catch (error) {
+        output_1.output.warn({
+            title: 'Unable to parse pnpm-workspace.yaml',
+            bodyLines: [error.toString()],
+        });
+        return null;
+    }
+}
+function formatCatalogError(error, suggestions) {
+    let message = error;
+    if (suggestions && suggestions.length > 0) {
+        message += '\n\nSuggestions:';
+        suggestions.forEach((suggestion) => {
+            message += `\n  • ${suggestion}`;
+        });
+    }
+    return message;
+}

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

@@ -0,0 +1,5 @@
+export interface CatalogReference {
+    catalogName?: string;
+    isDefaultCatalog: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/utils/catalog/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,gBAAgB;IAC/B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gBAAgB,EAAE,OAAO,CAAC;CAC3B"}

package/src/utils/catalog/types.js

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

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

@@ -0,0 +1,23 @@
+import { type ExecOptions, type ExecSyncOptions } from 'child_process';
+import { PackageManagerCommands } from './package-manager';
+import { ChildProcess } from '../native';
+export declare function getRunNxBaseCommand(packageManagerCommand?: PackageManagerCommands, cwd?: string): string;
+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;
+}
+//# sourceMappingURL=child-process.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"child-process.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/utils/child-process.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,WAAW,EAChB,KAAK,eAAe,EACrB,MAAM,eAAe,CAAC;AAGvB,OAAO,EAGL,sBAAsB,EACvB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAEzC,wBAAgB,mBAAmB,CACjC,qBAAqB,CAAC,EAAE,sBAAsB,EAC9C,GAAG,GAAE,MAAsB,GAC1B,MAAM,CAeR;AAED,wBAAgB,SAAS,CACvB,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,eAAe,GAAG;IAC1B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,qBAAqB,CAAC,EAAE,sBAAsB,CAAC;CAChD,QAYF;AAED,wBAAsB,UAAU,CAC9B,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,WAAW,GAAG;IACtB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,qBAAqB,CAAC,EAAE,sBAAsB,CAAC;CAChD,GACA,OAAO,CAAC,IAAI,CAAC,CA4Bf;AAqBD,qBAAa,gBAAgB;IAKf,OAAO,CAAC,YAAY;IAJhC,OAAO,UAAQ;IAEf,aAAa,QAAM;gBAEC,YAAY,EAAE,YAAY;IAU9C,MAAM,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI;IAI9C,QAAQ,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI;IAInD,IAAI,IAAI,IAAI;CAYb"}

package/src/utils/child-process.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PseudoTtyProcess = void 0;
+exports.getRunNxBaseCommand = getRunNxBaseCommand;
+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");
+function getRunNxBaseCommand(packageManagerCommand, cwd = process.cwd()) {
+    if ((0, fs_1.existsSync)((0, path_1.join)(workspace_root_1.workspaceRoot, 'package.json'))) {
+        if (!packageManagerCommand) {
+            const pm = (0, package_manager_1.detectPackageManager)();
+            packageManagerCommand = (0, package_manager_1.getPackageManagerCommand)(pm);
+        }
+        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');
+        }
+    }
+}
+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();
+    options.windowsHide ??= true;
+    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}`, options, (error, stdout, stderr) => {
+            if (error) {
+                reject(stderr || stdout || error.message);
+            }
+            else {
+                resolve();
+            }
+        });
+        if (!silent) {
+            child.stdout?.pipe(process.stdout);
+            child.stderr?.pipe(process.stderr);
+        }
+    });
+}
+function messageToCode(message) {
+    if (message.startsWith('Terminated by ')) {
+        switch (message.replace('Terminated by ', '').trim()) {
+            case 'Termination':
+                return 143;
+            case 'Interrupt':
+                return 130;
+            default:
+                return 128;
+        }
+    }
+    else if (message.startsWith('Exited with code ')) {
+        return parseInt(message.replace('Exited with code ', '').trim());
+    }
+    else if (message === 'Success') {
+        return 0;
+    }
+    else {
+        return 1;
+    }
+}
+class PseudoTtyProcess {
+    constructor(childProcess) {
+        this.childProcess = childProcess;
+        this.isAlive = true;
+        this.exitCallbacks = [];
+        childProcess.onExit((message) => {
+            this.isAlive = false;
+            const exitCode = 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/src/utils/chunkify.d.ts

@@ -0,0 +1,12 @@
+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(): 262144 | 8191 | 131072;
+//# sourceMappingURL=chunkify.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunkify.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/utils/chunkify.ts"],"names":[],"mappings":"AAEA,wBAAgB,QAAQ,CACtB,MAAM,EAAE,MAAM,EAAE,EAChB,cAAc,GAAE,MAA4B,GAC3C,MAAM,EAAE,EAAE,CAoBZ;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,2BAS9B"}

package/src/utils/chunkify.js

@@ -0,0 +1,44 @@
+"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) {
+        if (
+        // Prevent empty chunk if first file path is longer than maxChunkLength
+        currentChunk.length &&
+            // +1 accounts for the space between file names
+            currentChunkLength + file.length + 1 >= maxChunkLength) {
+            chunks.push(currentChunk);
+            currentChunk = [];
+            currentChunkLength = 0;
+        }
+        currentChunk.push(file);
+        currentChunkLength += file.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/src/utils/code-frames.d.ts

@@ -0,0 +1,15 @@
+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 {};
+//# sourceMappingURL=code-frames.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"code-frames.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/utils/code-frames.ts"],"names":[],"mappings":"AAGA,KAAK,QAAQ,GAAG;IACd,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,KAAK,YAAY,GAAG;IAClB,GAAG,CAAC,EAAE,QAAQ,CAAC;IACf,KAAK,CAAC,EAAE,QAAQ,CAAC;CAClB,CAAC;AAuFF,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,YAAY,EACjB,IAAI,GAAE;IACJ,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAC;CACrC,GACL,MAAM,CAwCR"}

package/src/utils/code-frames.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codeFrameColumns = codeFrameColumns;
+// Adapted from https://raw.githubusercontent.com/babel/babel/4108524/packages/babel-code-frame/src/index.js
+const pc = require("picocolors");
+/**
+ * Styles for code frame token types.
+ */
+const defs = {
+    gutter: pc.gray,
+    marker: (text) => pc.red(pc.bold(text)),
+    message: (text) => pc.red(pc.bold(text)),
+};
+/**
+ * RegExp to test for newlines in terminal.
+ */
+const NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
+/**
+ * Extract what lines should be marked and highlighted.
+ */
+function getMarkerLines(loc, source, opts = {}) {
+    const startLoc = {
+        column: 0,
+        line: -1,
+        ...loc.start,
+    };
+    const endLoc = {
+        ...startLoc,
+        ...loc.end,
+    };
+    const { linesAbove = 2, linesBelow = 3 } = opts || {};
+    const startLine = startLoc.line;
+    const startColumn = startLoc.column;
+    const endLine = endLoc.line;
+    const endColumn = endLoc.column;
+    let start = Math.max(startLine - (linesAbove + 1), 0);
+    let end = Math.min(source.length, endLine + linesBelow);
+    if (startLine === -1) {
+        start = 0;
+    }
+    if (endLine === -1) {
+        end = source.length;
+    }
+    const lineDiff = endLine - startLine;
+    const markerLines = {};
+    if (lineDiff) {
+        for (let i = 0; i <= lineDiff; i++) {
+            const lineNumber = i + startLine;
+            if (!startColumn) {
+                markerLines[lineNumber] = true;
+            }
+            else if (i === 0) {
+                const sourceLength = source[lineNumber - 1].length;
+                markerLines[lineNumber] = [startColumn, sourceLength - startColumn + 1];
+            }
+            else if (i === lineDiff) {
+                markerLines[lineNumber] = [0, endColumn];
+            }
+            else {
+                const sourceLength = source[lineNumber - i].length;
+                markerLines[lineNumber] = [0, sourceLength];
+            }
+        }
+    }
+    else {
+        if (startColumn === endColumn) {
+            if (startColumn) {
+                markerLines[startLine] = [startColumn, 0];
+            }
+            else {
+                markerLines[startLine] = true;
+            }
+        }
+        else {
+            markerLines[startLine] = [startColumn, endColumn - startColumn];
+        }
+    }
+    return { start, end, markerLines };
+}
+function codeFrameColumns(rawLines, loc, opts = {}) {
+    const lines = rawLines.split(NEWLINE);
+    const { start, end, markerLines } = getMarkerLines(loc, lines, opts);
+    const numberMaxWidth = String(end).length;
+    const highlightedLines = opts.highlight ? opts.highlight(rawLines) : rawLines;
+    let frame = highlightedLines
+        .split(NEWLINE)
+        .slice(start, end)
+        .map((line, index) => {
+        const number = start + 1 + index;
+        const paddedNumber = ` ${number}`.slice(-numberMaxWidth);
+        const gutter = ` ${paddedNumber} | `;
+        const hasMarker = markerLines[number];
+        if (hasMarker) {
+            let markerLine = '';
+            if (Array.isArray(hasMarker)) {
+                const markerSpacing = line
+                    .slice(0, Math.max(hasMarker[0] - 1, 0))
+                    .replace(/[^\t]/g, ' ');
+                const numberOfMarkers = hasMarker[1] || 1;
+                markerLine = [
+                    '\n ',
+                    defs.gutter(gutter.replace(/\d/g, ' ')),
+                    markerSpacing,
+                    defs.marker('^').repeat(numberOfMarkers),
+                ].join('');
+            }
+            return [defs.marker('>'), defs.gutter(gutter), line, markerLine].join('');
+        }
+        else {
+            return ` ${defs.gutter(gutter)}${line}`;
+        }
+    })
+        .join('\n');
+    return pc.reset(frame);
+}

package/src/utils/collapse-expanded-outputs.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Collapses a list of file paths into a smaller set of parent directories
+ * when there are too many outputs to efficiently track individually.
+ *
+ * This prevents creating too many hash files by:
+ * 1. Building a tree structure of all path components
+ * 2. Finding the "collapse level" - the deepest level before exceeding MAX_OUTPUTS_TO_CHECK_HASHES
+ * 3. Returning parent paths at/above collapse level, while preserving leaf paths that terminate early
+ */
+export declare function collapseExpandedOutputs(expandedOutputs: string[]): string[];
+//# sourceMappingURL=collapse-expanded-outputs.d.ts.map

package/src/utils/collapse-expanded-outputs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collapse-expanded-outputs.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/utils/collapse-expanded-outputs.ts"],"names":[],"mappings":"AAOA;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,eAAe,EAAE,MAAM,EAAE,YA+DhE"}