@pnpm/exe 12.8.2 → 12.9.0

package/dist/wasm/node_modules/chalk/source/util.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const stringReplaceAll = (string, substring, replacer) => {
+	let index = string.indexOf(substring);
+	if (index === -1) {
+		return string;
+	}
+
+	const substringLength = substring.length;
+	let endIndex = 0;
+	let returnValue = '';
+	do {
+		returnValue += string.substr(endIndex, index - endIndex) + substring + replacer;
+		endIndex = index + substringLength;
+		index = string.indexOf(substring, endIndex);
+	} while (index !== -1);
+
+	returnValue += string.substr(endIndex);
+	return returnValue;
+};
+
+const stringEncaseCRLFWithFirstIndex = (string, prefix, postfix, index) => {
+	let endIndex = 0;
+	let returnValue = '';
+	do {
+		const gotCR = string[index - 1] === '\r';
+		returnValue += string.substr(endIndex, (gotCR ? index - 1 : index) - endIndex) + prefix + (gotCR ? '\r\n' : '\n') + postfix;
+		endIndex = index + 1;
+		index = string.indexOf('\n', endIndex);
+	} while (index !== -1);
+
+	returnValue += string.substr(endIndex);
+	return returnValue;
+};
+
+module.exports = {
+	stringReplaceAll,
+	stringEncaseCRLFWithFirstIndex
+};

package/dist/wasm/node_modules/clipanion/README.md

@@ -0,0 +1,98 @@
+# <img src="./logo.svg" height="25" /> Clipanion
+
+> Type-safe CLI library with no runtime dependencies
+
+[![npm version](https://img.shields.io/npm/v/clipanion.svg)](https://yarnpkg.com/package/clipanion) [![Licence](https://img.shields.io/npm/l/clipanion.svg)](https://github.com/arcanis/clipanion#license-mit) [![Yarn](https://img.shields.io/badge/developed%20with-Yarn%202-blue)](https://github.com/yarnpkg/berry)
+
+## Installation
+
+```sh
+yarn add clipanion
+```
+
+## Why
+
+- Clipanion supports advanced typing mechanisms
+- Clipanion supports nested commands (`yarn workspaces list`)
+- Clipanion supports transparent option proxying without `--` (for example `yarn dlx eslint --fix`)
+- Clipanion supports all option types you could think of (including negations, batches, ...)
+- Clipanion offers a [Typanion](https://github.com/arcanis/typanion) integration for increased validation capabilities
+- Clipanion generates an optimized state machine out of your commands
+- Clipanion generates good-looking help pages out of the box
+- Clipanion offers common optional command entries out-of-the-box (e.g. version command, help command)
+
+Clipanion is used in [Yarn](https://github.com/yarnpkg/berry) with great success.
+
+## Documentation
+
+Check the website for our documentation: [mael.dev/clipanion](https://mael.dev/clipanion/).
+
+## Migration
+
+You can use [`clipanion-v3-codemod`](https://github.com/paul-soporan/clipanion-v3-codemod) to migrate a Clipanion v2 codebase to v3.
+
+## Overview
+
+Commands are declared by extending from the `Command` abstract base class, and more specifically by implementing its `execute` method which will then be called by Clipanion. Whatever exit code it returns will then be set as the exit code for the process:
+
+```ts
+class SuccessCommand extends Command {
+    async execute() {
+        return 0;
+    }
+}
+```
+
+Commands can also be exposed via one or many arbitrary paths using the `paths` static property:
+
+```ts
+class FooCommand extends Command {
+    static paths = [[`foo`]];
+    async execute() {
+        this.context.stdout.write(`Foo\n`);
+    }
+}
+
+class BarCommand extends Command {
+    static paths = [[`bar`]];
+    async execute() {
+        this.context.stdout.write(`Bar\n`);
+    }
+}
+```
+
+Options are defined as regular class properties, annotated by the helpers provided in the `Option` namespace. If you use TypeScript, all property types will then be properly inferred with no extra work required:
+
+```ts
+class HelloCommand extends Command {
+    // Positional option
+    name = Option.String();
+
+    async execute() {
+        this.context.stdout.write(`Hello ${this.name}!\n`);
+    }
+}
+```
+
+Option arguments can be validated and coerced using the [Typanion](https://mael.dev/typanion/) library:
+
+```ts
+class AddCommand extends Command {
+    a = Option.String({required: true, validator: t.isNumber()});
+    b = Option.String({required: true, validator: t.isNumber()});
+
+    async execute() {
+        this.context.stdout.write(`${this.a + this.b}\n`);
+    }
+}
+```
+
+## License (MIT)
+
+> **Copyright © 2019 Mael Nison**
+>
+> 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/dist/wasm/node_modules/clipanion/lib/advanced/Cli.d.ts

@@ -0,0 +1,225 @@
+/// <reference types="node" />
+import { Readable, Writable } from 'stream';
+import { CommandBuilder } from '../core';
+import { ColorFormat } from '../format';
+import { CommandClass, Command, Definition } from './Command';
+import { CommandOption } from './options/utils';
+declare type MakeOptional<T, Keys extends keyof T> = Omit<T, Keys> & Partial<Pick<T, Keys>>;
+declare type VoidIfEmpty<T> = keyof T extends never ? void : never;
+/**
+ * The base context of the CLI.
+ *
+ * All Contexts have to extend it.
+ */
+export declare type BaseContext = {
+    /**
+     * The input stream of the CLI.
+     *
+     * @default
+     * process.stdin
+     */
+    stdin: Readable;
+    /**
+     * The output stream of the CLI.
+     *
+     * @default
+     * process.stdout
+     */
+    stdout: Writable;
+    /**
+     * The error stream of the CLI.
+     *
+     * @default
+     * process.stderr
+     */
+    stderr: Writable;
+    /**
+     * Whether colors should be enabled.
+     */
+    colorDepth: number;
+};
+export declare type CliContext<Context extends BaseContext> = {
+    commandClass: CommandClass<Context>;
+};
+export declare type UserContextKeys<Context extends BaseContext> = Exclude<keyof Context, keyof BaseContext>;
+export declare type UserContext<Context extends BaseContext> = Pick<Context, UserContextKeys<Context>>;
+export declare type PartialContext<Context extends BaseContext> = UserContextKeys<Context> extends never ? Partial<Pick<Context, keyof BaseContext>> | undefined | void : Partial<Pick<Context, keyof BaseContext>> & UserContext<Context>;
+export declare type RunContext<Context extends BaseContext> = Context | PartialContext<Context>;
+export declare type CliOptions = Readonly<{
+    /**
+     * The label of the binary.
+     *
+     * Shown at the top of the usage information.
+     */
+    binaryLabel?: string;
+    /**
+     * The name of the binary.
+     *
+     * Included in the path and the examples of the definitions.
+     */
+    binaryName: string;
+    /**
+     * The version of the binary.
+     *
+     * Shown at the top of the usage information.
+     */
+    binaryVersion?: string;
+    /**
+     * If `true`, the Cli will hook into the process standard streams to catch
+     * the output produced by console.log and redirect them into the context
+     * streams. Note: stdin isn't captured at the moment.
+     *
+     * @default
+     * false
+     */
+    enableCapture: boolean;
+    /**
+     * If `true`, the Cli will use colors in the output. If `false`, it won't.
+     * If `undefined`, Clipanion will infer the correct value from the env.
+     */
+    enableColors?: boolean;
+}>;
+export declare type MiniCli<Context extends BaseContext> = CliOptions & {
+    /**
+     * Returns an Array representing the definitions of all registered commands.
+     */
+    definitions(): Array<Definition>;
+    /**
+     * Formats errors using colors.
+     *
+     * @param error The error to format. If `error.name` is `'Error'`, it is replaced with `'Internal Error'`.
+     * @param opts.command The command whose usage will be included in the formatted error.
+     */
+    error(error: Error, opts?: {
+        command?: Command<Context> | null;
+    }): string;
+    /**
+     * Returns a rich color format if colors are enabled, or a plain text format otherwise.
+     *
+     * @param colored Forcefully enable or disable colors.
+     */
+    format(colored?: boolean): ColorFormat;
+    /**
+     * Compiles a command and its arguments using the `CommandBuilder`.
+     *
+     * @param input An array containing the name of the command and its arguments
+     *
+     * @returns The compiled `Command`, with its properties populated with the arguments.
+     */
+    process(input: Array<string>): Command<Context>;
+    /**
+     * Runs a command.
+     *
+     * @param input An array containing the name of the command and its arguments
+     * @param context Overrides the Context of the main `Cli` instance
+     *
+     * @returns The exit code of the command
+     */
+    run(input: Array<string>, context?: Partial<Context>): Promise<number>;
+    /**
+     * Returns the usage of a command.
+     *
+     * @param command The `Command` whose usage will be returned or `null` to return the usage of all commands.
+     * @param opts.detailed If `true`, the usage of a command will also include its description, details, and examples. Doesn't have any effect if `command` is `null` or doesn't have a `usage` property.
+     * @param opts.prefix The prefix displayed before each command. Defaults to `$`.
+     */
+    usage(command?: CommandClass<Context> | Command<Context> | null, opts?: {
+        detailed?: boolean;
+        prefix?: string;
+    }): string;
+};
+/**
+ * @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`.
+ */
+export declare class Cli<Context extends BaseContext = BaseContext> implements Omit<MiniCli<Context>, `run`> {
+    /**
+     * The default context of the CLI.
+     *
+     * Contains the stdio of the current `process`.
+     */
+    static defaultContext: {
+        stdin: NodeJS.ReadStream & {
+            fd: 0;
+        };
+        stdout: NodeJS.WriteStream & {
+            fd: 1;
+        };
+        stderr: NodeJS.WriteStream & {
+            fd: 2;
+        };
+        colorDepth: number;
+    };
+    private readonly builder;
+    protected readonly registrations: Map<CommandClass<Context>, {
+        index: number;
+        builder: CommandBuilder<CliContext<Context>>;
+        specs: Map<string, CommandOption<unknown>>;
+    }>;
+    readonly binaryLabel?: string;
+    readonly binaryName: string;
+    readonly binaryVersion?: string;
+    readonly enableCapture: boolean;
+    readonly enableColors?: boolean;
+    /**
+     * Creates a new Cli and registers all commands passed as parameters.
+     *
+     * @param commandClasses The Commands to register
+     * @returns The created `Cli` instance
+     */
+    static from<Context extends BaseContext = BaseContext>(commandClasses: Array<CommandClass<Context>>, options?: Partial<CliOptions>): Cli<Context>;
+    constructor({ binaryLabel, binaryName: binaryNameOpt, binaryVersion, enableCapture, enableColors }?: Partial<CliOptions>);
+    /**
+     * Registers a command inside the CLI.
+     */
+    register(commandClass: CommandClass<Context>): void;
+    process(input: Array<string>): Command<Context>;
+    run(input: Command<Context> | Array<string>, context: VoidIfEmpty<Omit<Context, keyof BaseContext>>): Promise<number>;
+    run(input: Command<Context> | Array<string>, context: MakeOptional<Context, keyof BaseContext>): Promise<number>;
+    /**
+     * Runs a command and exits the current `process` with the exit code returned by the command.
+     *
+     * @param input An array containing the name of the command and its arguments.
+     *
+     * @example
+     * cli.runExit(process.argv.slice(2))
+     */
+    runExit(input: Command<Context> | Array<string>, context: VoidIfEmpty<Omit<Context, keyof BaseContext>>): Promise<void>;
+    runExit(input: Command<Context> | Array<string>, context: MakeOptional<Context, keyof BaseContext>): Promise<void>;
+    suggest(input: Array<string>, partial: boolean): string[][];
+    definitions({ colored }?: {
+        colored?: boolean;
+    }): Array<Definition>;
+    usage(command?: CommandClass<Context> | Command<Context> | null, { colored, detailed, prefix }?: {
+        colored?: boolean;
+        detailed?: boolean;
+        prefix?: string;
+    }): string;
+    error(error: Error | any, { colored, command }?: {
+        colored?: boolean;
+        command?: Command<Context> | null;
+    }): string;
+    format(colored?: boolean): ColorFormat;
+    protected getUsageByRegistration(klass: CommandClass<Context>, opts?: {
+        detailed?: boolean;
+        inlineOptions?: boolean;
+    }): {
+        usage: string;
+        options: {
+            definition: string;
+            description: string;
+            required: boolean;
+        }[];
+    };
+    protected getUsageByIndex(n: number, opts?: {
+        detailed?: boolean;
+        inlineOptions?: boolean;
+    }): {
+        usage: string;
+        options: {
+            definition: string;
+            description: string;
+            required: boolean;
+        }[];
+    };
+}
+export {};