windmill-cli 1.641.0 → 1.643.0

package/esm/deps/jsr.io/@windmill-labs/cliffy-command/1.0.0-rc.5/upgrade/upgrade_command.js

@@ -1,133 +0,0 @@
-import { bold, brightBlue } from "../../../../@std/fmt/0.225.6/colors.js";
-import { ValidationError } from "../_errors.js";
-import { exit } from "../../../cliffy-internal/1.0.0-rc.5/runtime/exit.js";
-import { Command } from "../command.js";
-import { EnumType } from "../types/enum.js";
-import { createLogger } from "./logger.js";
-import { Spinner } from "./spinner.js";
-import { upgrade, } from "./upgrade.js";
-/**
- * The `UpgradeCommand` adds an upgrade functionality to the cli to be able to
- * seamlessly upgrade the cli to the latest or a specific version from a
- * provided registry with any supported runtime.
- * Currently supported runtimes are: `deno`, `node` and `bun`.
- *
- * @example Upgrade command example.
- *
- * ```
- * import { Command } from "@cliffy/command";
- * import { UpgradeCommand } from "@cliffy/command/upgrade";
- * import { DenoLandProvider } from "@cliffy/command/upgrade/provider/deno-land";
- * import { GithubProvider } from "@cliffy/command/upgrade/provider/github";
- * import { JsrProvider } from "@cliffy/command/upgrade/provider/jsr";
- * import { NestLandProvider } from "@cliffy/command/upgrade/provider/nest-land";
- * import { NpmProvider } from "@cliffy/command/upgrade/provider/npm";
- *
- * await new Command()
- *   .name("my-cli")
- *   .version("0.2.1")
- *   .command(
- *     "upgrade",
- *     new UpgradeCommand({
- *       provider: [
- *         new JsrProvider({ scope: "examples" }),
- *         new NpmProvider({ scope: "examples" }),
- *         new DenoLandProvider(),
- *         new NestLandProvider(),
- *         new GithubProvider({ repository: "examples/my-cli" }),
- *       ],
- *     }),
- *   )
- *   .parse();
- * ```
- */
-export class UpgradeCommand extends Command {
-    constructor({ provider, ...options }) {
-        super();
-        Object.defineProperty(this, "providers", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.providers = Array.isArray(provider) ? provider : [provider];
-        if (!this.providers.length) {
-            throw new Error(`No upgrade provider defined!`);
-        }
-        this
-            .description(() => `Upgrade ${this.getMainCommand().getName()} executable to latest or given version.`)
-            .noGlobals()
-            .type("provider", new EnumType(this.getProviderNames()))
-            .option("-r, --registry <name:provider>", `The registry name from which to upgrade.`, {
-            default: this.getProvider().name,
-            hidden: this.providers.length < 2,
-            value: (registry) => this.getProvider(registry),
-        })
-            .option("-l, --list-versions", "Show available versions.", {
-            action: async ({ registry }) => {
-                await registry.listVersions(this.getMainCommand().getName(), this.getVersion());
-                exit(0);
-            },
-        })
-            .option("--version <version:string:version>", "The version to upgrade to.", { default: "latest" })
-            .option("-f, --force", "Replace current installation even if not out-of-date.")
-            .option("-v, --verbose", "Log verbose output.")
-            .option("--no-spinner", "Disable spinner.")
-            .complete("version", () => this.getAllVersions())
-            .action(async ({ registry: provider, version, force, verbose, spinner: spinnerEnabled, }) => {
-            const name = this.getMainCommand().getName();
-            const currentVersion = this.getVersion();
-            const spinner = spinnerEnabled
-                ? new Spinner({
-                    message: brightBlue(`Upgrading ${bold(name)} from version ${bold(currentVersion ?? "")} to ${bold(version)}...`),
-                })
-                : undefined;
-            const logger = createLogger({ spinner, verbose });
-            spinner?.start();
-            provider.setLogger(logger);
-            try {
-                await upgrade({
-                    name,
-                    to: version,
-                    from: currentVersion,
-                    force,
-                    provider,
-                    verbose,
-                    logger,
-                    ...options,
-                });
-            }
-            catch (error) {
-                logger.error(!verbose && error instanceof Error ? error.message : error);
-                spinner?.stop();
-                exit(1);
-            }
-            finally {
-                spinner?.stop();
-            }
-        });
-    }
-    async getAllVersions() {
-        const { versions } = await this.getVersions();
-        return versions;
-    }
-    async getLatestVersion() {
-        const { latest } = await this.getVersions();
-        return latest;
-    }
-    getVersions() {
-        return this.getProvider().getVersions(this.getMainCommand().getName());
-    }
-    getProvider(name) {
-        const provider = name
-            ? this.providers.find((provider) => provider.name === name)
-            : this.providers[0];
-        if (!provider) {
-            throw new ValidationError(`Unknown provider "${name}"`);
-        }
-        return provider;
-    }
-    getProviderNames() {
-        return this.providers.map((provider) => provider.name);
-    }
-}

package/esm/deps/jsr.io/@windmill-labs/cliffy-flags/1.0.0-rc.5/_errors.js

@@ -1,117 +0,0 @@
-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 InvalidOptionError extends ValidationError {
-    constructor(option, options) {
-        super(`Invalid option "${getFlag(option)}".${didYouMeanOption(option, options)}`);
-        Object.setPrototypeOf(this, InvalidOptionError.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, InvalidOptionValueError.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, MissingOptionValueError.prototype);
-    }
-}

package/esm/deps/jsr.io/@windmill-labs/cliffy-flags/1.0.0-rc.5/_utils.js

@@ -1,89 +0,0 @@
-import { closestString } from "../../../@std/text/1.0.0-rc.1/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;
-}
-export function getDefaultValue(option) {
-    return typeof option.default === "function"
-        ? option.default()
-        : option.default;
-}

package/esm/deps/jsr.io/@windmill-labs/cliffy-flags/1.0.0-rc.5/_validate_flags.js

@@ -1,155 +0,0 @@
-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);
-        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);
-        }
-        const hasDefaultValue = (!opts.ignoreDefaults ||
-            typeof opts.ignoreDefaults[name] === "undefined") &&
-            typeof ctx.flags[name] === "undefined" && (typeof option.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]);
-            }
-        }
-    }
-}
-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) {
-    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]) {
-            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";
-}

package/esm/deps/jsr.io/@windmill-labs/cliffy-flags/1.0.0-rc.5/deprecated.js

@@ -1,9 +0,0 @@
-// deno-lint-ignore-file no-explicit-any
-/** @deprecated Use `ArgumentType` instead. */
-export var OptionType;
-(function (OptionType) {
-    OptionType["STRING"] = "string";
-    OptionType["NUMBER"] = "number";
-    OptionType["INTEGER"] = "integer";
-    OptionType["BOOLEAN"] = "boolean";
-})(OptionType || (OptionType = {}));