windmill-cli 1.641.0 → 1.643.0

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

@@ -1,211 +0,0 @@
-import { MissingCommandNameCompletionsError } from "../_errors.js";
-import { FileType } from "../types/file.js";
-/** Generates bash completions script. */
-export class BashCompletionsGenerator {
-    /** Generates bash completions script for given command. */
-    static generate(name, cmd) {
-        if (!name || name === "COMMAND") {
-            throw new MissingCommandNameCompletionsError("bash");
-        }
-        return new BashCompletionsGenerator(name, cmd).generate();
-    }
-    constructor(name, cmd) {
-        Object.defineProperty(this, "name", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: name
-        });
-        Object.defineProperty(this, "cmd", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: cmd
-        });
-    }
-    /** Generates bash completions code. */
-    generate() {
-        const path = this.cmd.getPath(this.name);
-        const version = this.cmd.getVersion()
-            ? ` v${this.cmd.getVersion()}`
-            : "";
-        return `#!/usr/bin/env bash
-# bash completion support for ${path}${version}
-
-_${replaceSpecialChars(path)}() {
-  local word cur prev listFiles
-  local -a opts
-  COMPREPLY=()
-  cur="\${COMP_WORDS[COMP_CWORD]}"
-  prev="\${COMP_WORDS[COMP_CWORD-1]}"
-  cmd="_"
-  opts=()
-  listFiles=0
-
-  _${replaceSpecialChars(this.name)}_complete() {
-    local action="$1"; shift
-    mapfile -t values < <( ${this.name} completions complete "\${action}" "\${@}" )
-    for i in "\${values[@]}"; do
-      opts+=("$i")
-    done
-  }
-
-  _${replaceSpecialChars(this.name)}_expand() {
-    [ "$cur" != "\${cur%\\\\}" ] && cur="$cur\\\\"
-  
-    # expand ~username type directory specifications
-    if [[ "$cur" == \\~*/* ]]; then
-      # shellcheck disable=SC2086
-      eval cur=$cur
-      
-    elif [[ "$cur" == \\~* ]]; then
-      cur=\${cur#\\~}
-      # shellcheck disable=SC2086,SC2207
-      COMPREPLY=( $( compgen -P '~' -u $cur ) )
-      return \${#COMPREPLY[@]}
-    fi
-  }
-
-  # shellcheck disable=SC2120
-  _${replaceSpecialChars(this.name)}_file_dir() {
-    listFiles=1
-    local IFS=$'\\t\\n' xspec #glob
-    _${replaceSpecialChars(this.name)}_expand || return 0
-  
-    if [ "\${1:-}" = -d ]; then
-      # shellcheck disable=SC2206,SC2207,SC2086
-      COMPREPLY=( \${COMPREPLY[@]:-} $( compgen -d -- $cur ) )
-      #eval "$glob"    # restore glob setting.
-      return 0
-    fi
-  
-    xspec=\${1:+"!*.$1"}	# set only if glob passed in as $1
-    # shellcheck disable=SC2206,SC2207
-    COMPREPLY=( \${COMPREPLY[@]:-} $( compgen -f -X "$xspec" -- "$cur" ) \
-          $( compgen -d -- "$cur" ) )
-  }
-
-  ${this.generateCompletions(this.name, this.cmd).trim()}
-
-  for word in "\${COMP_WORDS[@]}"; do
-    case "\${word}" in
-      -*) ;;
-      *)
-        cmd_tmp="\${cmd}_\${word//[^[:alnum:]]/_}"
-        if type "\${cmd_tmp}" &>/dev/null; then
-          cmd="\${cmd_tmp}"
-        fi
-    esac
-  done
-
-  \${cmd}
-
-  if [[ listFiles -eq 1 ]]; then
-    return 0
-  fi
-
-  if [[ \${#opts[@]} -eq 0 ]]; then
-    # shellcheck disable=SC2207
-    COMPREPLY=($(compgen -f "\${cur}"))
-    return 0
-  fi
-
-  local values
-  values="$( printf "\\n%s" "\${opts[@]}" )"
-  local IFS=$'\\n'
-  # shellcheck disable=SC2207
-  local result=($(compgen -W "\${values[@]}" -- "\${cur}"))
-  if [[ \${#result[@]} -eq 0 ]]; then
-    # shellcheck disable=SC2207
-    COMPREPLY=($(compgen -f "\${cur}"))
-  else
-    # shellcheck disable=SC2207
-    COMPREPLY=($(printf '%q\\n' "\${result[@]}"))
-  fi
-
-  return 0
-}
-
-complete -F _${replaceSpecialChars(path)} -o bashdefault -o default ${path}`;
-    }
-    /** Generates bash completions method for given command and child commands. */
-    generateCompletions(name, command, path = "", index = 1) {
-        path = (path ? path + " " : "") + name;
-        const commandCompletions = this.generateCommandCompletions(command, path, index);
-        const childCommandCompletions = command.getCommands(false)
-            .filter((subCommand) => subCommand !== command)
-            .map((subCommand) => this.generateCompletions(subCommand.getName(), subCommand, path, index + 1))
-            .join("");
-        return `${commandCompletions}
-
-${childCommandCompletions}`;
-    }
-    generateCommandCompletions(command, path, index) {
-        const flags = this.getFlags(command);
-        const childCommandNames = command.getCommands(false)
-            .map((childCommand) => childCommand.getName());
-        const completionsPath = ~path.indexOf(" ")
-            ? " " + path.split(" ").slice(1).join(" ")
-            : "";
-        const optionArguments = this.generateOptionArguments(command, completionsPath);
-        const completionsCmd = this.generateCommandCompletionsCommand(command, completionsPath);
-        return `  __${replaceSpecialChars(path)}() {
-    opts=(${[...flags, ...childCommandNames].join(" ")})
-    ${completionsCmd}
-    if [[ \${cur} == -* || \${COMP_CWORD} -eq ${index} ]] ; then
-      return 0
-    fi
-    ${optionArguments}
-  }`;
-    }
-    getFlags(command) {
-        return command.getOptions(false)
-            .map((option) => option.flags)
-            .flat();
-    }
-    generateOptionArguments(command, completionsPath) {
-        let opts = "";
-        const options = command.getOptions(false);
-        if (options.length) {
-            opts += 'case "${prev}" in';
-            for (const option of options) {
-                const flags = option.flags
-                    .map((flag) => flag.trim())
-                    .join("|");
-                const completionsCmd = this.generateOptionCompletionsCommand(command, option.args, completionsPath, { standalone: option.standalone });
-                opts += `\n      ${flags}) ${completionsCmd} ;;`;
-            }
-            opts += "\n    esac";
-        }
-        return opts;
-    }
-    generateCommandCompletionsCommand(command, path) {
-        const args = command.getArguments();
-        if (args.length) {
-            const type = command.getType(args[0].type);
-            if (type && type.handler instanceof FileType) {
-                return `_${replaceSpecialChars(this.name)}_file_dir`;
-            }
-            // @TODO: add support for multiple arguments
-            return `_${replaceSpecialChars(this.name)}_complete ${args[0].action}${path}`;
-        }
-        return "";
-    }
-    generateOptionCompletionsCommand(command, args, path, opts) {
-        if (args.length) {
-            const type = command.getType(args[0].type);
-            if (type && type.handler instanceof FileType) {
-                return `opts=(); _${replaceSpecialChars(this.name)}_file_dir`;
-            }
-            // @TODO: add support for multiple arguments
-            return `opts=(); _${replaceSpecialChars(this.name)}_complete ${args[0].action}${path}`;
-        }
-        if (opts?.standalone) {
-            return "opts=()";
-        }
-        return "";
-    }
-}
-function replaceSpecialChars(str) {
-    return str.replace(/[^a-zA-Z0-9]/g, "_");
-}

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

@@ -1,151 +0,0 @@
-import { MissingCommandNameCompletionsError } from "../_errors.js";
-import { getDescription } from "../_utils.js";
-import { FileType } from "../types/file.js";
-/** Fish completions generator. */
-export class FishCompletionsGenerator {
-    /** Generates fish completions script for given command. */
-    static generate(name, cmd) {
-        if (!name || name === "COMMAND") {
-            throw new MissingCommandNameCompletionsError("fish");
-        }
-        return new FishCompletionsGenerator(name, cmd).generate();
-    }
-    constructor(name, cmd) {
-        Object.defineProperty(this, "name", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: name
-        });
-        Object.defineProperty(this, "cmd", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: cmd
-        });
-    }
-    /** Generates fish completions script. */
-    generate() {
-        const path = this.cmd.getPath(this.name);
-        const version = this.cmd.getVersion()
-            ? ` v${this.cmd.getVersion()}`
-            : "";
-        return `#!/usr/bin/env fish
-# fish completion support for ${path}${version}
-
-function __fish_${replaceSpecialChars(this.name)}_using_command
-  set -l cmds ${getCommandFnNames(this.name, this.cmd).join(" ")}
-  set -l words (commandline -opc)
-  set -l cmd "_"
-  for word in $words
-    switch $word
-      case '-*'
-        continue
-      case '*'
-        set word (string replace -r -a '\\W' '_' $word)
-        set -l cmd_tmp $cmd"_$word"
-        if contains $cmd_tmp $cmds
-          set cmd $cmd_tmp
-        end
-    end
-  end
-  if test "$cmd" = "$argv[1]"
-    return 0
-  end
-  return 1
-end
-
-${this.generateCompletions(this.name, this.cmd).trim()}`;
-    }
-    generateCompletions(name, command) {
-        const parent = command.getParent();
-        let result = ``;
-        if (parent) {
-            // command
-            result += "\n" + this.complete(parent, {
-                description: command.getShortDescription(),
-                arguments: name,
-            });
-        }
-        // arguments
-        const commandArgs = command.getArguments();
-        if (commandArgs.length) {
-            result += "\n" + this.complete(command, {
-                arguments: commandArgs.length
-                    ? this.getCompletionCommand(command, commandArgs[0])
-                    : undefined,
-            });
-        }
-        // options
-        for (const option of command.getOptions(false)) {
-            result += "\n" + this.completeOption(command, option);
-        }
-        for (const subCommand of command.getCommands(false)) {
-            result += this.generateCompletions(subCommand.getName(), subCommand);
-        }
-        return result;
-    }
-    completeOption(command, option) {
-        const shortOption = option.flags
-            .find((flag) => flag.length === 2)
-            ?.replace(/^(-)+/, "");
-        const longOption = option.flags
-            .find((flag) => flag.length > 2)
-            ?.replace(/^(-)+/, "");
-        return this.complete(command, {
-            description: getDescription(option.description),
-            shortOption: shortOption,
-            longOption: longOption,
-            // required: option.requiredValue,
-            required: true,
-            standalone: option.standalone,
-            arguments: option.args.length
-                ? this.getCompletionCommand(command, option.args[0])
-                : undefined,
-        });
-    }
-    complete(command, options) {
-        const cmd = ["complete"];
-        cmd.push("-c", this.name);
-        cmd.push("-n", `'__fish_${replaceSpecialChars(this.name)}_using_command __${replaceSpecialChars(command.getPath(this.name))}'`);
-        options.shortOption && cmd.push("-s", options.shortOption);
-        options.longOption && cmd.push("-l", options.longOption);
-        options.standalone && cmd.push("-x");
-        cmd.push("-k");
-        cmd.push("-f");
-        if (options.arguments) {
-            options.required && cmd.push("-r");
-            cmd.push("-a", options.arguments);
-        }
-        if (options.description) {
-            const description = getDescription(options.description, true)
-                // escape single quotes
-                .replace(/'/g, "\\'");
-            cmd.push("-d", `'${description}'`);
-        }
-        return cmd.join(" ");
-    }
-    getCompletionCommand(cmd, arg) {
-        const type = cmd.getType(arg.type);
-        if (type && type.handler instanceof FileType) {
-            return `'(__fish_complete_path)'`;
-        }
-        return `'(${this.name} completions complete ${arg.action + " " + getCompletionsPath(cmd)})'`;
-    }
-}
-function getCommandFnNames(name, cmd, cmds = []) {
-    cmds.push(`__${replaceSpecialChars(cmd.getPath(name))}`);
-    cmd.getCommands(false).forEach((command) => {
-        getCommandFnNames(name, command, cmds);
-    });
-    return cmds;
-}
-function getCompletionsPath(command) {
-    return command.getPath()
-        .split(" ")
-        .slice(1)
-        .join(" ");
-}
-function replaceSpecialChars(str) {
-    return str.replace(/[^a-zA-Z0-9]/g, "_");
-}

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

@@ -1,314 +0,0 @@
-import { MissingCommandNameCompletionsError } from "../_errors.js";
-import { getDescription } from "../_utils.js";
-import { FileType } from "../types/file.js";
-/** Generates zsh completions script. */
-export class ZshCompletionsGenerator {
-    /** Generates zsh completions script for given command. */
-    static generate(name, cmd) {
-        if (!name || name === "COMMAND") {
-            throw new MissingCommandNameCompletionsError("zsh");
-        }
-        return new ZshCompletionsGenerator(name, cmd).generate();
-    }
-    constructor(name, cmd) {
-        Object.defineProperty(this, "name", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: name
-        });
-        Object.defineProperty(this, "cmd", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: cmd
-        });
-        Object.defineProperty(this, "actions", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Map()
-        });
-    }
-    /** Generates zsh completions code. */
-    generate() {
-        const path = this.cmd.getPath(this.name);
-        const version = this.cmd.getVersion()
-            ? ` v${this.cmd.getVersion()}`
-            : "";
-        return `#compdef ${this.name}
-
-# zsh completion support for ${path}${version}
-
-autoload -U is-at-least
-
-# shellcheck disable=SC2154
-(( $+functions[__${replaceSpecialChars(this.name)}_complete] )) ||
-function __${replaceSpecialChars(this.name)}_complete {
-  local name="$1"; shift
-  local action="$1"; shift
-  integer ret=1
-  local -a values
-  local expl lines
-  _tags "$name"
-  while _tags; do
-    if _requested "$name"; then
-      # shellcheck disable=SC2034
-      lines="$(${this.name} completions complete "\${action}" "\${@}")"
-      values=("\${(ps:\\n:)lines}")
-      if (( \${#values[@]} )); then
-        while _next_label "$name" expl "$action"; do
-          compadd -S '' "\${expl[@]}" "\${values[@]}"
-        done
-      fi
-    fi
-  done
-}
-
-${this.generateCompletions(this.name, this.cmd).trim()}
-
-# shellcheck disable=SC2154
-if [ "\${funcstack[1]}" = "_${this.name}" ]; then
-  _${replaceSpecialChars(this.name)} "\${@}"
-else
-  compdef _${replaceSpecialChars(path)} ${path};
-fi`;
-    }
-    /** Generates zsh completions method for given command and child commands. */
-    generateCompletions(name, command, path = "") {
-        if (!command.hasCommands(false) && !command.hasOptions(false) &&
-            !command.hasArguments()) {
-            return "";
-        }
-        path = (path ? path + " " : "") + name;
-        return `# shellcheck disable=SC2154
-` +
-            (command.getParent()
-                ? `(( $+functions[_${replaceSpecialChars(path)}] )) || `
-                : "") +
-            `_${replaceSpecialChars(path)}() {` +
-            (!command.getParent()
-                ? `
-  local state`
-                : "") +
-            this.generateCommandCompletions(command, path) +
-            this.generateSubCommandCompletions(command, path) +
-            this.generateArgumentCompletions(command, path) +
-            this.generateActions(command) +
-            `\n}\n\n` +
-            command.getCommands(false)
-                .filter((subCommand) => subCommand !== command)
-                .map((subCommand) => this.generateCompletions(subCommand.getName(), subCommand, path))
-                .join("");
-    }
-    generateCommandCompletions(command, path) {
-        const commands = command.getCommands(false);
-        let completions = commands
-            .map((subCommand) => `'${subCommand.getName().replace(/:/g, "\\:")}:${subCommand.getShortDescription()
-            // escape single quotes
-            .replace(/'/g, "'\"'\"'")}'`)
-            .join("\n      ");
-        if (completions) {
-            completions = `
-    local -a commands
-    # shellcheck disable=SC2034
-    commands=(
-      ${completions}
-    )
-    _describe 'command' commands`;
-        }
-        // only complete first argument, rest arguments are completed with _arguments.
-        if (command.hasArguments()) {
-            const arg = command.getArguments()[0];
-            const type = command.getType(arg.type);
-            let action;
-            if (type && type.handler instanceof FileType) {
-                const fileCompletions = this.getFileCompletions(type);
-                completions += `\n    ${fileCompletions}`;
-            }
-            else {
-                const completionsPath = path.split(" ").slice(1).join(" ");
-                action = this.addAction(arg, completionsPath);
-                if (action && command.getCompletion(arg.action)) {
-                    completions += `\n    __${replaceSpecialChars(this.name)}_complete ${action.arg.name} ${action.arg.action} ${action.cmd}`;
-                }
-            }
-        }
-        if (command.hasArguments() || command.hasCommands(false)) {
-            completions = `\n\n  function _commands() {${completions}\n  }`;
-        }
-        return completions;
-    }
-    generateSubCommandCompletions(command, path) {
-        if (command.hasCommands(false)) {
-            const actions = command
-                .getCommands(false)
-                .map((command) => {
-                const aliases = [command.getName(), ...command.getAliases()]
-                    .join("|");
-                const action = replaceSpecialChars(path + " " + command.getName());
-                return `${aliases}) _${action} ;;`;
-            })
-                .join("\n      ");
-            return `\n
-  function _command_args() {
-    case "\${words[1]}" in\n      ${actions}\n    esac
-  }`;
-        }
-        return "";
-    }
-    generateArgumentCompletions(command, path) {
-        /* clear actions from previously parsed command. */
-        this.actions.clear();
-        const options = this.generateOptions(command, path);
-        let argIndex = 0;
-        // @TODO: add stop early option: -A "-*"
-        // http://zsh.sourceforge.net/Doc/Release/Completion-System.html
-        let argsCommand = "\n\n  _arguments -w -s -S -C";
-        if (command.hasOptions()) {
-            argsCommand += ` \\\n    ${options.join(" \\\n    ")}`;
-        }
-        if (command.hasArguments() || command.hasCommands(false)) {
-            const commandArgs = command.getArguments();
-            const isVariadic = commandArgs.at(argIndex)?.variadic;
-            const selector = isVariadic ? "*" : ++argIndex;
-            argsCommand += ` \\\n    '${selector}:command:_commands'`;
-            const args = [];
-            // first argument is completed together with commands.
-            for (const arg of commandArgs.slice(1)) {
-                const type = command.getType(arg.type);
-                if (type && type.handler instanceof FileType) {
-                    const fileCompletions = this.getFileCompletions(type);
-                    if (arg.variadic) {
-                        argIndex++;
-                        for (let i = 0; i < 5; i++) {
-                            args.push(`${argIndex + i}${arg.optional ? "::" : ":"}${arg.name}:${fileCompletions}`);
-                        }
-                    }
-                    else {
-                        args.push(`${++argIndex}${arg.optional ? "::" : ":"}${arg.name}:${fileCompletions}`);
-                    }
-                }
-                else {
-                    const completionsPath = path.split(" ").slice(1).join(" ");
-                    const action = this.addAction(arg, completionsPath);
-                    args.push(`${++argIndex}${arg.optional ? "::" : ":"}${arg.name}:->${action.name}`);
-                }
-            }
-            argsCommand += args.map((arg) => `\\\n    '${arg}'`).join("");
-            if (command.hasCommands(false)) {
-                argsCommand += ` \\\n    '*::sub command:->command_args'`;
-            }
-        }
-        return argsCommand;
-    }
-    generateOptions(command, path) {
-        const options = [];
-        const cmdArgs = path.split(" ");
-        const _baseName = cmdArgs.shift();
-        const completionsPath = cmdArgs.join(" ");
-        const excludedFlags = command.getOptions(false)
-            .map((option) => option.standalone ? option.flags : false)
-            .flat()
-            .filter((flag) => typeof flag === "string");
-        for (const option of command.getOptions(false)) {
-            options.push(this.generateOption(command, option, completionsPath, excludedFlags));
-        }
-        return options;
-    }
-    generateOption(command, option, completionsPath, excludedOptions) {
-        let args = "";
-        for (const arg of option.args) {
-            const type = command.getType(arg.type);
-            const optionalValue = arg.optional ? "::" : ":";
-            if (type && type.handler instanceof FileType) {
-                const fileCompletions = this.getFileCompletions(type);
-                args += `${optionalValue}${arg.name}:${fileCompletions}`;
-            }
-            else {
-                const action = this.addAction(arg, completionsPath);
-                args += `${optionalValue}${arg.name}:->${action.name}`;
-            }
-        }
-        const description = getDescription(option.description, true)
-            // escape brackets and quotes
-            .replace(/\[/g, "\\[")
-            .replace(/]/g, "\\]")
-            .replace(/"/g, '\\"')
-            .replace(/'/g, "'\"'\"'");
-        const collect = option.collect ? "*" : "";
-        const equalsSign = option.equalsSign ? "=" : "";
-        const flags = option.flags.map((flag) => `${flag}${equalsSign}`);
-        let result = "";
-        if (option.standalone) {
-            result += "'(- *)'";
-        }
-        else {
-            const excludedFlags = [...excludedOptions];
-            if (option.conflicts?.length) {
-                excludedFlags.push(...option.conflicts.map((opt) => "--" + opt.replace(/^--/, "")));
-            }
-            if (!option.collect) {
-                excludedFlags.push(...option.flags);
-            }
-            if (excludedFlags.length) {
-                result += `'(${excludedFlags.join(" ")})'`;
-            }
-        }
-        if (collect || flags.length > 1) {
-            result += `{${collect}${flags.join(",")}}`;
-        }
-        else {
-            result += `${flags.join(",")}`;
-        }
-        return `${result}'[${description}]${args}'`;
-    }
-    getFileCompletions(type) {
-        if (!(type.handler instanceof FileType)) {
-            return "";
-        }
-        return "_files";
-        // const fileOpts = type.handler.getOptions();
-        // let fileCompletions = "_files";
-        // if (fileOpts.dirsOnly) {
-        //   fileCompletions += " -/";
-        // }
-        // if (fileOpts.pattern) {
-        //   fileCompletions += ' -g "' + fileOpts.pattern + '"';
-        // }
-        // if (fileOpts.ignore) {
-        //   fileCompletions += " -F " + fileOpts.ignore;
-        // }
-        // return fileCompletions;
-    }
-    addAction(arg, cmd) {
-        const action = `${arg.name}-${arg.action}`;
-        if (!this.actions.has(action)) {
-            this.actions.set(action, {
-                arg: arg,
-                label: `${arg.name}: ${arg.action}`,
-                name: action,
-                cmd,
-            });
-        }
-        return this.actions.get(action);
-    }
-    generateActions(command) {
-        let actions = [];
-        if (this.actions.size) {
-            actions = Array
-                .from(this.actions)
-                .map(([name, action]) => `${name}) __${replaceSpecialChars(this.name)}_complete ${action.arg.name} ${action.arg.action} ${action.cmd} ;;`);
-        }
-        if (command.hasCommands(false)) {
-            actions.unshift(`command_args) _command_args ;;`);
-        }
-        if (actions.length) {
-            return `\n\n  case "$state" in\n    ${actions.join("\n    ")}\n  esac`;
-        }
-        return "";
-    }
-}
-function replaceSpecialChars(str) {
-    return str.replace(/[^a-zA-Z0-9]/g, "_");
-}