git-remote-ops 0.1.0

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

@@ -0,0 +1,129 @@
+import { didYouMeanOption, didYouMeanType, getFlag } from "./_utils.js";
+export class FlagsError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, FlagsError.prototype);
+    }
+}
+export class UnknownRequiredOptionError extends FlagsError {
+    constructor(option, options) {
+        super(`Unknown required option "${getFlag(option)}".${didYouMeanOption(option, options)}`);
+        Object.setPrototypeOf(this, UnknownRequiredOptionError.prototype);
+    }
+}
+export class UnknownConflictingOptionError extends FlagsError {
+    constructor(option, options) {
+        super(`Unknown conflicting option "${getFlag(option)}".${didYouMeanOption(option, options)}`);
+        Object.setPrototypeOf(this, UnknownConflictingOptionError.prototype);
+    }
+}
+export class UnknownTypeError extends FlagsError {
+    constructor(type, types) {
+        super(`Unknown type "${type}".${didYouMeanType(type, types)}`);
+        Object.setPrototypeOf(this, UnknownTypeError.prototype);
+    }
+}
+/* Validation errors. */
+/**
+ * A validation error is thrown when the command is wrongly used by the user.
+ * For example: If the user passes some invalid options or arguments to the
+ * command.
+ */
+export class ValidationError extends FlagsError {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, ValidationError.prototype);
+    }
+}
+export class DuplicateOptionError extends ValidationError {
+    constructor(name) {
+        super(`Option "${getFlag(name).replace(/^--no-/, "--")}" can only occur once, but was found several times.`);
+        Object.setPrototypeOf(this, DuplicateOptionError.prototype);
+    }
+}
+export class UnknownOptionError extends ValidationError {
+    constructor(option, options) {
+        super(`Unknown option "${getFlag(option)}".${didYouMeanOption(option, options)}`);
+        Object.setPrototypeOf(this, UnknownOptionError.prototype);
+    }
+}
+export class MissingOptionValueError extends ValidationError {
+    constructor(option) {
+        super(`Missing value for option "${getFlag(option)}".`);
+        Object.setPrototypeOf(this, MissingOptionValueError.prototype);
+    }
+}
+export class InvalidOptionValueError extends ValidationError {
+    constructor(option, expected, value) {
+        super(`Option "${getFlag(option)}" must be of type "${expected}", but got "${value}".`);
+        Object.setPrototypeOf(this, InvalidOptionValueError.prototype);
+    }
+}
+export class UnexpectedOptionValueError extends ValidationError {
+    constructor(option, value) {
+        super(`Option "${getFlag(option)}" doesn't take a value, but got "${value}".`);
+        Object.setPrototypeOf(this, UnexpectedOptionValueError.prototype);
+    }
+}
+export class OptionNotCombinableError extends ValidationError {
+    constructor(option) {
+        super(`Option "${getFlag(option)}" cannot be combined with other options.`);
+        Object.setPrototypeOf(this, OptionNotCombinableError.prototype);
+    }
+}
+export class ConflictingOptionError extends ValidationError {
+    constructor(option, conflictingOption) {
+        super(`Option "${getFlag(option)}" conflicts with option "${getFlag(conflictingOption)}".`);
+        Object.setPrototypeOf(this, ConflictingOptionError.prototype);
+    }
+}
+export class DependingOptionError extends ValidationError {
+    constructor(option, dependingOption) {
+        super(`Option "${getFlag(option)}" depends on option "${getFlag(dependingOption)}".`);
+        Object.setPrototypeOf(this, DependingOptionError.prototype);
+    }
+}
+export class MissingRequiredOptionError extends ValidationError {
+    constructor(option) {
+        super(`Missing required option "${getFlag(option)}".`);
+        Object.setPrototypeOf(this, MissingRequiredOptionError.prototype);
+    }
+}
+export class UnexpectedRequiredArgumentError extends ValidationError {
+    constructor(arg) {
+        super(`An required argument cannot follow an optional argument, but "${arg}"  is defined as required.`);
+        Object.setPrototypeOf(this, UnexpectedRequiredArgumentError.prototype);
+    }
+}
+export class UnexpectedArgumentAfterVariadicArgumentError extends ValidationError {
+    constructor(arg) {
+        super(`An argument cannot follow an variadic argument, but got "${arg}".`);
+        Object.setPrototypeOf(this, UnexpectedArgumentAfterVariadicArgumentError.prototype);
+    }
+}
+export class InvalidTypeError extends ValidationError {
+    constructor({ label, name, value, type }, expected) {
+        super(`${label} "${name}" must be of type "${type}", but got "${value}".` + (expected
+            ? ` Expected values: ${expected.map((value) => `"${value}"`).join(", ")}`
+            : ""));
+        Object.setPrototypeOf(this, InvalidTypeError.prototype);
+    }
+}
+export class MissingArgumentError extends ValidationError {
+    constructor(name) {
+        super(`Missing argument: ${name}`);
+        Object.setPrototypeOf(this, MissingArgumentError.prototype);
+    }
+}
+export class MissingArgumentsError extends ValidationError {
+    constructor(names) {
+        super(`Missing argument(s): ${names.join(", ")}`);
+        Object.setPrototypeOf(this, MissingArgumentsError.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/flags/1.1.0/_utils.js

@@ -0,0 +1,100 @@
+import { closestString } from "../../../@std/text/1.0.18/closest_string.js";
+/** Convert param case string to camel case. */
+export function paramCaseToCamelCase(str) {
+    return str.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
+}
+/**
+ * Find option by flag, name or alias.
+ *
+ * @param flags Source options array.
+ * @param name  Name of the option.
+ */
+export function getOption(flags, name) {
+    while (name[0] === "-") {
+        name = name.slice(1);
+    }
+    for (const flag of flags) {
+        if (isOption(flag, name)) {
+            return flag;
+        }
+    }
+    return;
+}
+export function didYouMeanOption(option, options) {
+    const optionNames = options
+        .map((option) => [option.name, ...(option.aliases ?? [])])
+        .flat()
+        .map((option) => getFlag(option));
+    return didYouMean(" Did you mean option", getFlag(option), optionNames);
+}
+export function didYouMeanType(type, types) {
+    return didYouMean(" Did you mean type", type, types);
+}
+export function didYouMean(message, type, types) {
+    const match = types.length
+        ? closestString(type, types)
+        : undefined;
+    return match ? `${message} "${match}"?` : "";
+}
+export function getFlag(name) {
+    if (name.startsWith("-")) {
+        return name;
+    }
+    if (name.length > 1) {
+        return `--${name}`;
+    }
+    return `-${name}`;
+}
+/**
+ * Check if option has name or alias.
+ *
+ * @param option    The option to check.
+ * @param name      The option name or alias.
+ */
+function isOption(option, name) {
+    return option.name === name ||
+        (option.aliases && option.aliases.indexOf(name) !== -1);
+}
+export function matchWildCardOptions(name, flags) {
+    for (const option of flags) {
+        if (option.name.indexOf("*") === -1) {
+            continue;
+        }
+        let matched = matchWildCardOption(name, option);
+        if (matched) {
+            matched = { ...matched, name };
+            flags.push(matched);
+            return matched;
+        }
+    }
+}
+function matchWildCardOption(name, option) {
+    const parts = option.name.split(".");
+    const parts2 = name.split(".");
+    if (parts.length !== parts2.length) {
+        return false;
+    }
+    const count = Math.max(parts.length, parts2.length);
+    for (let i = 0; i < count; i++) {
+        if (parts[i] !== parts2[i] && parts[i] !== "*") {
+            return false;
+        }
+    }
+    return option;
+}
+function getDefaultValues(option) {
+    const values = option.args?.map((arg) => getDefaultValue(arg)) ?? [];
+    while (values.length > 1 && values.at(-1) === undefined) {
+        values.pop();
+    }
+    return values.length ? values : undefined;
+}
+export function getDefaultValue(option) {
+    return typeof option.default === "function"
+        ? option.default()
+        : option.default !== undefined
+            ? option.default
+            : "args" in option && option.args?.some((arg) => arg.default !== undefined)
+                ? getDefaultValues(option)
+                : undefined;
+}

package/esm/deps/jsr.io/@cliffy/flags/1.1.0/_validate_flags.js

@@ -0,0 +1,166 @@
+import { getDefaultValue, getOption, paramCaseToCamelCase } from "./_utils.js";
+import { ConflictingOptionError, DependingOptionError, MissingOptionValueError, MissingRequiredOptionError, OptionNotCombinableError, UnknownOptionError, } from "./_errors.js";
+/**
+ * Flags post validation. Validations that are not already done by the parser.
+ *
+ * @param ctx     Parse context.
+ * @param opts    Parse options.
+ * @param options Option name mappings: propertyName -> option
+ */
+export function validateFlags(ctx, opts, options = new Map()) {
+    if (!opts.flags) {
+        return;
+    }
+    setDefaultValues(ctx, opts);
+    const optionNames = Object.keys(ctx.flags);
+    if (!optionNames.length && opts.allowEmpty) {
+        return;
+    }
+    if (ctx.standalone) {
+        validateStandaloneOption(ctx, options, optionNames);
+        return;
+    }
+    for (const [name, option] of options) {
+        validateUnknownOption(option, opts);
+        validateConflictingOptions(ctx, option);
+        validateDependingOptions(ctx, option, opts);
+        validateRequiredValues(ctx, option, name);
+    }
+    validateRequiredOptions(ctx, options, opts);
+}
+function validateUnknownOption(option, opts) {
+    if (!getOption(opts.flags ?? [], option.name)) {
+        throw new UnknownOptionError(option.name, opts.flags ?? []);
+    }
+}
+/**
+ * Adds all default values to ctx.flags and returns a boolean object map with
+ * only the default option names `{ [OptionName: string]: boolean }`.
+ */
+function setDefaultValues(ctx, opts) {
+    if (!opts.flags?.length) {
+        return;
+    }
+    // Set default values
+    for (const option of opts.flags) {
+        let name;
+        let defaultValue = undefined;
+        // if --no-[flag] is present set --[flag] default value to true
+        if (option.name.startsWith("no-")) {
+            const propName = option.name.replace(/^no-/, "");
+            if (typeof ctx.flags[propName] !== "undefined") {
+                continue;
+            }
+            const positiveOption = getOption(opts.flags, propName);
+            if (positiveOption) {
+                continue;
+            }
+            name = paramCaseToCamelCase(propName);
+            defaultValue = true;
+        }
+        if (!name) {
+            name = paramCaseToCamelCase(option.name);
+        }
+        // TODO: remove ignoreDefaults if flags module has support for environment variables
+        const hasDefaultValue = (!opts.ignoreDefaults ||
+            typeof opts.ignoreDefaults[name] === "undefined") &&
+            typeof ctx.flags[name] === "undefined" && (typeof option.default !== "undefined" ||
+            option.args?.some((arg) => arg.default !== undefined) ||
+            typeof defaultValue !== "undefined");
+        if (hasDefaultValue) {
+            ctx.flags[name] = getDefaultValue(option) ?? defaultValue;
+            ctx.defaults[option.name] = true;
+            if (typeof option.value === "function") {
+                ctx.flags[name] = option.value(ctx.flags[name]);
+            }
+            else if (option.args?.length) {
+                for (const [index, arg] of option.args.entries()) {
+                    if (typeof arg.value === "function") {
+                        ctx.flags[name][index] = arg.value(ctx.flags[name][index]);
+                    }
+                }
+            }
+        }
+    }
+}
+function validateStandaloneOption(ctx, options, optionNames) {
+    if (!ctx.standalone || optionNames.length === 1) {
+        return;
+    }
+    // Don't throw an error if all values are coming from the default option.
+    for (const [_, opt] of options) {
+        if (!ctx.defaults[opt.name] && opt !== ctx.standalone) {
+            throw new OptionNotCombinableError(ctx.standalone.name);
+        }
+    }
+}
+function validateConflictingOptions(ctx, option) {
+    if (!option.conflicts?.length) {
+        return;
+    }
+    for (const flag of option.conflicts) {
+        if (isset(flag, ctx.flags)) {
+            throw new ConflictingOptionError(option.name, flag);
+        }
+    }
+}
+function validateDependingOptions(ctx, option, opts) {
+    if (!option.depends) {
+        return;
+    }
+    for (const flag of option.depends) {
+        // Don't throw an error if the value is coming from the default option.
+        if (!isset(flag, ctx.flags) && !ctx.defaults[option.name] &&
+            // TODO: remove ignoreDefaults if flags module has support for environment variables
+            (!opts.ignoreDefaults || typeof opts.ignoreDefaults[flag] === "undefined")) {
+            throw new DependingOptionError(option.name, flag);
+        }
+    }
+}
+function validateRequiredValues(ctx, option, name) {
+    if (!option.args) {
+        return;
+    }
+    const isArray = option.args.length > 1;
+    for (let i = 0; i < option.args.length; i++) {
+        const arg = option.args[i];
+        if (arg.optional) {
+            continue;
+        }
+        const hasValue = isArray
+            ? typeof ctx.flags[name][i] !== "undefined"
+            : typeof ctx.flags[name] !== "undefined";
+        if (!hasValue) {
+            throw new MissingOptionValueError(option.name);
+        }
+    }
+}
+function validateRequiredOptions(ctx, options, opts) {
+    if (!opts.flags?.length) {
+        return;
+    }
+    const optionsValues = [...options.values()];
+    for (const option of opts.flags) {
+        if (!option.required || paramCaseToCamelCase(option.name) in ctx.flags) {
+            continue;
+        }
+        const conflicts = option.conflicts ?? [];
+        const hasConflict = conflicts.find((flag) => !!ctx.flags[flag]);
+        const hasConflicts = hasConflict ||
+            optionsValues.find((opt) => opt.conflicts?.find((flag) => flag === option.name));
+        if (hasConflicts) {
+            continue;
+        }
+        throw new MissingRequiredOptionError(option.name);
+    }
+}
+/**
+ * Check if value exists for flag.
+ * @param flagName  Flag name.
+ * @param flags     Parsed values.
+ */
+function isset(flagName, flags) {
+    const name = paramCaseToCamelCase(flagName);
+    // return typeof values[ name ] !== 'undefined' && values[ name ] !== false;
+    return typeof flags[name] !== "undefined";
+}