git-remote-ops 0.1.0

package/esm/deps/jsr.io/@cliffy/command/1.1.0/_errors.js

@@ -0,0 +1,133 @@
+import { didYouMeanCommand } from "./_utils.js";
+import { getFlag } from "./_utils.js";
+import { bold } from "../../../@std/fmt/1.0.10/colors.js";
+export class CommandError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        Object.setPrototypeOf(this, CommandError.prototype);
+    }
+}
+export class ValidationError extends CommandError {
+    exitCode;
+    cmd;
+    constructor(message, { exitCode, cause } = {}) {
+        super(message, { cause });
+        Object.setPrototypeOf(this, ValidationError.prototype);
+        this.exitCode = exitCode ?? 2;
+    }
+}
+export class DuplicateOptionNameError extends CommandError {
+    constructor(optionName, commandName) {
+        super(`An option with name '${bold(getFlag(optionName))}' is already registered on command '${bold(commandName)}'. If it is intended to override the option, set the '${bold("override")}' option of the '${bold("option")}' method to true.`);
+        Object.setPrototypeOf(this, DuplicateOptionNameError.prototype);
+    }
+}
+export class MissingCommandNameCompletionsError extends CommandError {
+    constructor(shell) {
+        super(`Failed to generate shell completions. Missing main command name. Use '${bold('cmd.name("<command-name>")')}' to set the name of the main command or use the '${bold("--name")}' option from the '${bold("completions")}' command to set the cli name: '${bold(`<command> completions ${shell} --name <cli-name>`)}'.`);
+        Object.setPrototypeOf(this, MissingCommandNameCompletionsError.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 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 TooManyArgumentsError extends ValidationError {
+    constructor(args) {
+        super(`Too many arguments: ${args.join(" ")}`);
+        Object.setPrototypeOf(this, TooManyArgumentsError.prototype);
+    }
+}

package/esm/deps/jsr.io/@cliffy/command/1.1.0/_spread.js

@@ -0,0 +1 @@
+export {};

package/esm/deps/jsr.io/@cliffy/command/1.1.0/_type_utils.js

@@ -0,0 +1 @@
+export {};

package/esm/deps/jsr.io/@cliffy/command/1.1.0/_utils.js

@@ -0,0 +1,141 @@
+import { UnexpectedArgumentAfterVariadicArgumentError, UnexpectedRequiredArgumentError, } from "../../flags/1.1.0/mod.js";
+import { closestString } from "../../../@std/text/1.0.18/closest_string.js";
+export function getFlag(name) {
+    if (name.startsWith("-")) {
+        return name;
+    }
+    if (name.length > 1) {
+        return `--${name}`;
+    }
+    return `-${name}`;
+}
+export function didYouMean(message, type, types) {
+    const match = types.length
+        ? closestString(type, types)
+        : undefined;
+    return match ? `${message} "${match}"?` : "";
+}
+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:
+ * ```json
+ * {
+ *   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 = Array.isArray(argsDefinition)
+        ? argsDefinition
+        : argsDefinition.split(/ +/);
+    for (let argDef of parts) {
+        if (typeof argDef === "string") {
+            argDef = { arg: argDef };
+        }
+        if (validate && hasVariadic) {
+            throw new UnexpectedArgumentAfterVariadicArgumentError(argDef.arg);
+        }
+        const parts = argDef.arg.split(ARGUMENT_DETAILS_REGEX);
+        if (!parts[1]) {
+            if (all) {
+                argumentDetails.push(parts[0]);
+            }
+            continue;
+        }
+        const type = parts[2] || "string";
+        const details = {
+            description: argDef.description,
+            optional: argDef.arg[0] === "[",
+            raw: argDef.arg,
+            name: parts[1],
+            action: parts[3] || type,
+            variadic: false,
+            list: type ? argDef.arg.indexOf(type + "[]") !== -1 : false,
+            type,
+        };
+        if (argDef.value !== undefined) {
+            details.value = argDef.value;
+        }
+        if (argDef.default !== undefined) {
+            details.default = argDef.default;
+        }
+        if (argDef.separator !== undefined) {
+            details.separator = argDef.separator;
+        }
+        if (validate && !details.optional && hasOptional) {
+            throw new UnexpectedRequiredArgumentError(details.name);
+        }
+        if (argDef.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);
+}
+/** Convert underscore case string to camel case. */
+export function underscoreToCamelCase(str) {
+    return str
+        .replace(/([a-z])([A-Z])/g, "$1_$2")
+        .toLowerCase()
+        .replace(/_([a-z])/g, (g) => g[1].toUpperCase());
+}