pnpm 12.9.0 → 12.10.0

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

@@ -1,398 +0,0 @@
-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

@@ -1,144 +0,0 @@
-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

@@ -1,91 +0,0 @@
-'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

@@ -1,67 +0,0 @@
-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 };