@pnpm/cli.parse-cli-args 1000.1.4

package/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2016 Rico Sta. Cruz and other contributors
+Copyright (c) 2016-2026 Zoltan Kochan and other contributors
+
+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,15 @@
+# @pnpm/parse-cli-args
+
+> Parses the CLI args passed to pnpm
+
+[![npm version](https://img.shields.io/npm/v/@pnpm/parse-cli-args.svg)](https://www.npmjs.com/package/@pnpm/parse-cli-args)
+
+## Installation
+
+```sh
+pnpm add @pnpm/parse-cli-args
+```
+
+## License
+
+MIT

package/lib/index.d.ts

@@ -0,0 +1,23 @@
+export interface ParsedCliArgs {
+    argv: {
+        remain: string[];
+        cooked: string[];
+        original: string[];
+    };
+    params: string[];
+    options: Record<string, any>;
+    cmd: string | null;
+    unknownOptions: Map<string, string[]>;
+    fallbackCommandUsed: boolean;
+    workspaceDir: string | undefined;
+}
+export declare function parseCliArgs(opts: {
+    escapeArgs?: string[];
+    fallbackCommand?: string;
+    getCommandLongName: (commandName: string) => string | null;
+    getTypesByCommandName: (commandName: string) => object;
+    renamedOptions?: Record<string, string>;
+    shorthandsByCommandName: Record<string, Record<string, string | string[]>>;
+    universalOptionsTypes: Record<string, unknown>;
+    universalShorthands: Record<string, string | string[]>;
+}, inputArgv: string[]): Promise<ParsedCliArgs>;

package/lib/index.js

@@ -0,0 +1,189 @@
+import { PnpmError } from '@pnpm/error';
+import nopt from '@pnpm/nopt';
+import { findWorkspaceDir } from '@pnpm/workspace.root-finder';
+import didYouMean, { ReturnTypeEnums } from 'didyoumean2';
+const RECURSIVE_CMDS = new Set(['recursive', 'multi', 'm']);
+const SPECIALLY_ESCAPED_CMDS = new Set(['run', 'dlx']);
+export async function parseCliArgs(opts, inputArgv) {
+    const noptExploratoryResults = nopt({
+        filter: [String],
+        help: Boolean,
+        recursive: Boolean,
+        ...opts.universalOptionsTypes,
+        ...opts.getTypesByCommandName('add'),
+        ...opts.getTypesByCommandName('install'),
+    }, {
+        r: '--recursive',
+        ...opts.universalShorthands,
+    }, inputArgv, 0, { escapeArgs: opts.escapeArgs });
+    const recursiveCommandUsed = RECURSIVE_CMDS.has(noptExploratoryResults.argv.remain[0]);
+    let commandName = getCommandName(noptExploratoryResults.argv.remain);
+    let cmd = commandName ? opts.getCommandLongName(commandName) : null;
+    const fallbackCommandUsed = Boolean(commandName && !cmd && opts.fallbackCommand);
+    if (fallbackCommandUsed) {
+        cmd = opts.fallbackCommand;
+        commandName = opts.fallbackCommand;
+        inputArgv.unshift(opts.fallbackCommand);
+        // The run command has special casing for --help and is handled further below.
+    }
+    else if (!SPECIALLY_ESCAPED_CMDS.has(cmd)) {
+        if (noptExploratoryResults['help']) {
+            return {
+                ...getParsedArgsForHelp(),
+                workspaceDir: await getWorkspaceDir(noptExploratoryResults),
+            };
+        }
+        if (noptExploratoryResults['version'] || noptExploratoryResults['v']) {
+            return {
+                argv: noptExploratoryResults.argv,
+                cmd: null,
+                options: {
+                    version: true,
+                },
+                params: noptExploratoryResults.argv.remain,
+                unknownOptions: new Map(),
+                fallbackCommandUsed: false,
+                workspaceDir: await getWorkspaceDir(noptExploratoryResults),
+            };
+        }
+    }
+    function getParsedArgsForHelp() {
+        return {
+            argv: noptExploratoryResults.argv,
+            cmd: 'help',
+            options: {},
+            params: noptExploratoryResults.argv.remain,
+            unknownOptions: new Map(),
+            fallbackCommandUsed: false,
+        };
+    }
+    const types = {
+        ...opts.universalOptionsTypes,
+        ...opts.getTypesByCommandName(commandName),
+    }; // eslint-disable-line @typescript-eslint/no-explicit-any
+    function getCommandName(args) {
+        if (recursiveCommandUsed) {
+            args = args.slice(1);
+        }
+        if (opts.getCommandLongName(args[0]) !== 'install' || args.length === 1) {
+            return args[0];
+        }
+        return 'add';
+    }
+    function getEscapeArgsWithSpecialCases() {
+        if (!SPECIALLY_ESCAPED_CMDS.has(cmd)) {
+            return opts.escapeArgs;
+        }
+        // We'd like everything after the run script's name to be passed to the
+        // script's argv itself. For example, "pnpm run echo --test" should pass
+        // "--test" to the "echo" script. This requires determining the script's
+        // name and declaring it as the "escape arg".
+        //
+        // The name of the run script is normally the second argument (ex: pnpm
+        // run foo), but can be pushed back by recursive commands (ex: pnpm
+        // recursive run foo) or becomes the first argument when the fallback
+        // command (ex: pnpm foo) is set to 'run'.
+        const indexOfRunScriptName = 1 +
+            (recursiveCommandUsed ? 1 : 0) +
+            (fallbackCommandUsed && opts.fallbackCommand === 'run' ? -1 : 0);
+        return [noptExploratoryResults.argv.remain[indexOfRunScriptName]];
+    }
+    const { argv, ...options } = nopt({
+        recursive: Boolean,
+        ...types,
+    }, {
+        ...opts.universalShorthands,
+        ...opts.shorthandsByCommandName[commandName],
+    }, inputArgv, 0, { escapeArgs: getEscapeArgsWithSpecialCases() });
+    const workspaceDir = await getWorkspaceDir(options);
+    // For the run command, it's not clear whether --help should be passed to the
+    // underlying script or invoke pnpm's help text until an additional nopt call.
+    if (SPECIALLY_ESCAPED_CMDS.has(cmd) && options['help']) {
+        return {
+            ...getParsedArgsForHelp(),
+            workspaceDir,
+        };
+    }
+    if (opts.renamedOptions != null) {
+        for (const [cliOption, optionValue] of Object.entries(options)) {
+            if (opts.renamedOptions[cliOption]) {
+                options[opts.renamedOptions[cliOption]] = optionValue;
+                delete options[cliOption];
+            }
+        }
+    }
+    const params = argv.remain.slice(1);
+    if (options['recursive'] !== true && (options['filter'] || options['filter-prod'] || recursiveCommandUsed)) {
+        options['recursive'] = true;
+        const subCmd = argv.remain[1] && opts.getCommandLongName(argv.remain[1]);
+        if (subCmd && recursiveCommandUsed) {
+            params.shift();
+            argv.remain.shift();
+            cmd = subCmd;
+        }
+    }
+    if (options['workspace-root']) {
+        if (options['global']) {
+            throw new PnpmError('OPTIONS_CONFLICT', '--workspace-root may not be used with --global');
+        }
+        if (!workspaceDir) {
+            throw new PnpmError('NOT_IN_WORKSPACE', '--workspace-root may only be used inside a workspace');
+        }
+        options['dir'] = workspaceDir;
+    }
+    if (cmd === 'install' && params.length > 0) {
+        cmd = 'add';
+    }
+    else if (!cmd && options['recursive']) {
+        cmd = 'recursive';
+    }
+    const knownOptions = new Set(Object.keys(types));
+    return {
+        argv,
+        cmd,
+        params,
+        workspaceDir,
+        fallbackCommandUsed,
+        ...normalizeOptions(options, knownOptions),
+    };
+}
+const CUSTOM_OPTION_PREFIX = 'config.';
+function normalizeOptions(options, knownOptions) {
+    const standardOptionNames = [];
+    const normalizedOptions = {};
+    for (const [optionName, optionValue] of Object.entries(options)) {
+        if (optionName.startsWith(CUSTOM_OPTION_PREFIX)) {
+            normalizedOptions[optionName.substring(CUSTOM_OPTION_PREFIX.length)] = optionValue;
+            continue;
+        }
+        normalizedOptions[optionName] = optionValue;
+        standardOptionNames.push(optionName);
+    }
+    const unknownOptions = getUnknownOptions(standardOptionNames, knownOptions);
+    return { options: normalizedOptions, unknownOptions };
+}
+function getUnknownOptions(usedOptions, knownOptions) {
+    const unknownOptions = new Map();
+    const closestMatches = getClosestOptionMatches.bind(null, Array.from(knownOptions));
+    for (const usedOption of usedOptions) {
+        if (knownOptions.has(usedOption) || usedOption.startsWith('//') || isScopeRegistryOption(usedOption))
+            continue;
+        unknownOptions.set(usedOption, closestMatches(usedOption));
+    }
+    return unknownOptions;
+}
+function isScopeRegistryOption(optionName) {
+    return /^@[a-z0-9][\w.-]*:registry$/.test(optionName);
+}
+function getClosestOptionMatches(knownOptions, option) {
+    return didYouMean(option, knownOptions, {
+        returnType: ReturnTypeEnums.ALL_CLOSEST_MATCHES,
+    });
+}
+async function getWorkspaceDir(parsedOpts) {
+    if (parsedOpts['global'] || parsedOpts['ignore-workspace'])
+        return undefined;
+    const dir = parsedOpts['dir'] ?? process.cwd();
+    return findWorkspaceDir(dir);
+}
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@pnpm/cli.parse-cli-args",
+  "version": "1000.1.4",
+  "description": "Parses the CLI args passed to pnpm",
+  "keywords": [
+    "pnpm",
+    "pnpm11"
+  ],
+  "license": "MIT",
+  "funding": "https://opencollective.com/pnpm",
+  "repository": "https://github.com/pnpm/pnpm/tree/main/cli/parse-cli-args",
+  "homepage": "https://github.com/pnpm/pnpm/tree/main/cli/parse-cli-args#readme",
+  "bugs": {
+    "url": "https://github.com/pnpm/pnpm/issues"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": "./lib/index.js"
+  },
+  "files": [
+    "lib",
+    "!*.map"
+  ],
+  "dependencies": {
+    "@pnpm/nopt": "^0.3.1",
+    "didyoumean2": "^7.0.4",
+    "@pnpm/workspace.root-finder": "1000.1.3",
+    "@pnpm/error": "1000.0.5"
+  },
+  "devDependencies": {
+    "tempy": "3.0.0",
+    "@pnpm/cli.parse-cli-args": "1000.1.4"
+  },
+  "engines": {
+    "node": ">=22.13"
+  },
+  "jest": {
+    "preset": "@pnpm/jest-config"
+  },
+  "scripts": {
+    "lint": "eslint \"src/**/*.ts\" \"test/**/*.ts\"",
+    "_test": "cross-env NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules --disable-warning=ExperimentalWarning --disable-warning=DEP0169\" jest",
+    "test": "pnpm run compile && pnpm run _test",
+    "start": "tsgo --watch",
+    "compile": "tsgo --build && pnpm run lint --fix"
+  }
+}