track-cli 3.0.0-rc

package/esm/deps/deno.land/x/cliffy@v0.25.7/_utils/distance.d.ts

@@ -0,0 +1 @@
+export declare function distance(a: string, b: string): number;

package/esm/deps/deno.land/x/cliffy@v0.25.7/_utils/distance.js

@@ -0,0 +1,26 @@
+export function distance(a, b) {
+    if (a.length == 0) {
+        return b.length;
+    }
+    if (b.length == 0) {
+        return a.length;
+    }
+    const matrix = [];
+    for (let i = 0; i <= b.length; i++) {
+        matrix[i] = [i];
+    }
+    for (let j = 0; j <= a.length; j++) {
+        matrix[0][j] = j;
+    }
+    for (let i = 1; i <= b.length; i++) {
+        for (let j = 1; j <= a.length; j++) {
+            if (b.charAt(i - 1) == a.charAt(j - 1)) {
+                matrix[i][j] = matrix[i - 1][j - 1];
+            }
+            else {
+                matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, Math.min(matrix[i][j - 1] + 1, matrix[i - 1][j] + 1));
+            }
+        }
+    }
+    return matrix[b.length][a.length];
+}

package/esm/deps/deno.land/x/cliffy@v0.25.7/command/_errors.d.ts

@@ -0,0 +1,76 @@
+import type { Command } from "./command.js";
+import { EnvVar } from "./types.js";
+export declare class CommandError extends Error {
+    constructor(message: string);
+}
+export interface ValidationErrorOptions {
+    exitCode?: number;
+}
+export declare class ValidationError extends CommandError {
+    readonly exitCode: number;
+    cmd?: Command;
+    constructor(message: string, { exitCode }?: ValidationErrorOptions);
+}
+export declare class DuplicateOptionNameError extends CommandError {
+    constructor(name: string);
+}
+export declare class MissingCommandNameError extends CommandError {
+    constructor();
+}
+export declare class DuplicateCommandNameError extends CommandError {
+    constructor(name: string);
+}
+export declare class DuplicateCommandAliasError extends CommandError {
+    constructor(alias: string);
+}
+export declare class CommandNotFoundError extends CommandError {
+    constructor(name: string, commands: Array<Command>, excluded?: Array<string>);
+}
+export declare class DuplicateTypeError extends CommandError {
+    constructor(name: string);
+}
+export declare class DuplicateCompletionError extends CommandError {
+    constructor(name: string);
+}
+export declare class DuplicateExampleError extends CommandError {
+    constructor(name: string);
+}
+export declare class DuplicateEnvVarError extends CommandError {
+    constructor(name: string);
+}
+export declare class MissingRequiredEnvVarError extends ValidationError {
+    constructor(envVar: EnvVar);
+}
+export declare class TooManyEnvVarValuesError extends CommandError {
+    constructor(name: string);
+}
+export declare class UnexpectedOptionalEnvVarValueError extends CommandError {
+    constructor(name: string);
+}
+export declare class UnexpectedVariadicEnvVarValueError extends CommandError {
+    constructor(name: string);
+}
+export declare class DefaultCommandNotFoundError extends CommandError {
+    constructor(name: string, commands: Array<Command>);
+}
+export declare class CommandExecutableNotFoundError extends CommandError {
+    constructor(name: string);
+}
+export declare class UnknownCompletionCommandError extends CommandError {
+    constructor(name: string, commands: Array<Command>);
+}
+export declare class UnknownCommandError extends ValidationError {
+    constructor(name: string, commands: Array<Command>, excluded?: Array<string>);
+}
+export declare class NoArgumentsAllowedError extends ValidationError {
+    constructor(name: string);
+}
+export declare class MissingArgumentsError extends ValidationError {
+    constructor(names: Array<string>);
+}
+export declare class MissingArgumentError extends ValidationError {
+    constructor(name: string);
+}
+export declare class TooManyArgumentsError extends ValidationError {
+    constructor(args: Array<string>);
+}

package/esm/deps/deno.land/x/cliffy@v0.25.7/command/_errors.js

@@ -0,0 +1,154 @@
+import { didYouMeanCommand } from "./_utils.js";
+import { getFlag } from "../flags/_utils.js";
+export class CommandError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, CommandError.prototype);
+    }
+}
+export class ValidationError extends CommandError {
+    constructor(message, { exitCode } = {}) {
+        super(message);
+        Object.defineProperty(this, "exitCode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cmd", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.setPrototypeOf(this, ValidationError.prototype);
+        this.exitCode = exitCode ?? 1;
+    }
+}
+export class DuplicateOptionNameError extends CommandError {
+    constructor(name) {
+        super(`Option with name "${getFlag(name)}" already exists.`);
+        Object.setPrototypeOf(this, DuplicateOptionNameError.prototype);
+    }
+}
+export class MissingCommandNameError extends CommandError {
+    constructor() {
+        super("Missing command name.");
+        Object.setPrototypeOf(this, MissingCommandNameError.prototype);
+    }
+}
+export class DuplicateCommandNameError extends CommandError {
+    constructor(name) {
+        super(`Duplicate command name "${name}".`);
+        Object.setPrototypeOf(this, DuplicateCommandNameError.prototype);
+    }
+}
+export class DuplicateCommandAliasError extends CommandError {
+    constructor(alias) {
+        super(`Duplicate command alias "${alias}".`);
+        Object.setPrototypeOf(this, DuplicateCommandAliasError.prototype);
+    }
+}
+export class CommandNotFoundError extends CommandError {
+    constructor(name, commands, excluded) {
+        super(`Unknown command "${name}".${didYouMeanCommand(name, commands, excluded)}`);
+        Object.setPrototypeOf(this, CommandNotFoundError.prototype);
+    }
+}
+export class DuplicateTypeError extends CommandError {
+    constructor(name) {
+        super(`Type with name "${name}" already exists.`);
+        Object.setPrototypeOf(this, DuplicateTypeError.prototype);
+    }
+}
+export class DuplicateCompletionError extends CommandError {
+    constructor(name) {
+        super(`Completion with name "${name}" already exists.`);
+        Object.setPrototypeOf(this, DuplicateCompletionError.prototype);
+    }
+}
+export class DuplicateExampleError extends CommandError {
+    constructor(name) {
+        super(`Example with name "${name}" already exists.`);
+        Object.setPrototypeOf(this, DuplicateExampleError.prototype);
+    }
+}
+export class DuplicateEnvVarError extends CommandError {
+    constructor(name) {
+        super(`Environment variable with name "${name}" already exists.`);
+        Object.setPrototypeOf(this, DuplicateEnvVarError.prototype);
+    }
+}
+export class MissingRequiredEnvVarError extends ValidationError {
+    constructor(envVar) {
+        super(`Missing required environment variable "${envVar.names[0]}".`);
+        Object.setPrototypeOf(this, MissingRequiredEnvVarError.prototype);
+    }
+}
+export class TooManyEnvVarValuesError extends CommandError {
+    constructor(name) {
+        super(`An environment variable can only have one value, but "${name}" has more than one.`);
+        Object.setPrototypeOf(this, TooManyEnvVarValuesError.prototype);
+    }
+}
+export class UnexpectedOptionalEnvVarValueError extends CommandError {
+    constructor(name) {
+        super(`An environment variable cannot have an optional value, but "${name}" is defined as optional.`);
+        Object.setPrototypeOf(this, UnexpectedOptionalEnvVarValueError.prototype);
+    }
+}
+export class UnexpectedVariadicEnvVarValueError extends CommandError {
+    constructor(name) {
+        super(`An environment variable cannot have an variadic value, but "${name}" is defined as variadic.`);
+        Object.setPrototypeOf(this, UnexpectedVariadicEnvVarValueError.prototype);
+    }
+}
+export class DefaultCommandNotFoundError extends CommandError {
+    constructor(name, commands) {
+        super(`Default command "${name}" not found.${didYouMeanCommand(name, commands)}`);
+        Object.setPrototypeOf(this, DefaultCommandNotFoundError.prototype);
+    }
+}
+export class CommandExecutableNotFoundError extends CommandError {
+    constructor(name) {
+        super(`Command executable not found: ${name}`);
+        Object.setPrototypeOf(this, CommandExecutableNotFoundError.prototype);
+    }
+}
+export class UnknownCompletionCommandError extends CommandError {
+    constructor(name, commands) {
+        super(`Auto-completion failed. Unknown command "${name}".${didYouMeanCommand(name, commands)}`);
+        Object.setPrototypeOf(this, UnknownCompletionCommandError.prototype);
+    }
+}
+/* Validation errors. */
+export class UnknownCommandError extends ValidationError {
+    constructor(name, commands, excluded) {
+        super(`Unknown command "${name}".${didYouMeanCommand(name, commands, excluded)}`);
+        Object.setPrototypeOf(this, UnknownCommandError.prototype);
+    }
+}
+export class NoArgumentsAllowedError extends ValidationError {
+    constructor(name) {
+        super(`No arguments allowed for command "${name}".`);
+        Object.setPrototypeOf(this, NoArgumentsAllowedError.prototype);
+    }
+}
+export class MissingArgumentsError extends ValidationError {
+    constructor(names) {
+        super(`Missing argument(s): ${names.join(", ")}`);
+        Object.setPrototypeOf(this, MissingArgumentsError.prototype);
+    }
+}
+export class MissingArgumentError extends ValidationError {
+    constructor(name) {
+        super(`Missing argument: ${name}`);
+        Object.setPrototypeOf(this, MissingArgumentError.prototype);
+    }
+}
+export class TooManyArgumentsError extends ValidationError {
+    constructor(args) {
+        super(`Too many arguments: ${args.join(" ")}`);
+        Object.setPrototypeOf(this, TooManyArgumentsError.prototype);
+    }
+}

package/esm/deps/deno.land/x/cliffy@v0.25.7/command/_utils.d.ts

@@ -0,0 +1,32 @@
+import type { Command } from "./command.js";
+import type { Argument } from "./types.js";
+export declare function didYouMeanCommand(command: string, commands: Array<Command>, excludes?: Array<string>): string;
+interface SplitArgumentsResult {
+    flags: string[];
+    typeDefinition: string;
+    equalsSign: boolean;
+}
+/**
+ * Split options and arguments.
+ * @param args Arguments definition: `--color, -c <color1:string> <color2:string>`
+ *
+ * For example: `-c, --color <color1:string> <color2:string>`
+ *
+ * Will result in:
+ * ```
+ * {
+ *   flags: [ "-c", "--color" ],
+ *   typeDefinition: "<color1:string> <color2:string>"
+ * }
+ * ```
+ */
+export declare function splitArguments(args: string): SplitArgumentsResult;
+/**
+ * Parse arguments string.
+ * @param argsDefinition Arguments definition: `<color1:string> <color2:string>`
+ */
+export declare function parseArgumentsDefinition<T extends boolean>(argsDefinition: string, validate: boolean, all: true): Array<Argument | string>;
+export declare function parseArgumentsDefinition<T extends boolean>(argsDefinition: string, validate?: boolean, all?: false): Array<Argument>;
+export declare function dedent(str: string): string;
+export declare function getDescription(description: string, short?: boolean): string;
+export {};

package/esm/deps/deno.land/x/cliffy@v0.25.7/command/_utils.js

@@ -0,0 +1,105 @@
+import { UnexpectedArgumentAfterVariadicArgumentError, UnexpectedRequiredArgumentError, } from "../flags/_errors.js";
+import { didYouMean } from "../flags/_utils.js";
+import { OptionType } from "../flags/deprecated.js";
+export function didYouMeanCommand(command, commands, excludes = []) {
+    const commandNames = commands
+        .map((command) => command.getName())
+        .filter((command) => !excludes.includes(command));
+    return didYouMean(" Did you mean command", command, commandNames);
+}
+const ARGUMENT_REGEX = /^[<\[].+[\]>]$/;
+const ARGUMENT_DETAILS_REGEX = /[<\[:>\]]/;
+/**
+ * Split options and arguments.
+ * @param args Arguments definition: `--color, -c <color1:string> <color2:string>`
+ *
+ * For example: `-c, --color <color1:string> <color2:string>`
+ *
+ * Will result in:
+ * ```
+ * {
+ *   flags: [ "-c", "--color" ],
+ *   typeDefinition: "<color1:string> <color2:string>"
+ * }
+ * ```
+ */
+export function splitArguments(args) {
+    const parts = args.trim().split(/[, =] */g);
+    const typeParts = [];
+    while (parts[parts.length - 1] &&
+        ARGUMENT_REGEX.test(parts[parts.length - 1])) {
+        typeParts.unshift(parts.pop());
+    }
+    const typeDefinition = typeParts.join(" ");
+    return { flags: parts, typeDefinition, equalsSign: args.includes("=") };
+}
+export function parseArgumentsDefinition(argsDefinition, validate = true, all) {
+    const argumentDetails = [];
+    let hasOptional = false;
+    let hasVariadic = false;
+    const parts = argsDefinition.split(/ +/);
+    for (const arg of parts) {
+        if (validate && hasVariadic) {
+            throw new UnexpectedArgumentAfterVariadicArgumentError(arg);
+        }
+        const parts = arg.split(ARGUMENT_DETAILS_REGEX);
+        if (!parts[1]) {
+            if (all) {
+                argumentDetails.push(parts[0]);
+            }
+            continue;
+        }
+        const type = parts[2] || OptionType.STRING;
+        const details = {
+            optionalValue: arg[0] === "[",
+            requiredValue: arg[0] === "<",
+            name: parts[1],
+            action: parts[3] || type,
+            variadic: false,
+            list: type ? arg.indexOf(type + "[]") !== -1 : false,
+            type,
+        };
+        if (validate && !details.optionalValue && hasOptional) {
+            throw new UnexpectedRequiredArgumentError(details.name);
+        }
+        if (arg[0] === "[") {
+            hasOptional = true;
+        }
+        if (details.name.length > 3) {
+            const istVariadicLeft = details.name.slice(0, 3) === "...";
+            const istVariadicRight = details.name.slice(-3) === "...";
+            hasVariadic = details.variadic = istVariadicLeft || istVariadicRight;
+            if (istVariadicLeft) {
+                details.name = details.name.slice(3);
+            }
+            else if (istVariadicRight) {
+                details.name = details.name.slice(0, -3);
+            }
+        }
+        argumentDetails.push(details);
+    }
+    return argumentDetails;
+}
+export function dedent(str) {
+    const lines = str.split(/\r?\n|\r/g);
+    let text = "";
+    let indent = 0;
+    for (const line of lines) {
+        if (text || line.trim()) {
+            if (!text) {
+                text = line.trimStart();
+                indent = line.length - text.length;
+            }
+            else {
+                text += line.slice(indent);
+            }
+            text += "\n";
+        }
+    }
+    return text.trimEnd();
+}
+export function getDescription(description, short) {
+    return short
+        ? description.trim().split("\n", 1)[0].trim()
+        : dedent(description);
+}