@pnpm/exe 12.8.1 → 12.9.0

package/dist/wasm/node_modules/clipanion/lib/advanced/Cli.mjs

@@ -0,0 +1,398 @@
+import { HELP_COMMAND_INDEX } from '../constants.mjs';
+import { Command } from './Command.mjs';
+import tty from 'tty';
+import { CliBuilder } from '../core.mjs';
+import { formatMarkdownish, richFormat, textFormat } from '../format.mjs';
+import { HelpCommand } from './HelpCommand.mjs';
+
+const errorCommandSymbol = Symbol(`clipanion/errorCommand`);
+function getDefaultColorDepth() {
+    if (process.env.FORCE_COLOR === `0`)
+        return 1;
+    if (process.env.FORCE_COLOR === `1`)
+        return 8;
+    if (typeof process.stdout !== `undefined` && process.stdout.isTTY)
+        return 8;
+    return 1;
+}
+/**
+ * @template Context The context shared by all commands. Contexts are a set of values, defined when calling the `run`/`runExit` functions from the CLI instance, that will be made available to the commands via `this.context`.
+ */
+class Cli {
+    constructor({ binaryLabel, binaryName: binaryNameOpt = `...`, binaryVersion, enableCapture = false, enableColors } = {}) {
+        this.registrations = new Map();
+        this.builder = new CliBuilder({ binaryName: binaryNameOpt });
+        this.binaryLabel = binaryLabel;
+        this.binaryName = binaryNameOpt;
+        this.binaryVersion = binaryVersion;
+        this.enableCapture = enableCapture;
+        this.enableColors = enableColors;
+    }
+    /**
+     * Creates a new Cli and registers all commands passed as parameters.
+     *
+     * @param commandClasses The Commands to register
+     * @returns The created `Cli` instance
+     */
+    static from(commandClasses, options = {}) {
+        const cli = new Cli(options);
+        for (const commandClass of commandClasses)
+            cli.register(commandClass);
+        return cli;
+    }
+    /**
+     * Registers a command inside the CLI.
+     */
+    register(commandClass) {
+        var _a;
+        const specs = new Map();
+        const command = new commandClass();
+        for (const key in command) {
+            const value = command[key];
+            if (typeof value === `object` && value !== null && value[Command.isOption]) {
+                specs.set(key, value);
+            }
+        }
+        const builder = this.builder.command();
+        const index = builder.cliIndex;
+        const paths = (_a = commandClass.paths) !== null && _a !== void 0 ? _a : command.paths;
+        if (typeof paths !== `undefined`)
+            for (const path of paths)
+                builder.addPath(path);
+        this.registrations.set(commandClass, { specs, builder, index });
+        for (const [key, { definition }] of specs.entries())
+            definition(builder, key);
+        builder.setContext({
+            commandClass,
+        });
+    }
+    process(input) {
+        const { contexts, process } = this.builder.compile();
+        const state = process(input);
+        switch (state.selectedIndex) {
+            case HELP_COMMAND_INDEX:
+                {
+                    return HelpCommand.from(state, contexts);
+                }
+            default:
+                {
+                    const { commandClass } = contexts[state.selectedIndex];
+                    const record = this.registrations.get(commandClass);
+                    if (typeof record === `undefined`)
+                        throw new Error(`Assertion failed: Expected the command class to have been registered.`);
+                    const command = new commandClass();
+                    command.path = state.path;
+                    try {
+                        for (const [key, { transformer }] of record.specs.entries())
+                            command[key] = transformer(record.builder, key, state);
+                        return command;
+                    }
+                    catch (error) {
+                        error[errorCommandSymbol] = command;
+                        throw error;
+                    }
+                }
+                break;
+        }
+    }
+    async run(input, userContext) {
+        var _a;
+        let command;
+        const context = {
+            ...Cli.defaultContext,
+            ...userContext,
+        };
+        const colored = (_a = this.enableColors) !== null && _a !== void 0 ? _a : context.colorDepth > 1;
+        if (!Array.isArray(input)) {
+            command = input;
+        }
+        else {
+            try {
+                command = this.process(input);
+            }
+            catch (error) {
+                context.stdout.write(this.error(error, { colored }));
+                return 1;
+            }
+        }
+        if (command.help) {
+            context.stdout.write(this.usage(command, { colored, detailed: true }));
+            return 0;
+        }
+        command.context = context;
+        command.cli = {
+            binaryLabel: this.binaryLabel,
+            binaryName: this.binaryName,
+            binaryVersion: this.binaryVersion,
+            enableCapture: this.enableCapture,
+            enableColors: this.enableColors,
+            definitions: () => this.definitions(),
+            error: (error, opts) => this.error(error, opts),
+            format: colored => this.format(colored),
+            process: input => this.process(input),
+            run: (input, subContext) => this.run(input, { ...context, ...subContext }),
+            usage: (command, opts) => this.usage(command, opts),
+        };
+        const activate = this.enableCapture
+            ? getCaptureActivator(context)
+            : noopCaptureActivator;
+        let exitCode;
+        try {
+            exitCode = await activate(() => command.validateAndExecute().catch(error => command.catch(error).then(() => 0)));
+        }
+        catch (error) {
+            context.stdout.write(this.error(error, { colored, command }));
+            return 1;
+        }
+        return exitCode;
+    }
+    async runExit(input, context) {
+        process.exitCode = await this.run(input, context);
+    }
+    suggest(input, partial) {
+        const { suggest } = this.builder.compile();
+        return suggest(input, partial);
+    }
+    definitions({ colored = false } = {}) {
+        const data = [];
+        for (const [commandClass, { index }] of this.registrations) {
+            if (typeof commandClass.usage === `undefined`)
+                continue;
+            const { usage: path } = this.getUsageByIndex(index, { detailed: false });
+            const { usage, options } = this.getUsageByIndex(index, { detailed: true, inlineOptions: false });
+            const category = typeof commandClass.usage.category !== `undefined`
+                ? formatMarkdownish(commandClass.usage.category, { format: this.format(colored), paragraphs: false })
+                : undefined;
+            const description = typeof commandClass.usage.description !== `undefined`
+                ? formatMarkdownish(commandClass.usage.description, { format: this.format(colored), paragraphs: false })
+                : undefined;
+            const details = typeof commandClass.usage.details !== `undefined`
+                ? formatMarkdownish(commandClass.usage.details, { format: this.format(colored), paragraphs: true })
+                : undefined;
+            const examples = typeof commandClass.usage.examples !== `undefined`
+                ? commandClass.usage.examples.map(([label, cli]) => [formatMarkdownish(label, { format: this.format(colored), paragraphs: false }), cli.replace(/\$0/g, this.binaryName)])
+                : undefined;
+            data.push({ path, usage, category, description, details, examples, options });
+        }
+        return data;
+    }
+    usage(command = null, { colored, detailed = false, prefix = `$ ` } = {}) {
+        var _a;
+        // In case the default command is the only one, we can just show the command help rather than the general one
+        if (command === null) {
+            for (const commandClass of this.registrations.keys()) {
+                const paths = commandClass.paths;
+                const isDocumented = typeof commandClass.usage !== `undefined`;
+                const isExclusivelyDefault = !paths || paths.length === 0 || (paths.length === 1 && paths[0].length === 0);
+                const isDefault = isExclusivelyDefault || ((_a = paths === null || paths === void 0 ? void 0 : paths.some(path => path.length === 0)) !== null && _a !== void 0 ? _a : false);
+                if (isDefault) {
+                    if (command) {
+                        command = null;
+                        break;
+                    }
+                    else {
+                        command = commandClass;
+                    }
+                }
+                else {
+                    if (isDocumented) {
+                        command = null;
+                        continue;
+                    }
+                }
+            }
+            if (command) {
+                detailed = true;
+            }
+        }
+        // @ts-ignore
+        const commandClass = command !== null && command instanceof Command
+            ? command.constructor
+            : command;
+        let result = ``;
+        if (!commandClass) {
+            const commandsByCategories = new Map();
+            for (const [commandClass, { index }] of this.registrations.entries()) {
+                if (typeof commandClass.usage === `undefined`)
+                    continue;
+                const category = typeof commandClass.usage.category !== `undefined`
+                    ? formatMarkdownish(commandClass.usage.category, { format: this.format(colored), paragraphs: false })
+                    : null;
+                let categoryCommands = commandsByCategories.get(category);
+                if (typeof categoryCommands === `undefined`)
+                    commandsByCategories.set(category, categoryCommands = []);
+                const { usage } = this.getUsageByIndex(index);
+                categoryCommands.push({ commandClass, usage });
+            }
+            const categoryNames = Array.from(commandsByCategories.keys()).sort((a, b) => {
+                if (a === null)
+                    return -1;
+                if (b === null)
+                    return +1;
+                return a.localeCompare(b, `en`, { usage: `sort`, caseFirst: `upper` });
+            });
+            const hasLabel = typeof this.binaryLabel !== `undefined`;
+            const hasVersion = typeof this.binaryVersion !== `undefined`;
+            if (hasLabel || hasVersion) {
+                if (hasLabel && hasVersion)
+                    result += `${this.format(colored).header(`${this.binaryLabel} - ${this.binaryVersion}`)}\n\n`;
+                else if (hasLabel)
+                    result += `${this.format(colored).header(`${this.binaryLabel}`)}\n`;
+                else
+                    result += `${this.format(colored).header(`${this.binaryVersion}`)}\n`;
+                result += `  ${this.format(colored).bold(prefix)}${this.binaryName} <command>\n`;
+            }
+            else {
+                result += `${this.format(colored).bold(prefix)}${this.binaryName} <command>\n`;
+            }
+            for (const categoryName of categoryNames) {
+                const commands = commandsByCategories.get(categoryName).slice().sort((a, b) => {
+                    return a.usage.localeCompare(b.usage, `en`, { usage: `sort`, caseFirst: `upper` });
+                });
+                const header = categoryName !== null
+                    ? categoryName.trim()
+                    : `General commands`;
+                result += `\n`;
+                result += `${this.format(colored).header(`${header}`)}\n`;
+                for (const { commandClass, usage } of commands) {
+                    const doc = commandClass.usage.description || `undocumented`;
+                    result += `\n`;
+                    result += `  ${this.format(colored).bold(usage)}\n`;
+                    result += `    ${formatMarkdownish(doc, { format: this.format(colored), paragraphs: false })}`;
+                }
+            }
+            result += `\n`;
+            result += formatMarkdownish(`You can also print more details about any of these commands by calling them with the \`-h,--help\` flag right after the command name.`, { format: this.format(colored), paragraphs: true });
+        }
+        else {
+            if (!detailed) {
+                const { usage } = this.getUsageByRegistration(commandClass);
+                result += `${this.format(colored).bold(prefix)}${usage}\n`;
+            }
+            else {
+                const { description = ``, details = ``, examples = [], } = commandClass.usage || {};
+                if (description !== ``) {
+                    result += formatMarkdownish(description, { format: this.format(colored), paragraphs: false }).replace(/^./, $0 => $0.toUpperCase());
+                    result += `\n`;
+                }
+                if (details !== `` || examples.length > 0) {
+                    result += `${this.format(colored).header(`Usage`)}\n`;
+                    result += `\n`;
+                }
+                const { usage, options } = this.getUsageByRegistration(commandClass, { inlineOptions: false });
+                result += `${this.format(colored).bold(prefix)}${usage}\n`;
+                if (options.length > 0) {
+                    result += `\n`;
+                    result += `${richFormat.header(`Options`)}\n`;
+                    const maxDefinitionLength = options.reduce((length, option) => {
+                        return Math.max(length, option.definition.length);
+                    }, 0);
+                    result += `\n`;
+                    for (const { definition, description } of options) {
+                        result += `  ${this.format(colored).bold(definition.padEnd(maxDefinitionLength))}    ${formatMarkdownish(description, { format: this.format(colored), paragraphs: false })}`;
+                    }
+                }
+                if (details !== ``) {
+                    result += `\n`;
+                    result += `${this.format(colored).header(`Details`)}\n`;
+                    result += `\n`;
+                    result += formatMarkdownish(details, { format: this.format(colored), paragraphs: true });
+                }
+                if (examples.length > 0) {
+                    result += `\n`;
+                    result += `${this.format(colored).header(`Examples`)}\n`;
+                    for (const [description, example] of examples) {
+                        result += `\n`;
+                        result += formatMarkdownish(description, { format: this.format(colored), paragraphs: false });
+                        result += `${example
+                            .replace(/^/m, `  ${this.format(colored).bold(prefix)}`)
+                            .replace(/\$0/g, this.binaryName)}\n`;
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    error(error, _a) {
+        var _b;
+        var { colored, command = (_b = error[errorCommandSymbol]) !== null && _b !== void 0 ? _b : null } = _a === void 0 ? {} : _a;
+        if (!(error instanceof Error))
+            error = new Error(`Execution failed with a non-error rejection (rejected value: ${JSON.stringify(error)})`);
+        let result = ``;
+        let name = error.name.replace(/([a-z])([A-Z])/g, `$1 $2`);
+        if (name === `Error`)
+            name = `Internal Error`;
+        result += `${this.format(colored).error(name)}: ${error.message}\n`;
+        const meta = error.clipanion;
+        if (typeof meta !== `undefined`) {
+            if (meta.type === `usage`) {
+                result += `\n`;
+                result += this.usage(command);
+            }
+        }
+        else {
+            if (error.stack) {
+                result += `${error.stack.replace(/^.*\n/, ``)}\n`;
+            }
+        }
+        return result;
+    }
+    format(colored) {
+        var _a;
+        return ((_a = colored !== null && colored !== void 0 ? colored : this.enableColors) !== null && _a !== void 0 ? _a : Cli.defaultContext.colorDepth > 1) ? richFormat : textFormat;
+    }
+    getUsageByRegistration(klass, opts) {
+        const record = this.registrations.get(klass);
+        if (typeof record === `undefined`)
+            throw new Error(`Assertion failed: Unregistered command`);
+        return this.getUsageByIndex(record.index, opts);
+    }
+    getUsageByIndex(n, opts) {
+        return this.builder.getBuilderByIndex(n).usage(opts);
+    }
+}
+/**
+ * The default context of the CLI.
+ *
+ * Contains the stdio of the current `process`.
+ */
+Cli.defaultContext = {
+    stdin: process.stdin,
+    stdout: process.stdout,
+    stderr: process.stderr,
+    colorDepth: `getColorDepth` in tty.WriteStream.prototype
+        ? tty.WriteStream.prototype.getColorDepth()
+        : getDefaultColorDepth(),
+};
+let gContextStorage;
+function getCaptureActivator(context) {
+    let contextStorage = gContextStorage;
+    if (typeof contextStorage === `undefined`) {
+        if (context.stdout === process.stdout && context.stderr === process.stderr)
+            return noopCaptureActivator;
+        const { AsyncLocalStorage: LazyAsyncLocalStorage } = require(`async_hooks`);
+        contextStorage = gContextStorage = new LazyAsyncLocalStorage();
+        const origStdoutWrite = process.stdout._write;
+        process.stdout._write = function (chunk, encoding, cb) {
+            const context = contextStorage.getStore();
+            if (typeof context === `undefined`)
+                return origStdoutWrite.call(this, chunk, encoding, cb);
+            return context.stdout.write(chunk, encoding, cb);
+        };
+        const origStderrWrite = process.stderr._write;
+        process.stderr._write = function (chunk, encoding, cb) {
+            const context = contextStorage.getStore();
+            if (typeof context === `undefined`)
+                return origStderrWrite.call(this, chunk, encoding, cb);
+            return context.stderr.write(chunk, encoding, cb);
+        };
+    }
+    return (fn) => {
+        return contextStorage.run(context, fn);
+    };
+}
+function noopCaptureActivator(fn) {
+    return fn();
+}
+
+export { Cli };

package/dist/wasm/node_modules/clipanion/lib/advanced/Command.d.ts

@@ -0,0 +1,144 @@
+import { LooseTest } from 'typanion';
+import { BaseContext, MiniCli } from './Cli';
+import { isOptionSymbol } from './options/utils';
+/**
+ * The usage of a Command.
+ */
+export declare type Usage = {
+    /**
+     * The category of the command.
+     *
+     * Included in the detailed usage.
+     */
+    category?: string;
+    /**
+     * The short description of the command, formatted as Markdown.
+     *
+     * Included in the detailed usage.
+     */
+    description?: string;
+    /**
+     * The extended details of the command, formatted as Markdown.
+     *
+     * Included in the detailed usage.
+     */
+    details?: string;
+    /**
+     * Examples of the command represented as an Array of tuples.
+     *
+     * The first element of the tuple represents the description of the example.
+     *
+     * The second element of the tuple represents the command of the example.
+     * If present, the leading `$0` is replaced with `cli.binaryName`.
+     */
+    examples?: Array<[string, string]>;
+};
+/**
+ * The definition of a Command.
+ */
+export declare type Definition = Usage & {
+    /**
+     * The path of the command, starting with `cli.binaryName`.
+     */
+    path: string;
+    /**
+     * The detailed usage of the command.
+     */
+    usage: string;
+    /**
+     * The various options registered on the command.
+     */
+    options: Array<{
+        definition: string;
+        description?: string;
+        required: boolean;
+    }>;
+};
+export declare type CommandClass<Context extends BaseContext = BaseContext> = {
+    new (): Command<Context>;
+    paths?: Array<Array<string>>;
+    schema?: Array<LooseTest<{
+        [key: string]: unknown;
+    }>>;
+    usage?: Usage;
+};
+export declare abstract class Command<Context extends BaseContext = BaseContext> {
+    /**
+     * @deprecated Do not use this; prefer the static `paths` property instead.
+     */
+    paths?: undefined;
+    /**
+     * Defined to prevent a common typo.
+     */
+    static path: never;
+    /**
+     * Paths under which the command should be exposed.
+     */
+    static paths?: Array<Array<string>>;
+    /**
+     * Defines the usage information for the given command.
+     */
+    static Usage(usage: Usage): Usage;
+    /**
+     * Contains the usage information for the command. If undefined, the
+     * command will be hidden from the general listing.
+     */
+    static usage?: Usage;
+    /**
+     * Defines a schema to apply before running the `execute` method. The
+     * schema is expected to be generated by Typanion.
+     *
+     * @see https://github.com/arcanis/typanion
+     */
+    static schema?: Array<LooseTest<{
+        [key: string]: unknown;
+    }>>;
+    /**
+     * Standard function that'll get executed by `Cli#run` and `Cli#runExit`.
+     *
+     * Expected to return an exit code or nothing (which Clipanion will treat
+     * as if 0 had been returned).
+     */
+    abstract execute(): Promise<number | void>;
+    /**
+     * Standard error handler which will simply rethrow the error. Can be used
+     * to add custom logic to handle errors from the command or simply return
+     * the parent class error handling.
+     */
+    catch(error: any): Promise<void>;
+    /**
+     * Predefined that will be set to true if `-h,--help` has been used, in
+     * which case `Command#execute` won't be called.
+     */
+    help: boolean;
+    /**
+     * Predefined variable that will be populated with a miniature API that can
+     * be used to query Clipanion and forward commands.
+     */
+    cli: MiniCli<Context>;
+    /**
+     * Predefined variable that will be populated with the context of the
+     * application.
+     */
+    context: Context;
+    /**
+     * Predefined variable that will be populated with the path that got used
+     * to access the command currently being executed.
+     */
+    path: Array<string>;
+    validateAndExecute(): Promise<number>;
+    /**
+     * Used to detect option definitions.
+     */
+    static isOption: typeof isOptionSymbol;
+    /**
+     * Just an helper to use along with the `paths` fields, to make it
+     * clearer that a command is the default one.
+     *
+     * @example
+     * class MyCommand extends Command {
+     *   static paths = [Command.Default];
+     * }
+     */
+    static Default: never[];
+}

package/dist/wasm/node_modules/clipanion/lib/advanced/Command.js

@@ -0,0 +1,91 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var utils = require('./options/utils.js');
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () {
+                        return e[k];
+                    }
+                });
+            }
+        });
+    }
+    n['default'] = e;
+    return Object.freeze(n);
+}
+
+class Command {
+    constructor() {
+        /**
+         * Predefined that will be set to true if `-h,--help` has been used, in
+         * which case `Command#execute` won't be called.
+         */
+        this.help = false;
+    }
+    /**
+     * Defines the usage information for the given command.
+     */
+    static Usage(usage) {
+        return usage;
+    }
+    /**
+     * Standard error handler which will simply rethrow the error. Can be used
+     * to add custom logic to handle errors from the command or simply return
+     * the parent class error handling.
+     */
+    async catch(error) {
+        throw error;
+    }
+    async validateAndExecute() {
+        const commandClass = this.constructor;
+        const cascade = commandClass.schema;
+        if (Array.isArray(cascade)) {
+            const { isDict, isUnknown, applyCascade } = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('typanion')); });
+            const schema = applyCascade(isDict(isUnknown()), cascade);
+            const errors = [];
+            const coercions = [];
+            const check = schema(this, { errors, coercions });
+            if (!check)
+                throw utils.formatError(`Invalid option schema`, errors);
+            for (const [, op] of coercions) {
+                op();
+            }
+        }
+        else if (cascade != null) {
+            throw new Error(`Invalid command schema`);
+        }
+        const exitCode = await this.execute();
+        if (typeof exitCode !== `undefined`) {
+            return exitCode;
+        }
+        else {
+            return 0;
+        }
+    }
+}
+/**
+ * Used to detect option definitions.
+ */
+Command.isOption = utils.isOptionSymbol;
+/**
+ * Just an helper to use along with the `paths` fields, to make it
+ * clearer that a command is the default one.
+ *
+ * @example
+ * class MyCommand extends Command {
+ *   static paths = [Command.Default];
+ * }
+ */
+Command.Default = [];
+
+exports.Command = Command;

package/dist/wasm/node_modules/clipanion/lib/advanced/Command.mjs

@@ -0,0 +1,67 @@
+import { formatError, isOptionSymbol } from './options/utils.mjs';
+
+class Command {
+    constructor() {
+        /**
+         * Predefined that will be set to true if `-h,--help` has been used, in
+         * which case `Command#execute` won't be called.
+         */
+        this.help = false;
+    }
+    /**
+     * Defines the usage information for the given command.
+     */
+    static Usage(usage) {
+        return usage;
+    }
+    /**
+     * Standard error handler which will simply rethrow the error. Can be used
+     * to add custom logic to handle errors from the command or simply return
+     * the parent class error handling.
+     */
+    async catch(error) {
+        throw error;
+    }
+    async validateAndExecute() {
+        const commandClass = this.constructor;
+        const cascade = commandClass.schema;
+        if (Array.isArray(cascade)) {
+            const { isDict, isUnknown, applyCascade } = await import('typanion');
+            const schema = applyCascade(isDict(isUnknown()), cascade);
+            const errors = [];
+            const coercions = [];
+            const check = schema(this, { errors, coercions });
+            if (!check)
+                throw formatError(`Invalid option schema`, errors);
+            for (const [, op] of coercions) {
+                op();
+            }
+        }
+        else if (cascade != null) {
+            throw new Error(`Invalid command schema`);
+        }
+        const exitCode = await this.execute();
+        if (typeof exitCode !== `undefined`) {
+            return exitCode;
+        }
+        else {
+            return 0;
+        }
+    }
+}
+/**
+ * Used to detect option definitions.
+ */
+Command.isOption = isOptionSymbol;
+/**
+ * Just an helper to use along with the `paths` fields, to make it
+ * clearer that a command is the default one.
+ *
+ * @example
+ * class MyCommand extends Command {
+ *   static paths = [Command.Default];
+ * }
+ */
+Command.Default = [];
+
+export { Command };