track-cli 3.0.0-rc

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

@@ -0,0 +1,402 @@
+import { getDefaultValue, getOption, matchWildCardOptions, paramCaseToCamelCase, } from "./_utils.js";
+import { DuplicateOptionError, InvalidOptionError, InvalidOptionValueError, MissingOptionValueError, UnexpectedArgumentAfterVariadicArgumentError, UnexpectedOptionValueError, UnexpectedRequiredArgumentError, UnknownConflictingOptionError, UnknownOptionError, UnknownRequiredOptionError, UnknownTypeError, } from "./_errors.js";
+import { OptionType } from "./deprecated.js";
+import { boolean } from "./types/boolean.js";
+import { number } from "./types/number.js";
+import { string } from "./types/string.js";
+import { validateFlags } from "./_validate_flags.js";
+import { integer } from "./types/integer.js";
+const DefaultTypes = {
+    string,
+    number,
+    integer,
+    boolean,
+};
+/**
+ * Parse command line arguments.
+ * @param argsOrCtx Command line arguments e.g: `Deno.args` or parse context.
+ * @param opts      Parse options.
+ *
+ * ```
+ * // examples/flags/flags.ts -x 3 -y.z -n5 -abc --beep=boop foo bar baz --deno.land --deno.com -- --cliffy
+ * parseFlags(Deno.args);
+ * ```
+ *
+ * Output:
+ *
+ * ```
+ * {
+ *   flags: {
+ *     x: "3",
+ *     y: { z: true },
+ *     n: "5",
+ *     a: true,
+ *     b: true,
+ *     c: true,
+ *     beep: "boop",
+ *     deno: { land: true, com: true }
+ *   },
+ *   literal: [ "--cliffy" ],
+ *   unknown: [ "foo", "bar", "baz" ],
+ *   stopEarly: false,
+ *   stopOnUnknown: false
+ * }
+ * ```
+ */
+export function parseFlags(argsOrCtx, opts = {}) {
+    let args;
+    let ctx;
+    if (Array.isArray(argsOrCtx)) {
+        ctx = {};
+        args = argsOrCtx;
+    }
+    else {
+        ctx = argsOrCtx;
+        args = argsOrCtx.unknown;
+        argsOrCtx.unknown = [];
+    }
+    args = args.slice();
+    ctx.flags ??= {};
+    ctx.literal ??= [];
+    ctx.unknown ??= [];
+    ctx.stopEarly = false;
+    ctx.stopOnUnknown = false;
+    opts.dotted ??= true;
+    validateOptions(opts);
+    const options = parseArgs(ctx, args, opts);
+    validateFlags(ctx, opts, options);
+    if (opts.dotted) {
+        parseDottedOptions(ctx);
+    }
+    return ctx;
+}
+function validateOptions(opts) {
+    opts.flags?.forEach((opt) => {
+        opt.depends?.forEach((flag) => {
+            if (!opts.flags || !getOption(opts.flags, flag)) {
+                throw new UnknownRequiredOptionError(flag, opts.flags ?? []);
+            }
+        });
+        opt.conflicts?.forEach((flag) => {
+            if (!opts.flags || !getOption(opts.flags, flag)) {
+                throw new UnknownConflictingOptionError(flag, opts.flags ?? []);
+            }
+        });
+    });
+}
+function parseArgs(ctx, args, opts) {
+    /** Option name mapping: propertyName -> option.name */
+    const optionsMap = new Map();
+    let inLiteral = false;
+    for (let argsIndex = 0; argsIndex < args.length; argsIndex++) {
+        let option;
+        let current = args[argsIndex];
+        let currentValue;
+        let negate = false;
+        // literal args after --
+        if (inLiteral) {
+            ctx.literal.push(current);
+            continue;
+        }
+        else if (current === "--") {
+            inLiteral = true;
+            continue;
+        }
+        else if (ctx.stopEarly || ctx.stopOnUnknown) {
+            ctx.unknown.push(current);
+            continue;
+        }
+        const isFlag = current.length > 1 && current[0] === "-";
+        if (!isFlag) {
+            if (opts.stopEarly) {
+                ctx.stopEarly = true;
+            }
+            ctx.unknown.push(current);
+            continue;
+        }
+        const isShort = current[1] !== "-";
+        const isLong = isShort ? false : current.length > 3 && current[2] !== "-";
+        if (!isShort && !isLong) {
+            throw new InvalidOptionError(current, opts.flags ?? []);
+        }
+        // normalize short flags: -abc => -a -b -c
+        if (isShort && current.length > 2 && current[2] !== ".") {
+            args.splice(argsIndex, 1, ...splitFlags(current));
+            current = args[argsIndex];
+        }
+        else if (isLong && current.startsWith("--no-")) {
+            negate = true;
+        }
+        // split value: --foo="bar=baz" => --foo bar=baz
+        const equalSignIndex = current.indexOf("=");
+        if (equalSignIndex !== -1) {
+            currentValue = current.slice(equalSignIndex + 1) || undefined;
+            current = current.slice(0, equalSignIndex);
+        }
+        if (opts.flags) {
+            option = getOption(opts.flags, current);
+            if (!option) {
+                const name = current.replace(/^-+/, "");
+                option = matchWildCardOptions(name, opts.flags);
+                if (!option) {
+                    if (opts.stopOnUnknown) {
+                        ctx.stopOnUnknown = true;
+                        ctx.unknown.push(args[argsIndex]);
+                        continue;
+                    }
+                    throw new UnknownOptionError(current, opts.flags);
+                }
+            }
+        }
+        else {
+            option = {
+                name: current.replace(/^-+/, ""),
+                optionalValue: true,
+                type: OptionType.STRING,
+            };
+        }
+        if (option.standalone) {
+            ctx.standalone = option;
+        }
+        const positiveName = negate
+            ? option.name.replace(/^no-?/, "")
+            : option.name;
+        const propName = paramCaseToCamelCase(positiveName);
+        if (typeof ctx.flags[propName] !== "undefined") {
+            if (!opts.flags?.length) {
+                option.collect = true;
+            }
+            else if (!option.collect) {
+                throw new DuplicateOptionError(current);
+            }
+        }
+        if (option.type && !option.args?.length) {
+            option.args = [{
+                    type: option.type,
+                    requiredValue: option.requiredValue,
+                    optionalValue: option.optionalValue,
+                    variadic: option.variadic,
+                    list: option.list,
+                    separator: option.separator,
+                }];
+        }
+        if (opts.flags?.length && !option.args?.length &&
+            typeof currentValue !== "undefined") {
+            throw new UnexpectedOptionValueError(option.name, currentValue);
+        }
+        let optionArgsIndex = 0;
+        let inOptionalArg = false;
+        const next = () => currentValue ?? args[argsIndex + 1];
+        const previous = ctx.flags[propName];
+        parseNext(option);
+        if (typeof ctx.flags[propName] === "undefined") {
+            if (option.args?.[optionArgsIndex]?.requiredValue) {
+                throw new MissingOptionValueError(option.name);
+            }
+            else if (typeof option.default !== "undefined") {
+                ctx.flags[propName] = getDefaultValue(option);
+            }
+            else {
+                ctx.flags[propName] = true;
+            }
+        }
+        if (option.value) {
+            ctx.flags[propName] = option.value(ctx.flags[propName], previous);
+        }
+        else if (option.collect) {
+            const value = typeof previous !== "undefined"
+                ? (Array.isArray(previous) ? previous : [previous])
+                : [];
+            value.push(ctx.flags[propName]);
+            ctx.flags[propName] = value;
+        }
+        optionsMap.set(propName, option);
+        opts.option?.(option, ctx.flags[propName]);
+        /** Parse next argument for current option. */
+        // deno-lint-ignore no-inner-declarations
+        function parseNext(option) {
+            if (negate) {
+                ctx.flags[propName] = false;
+                return;
+            }
+            else if (!option.args?.length) {
+                ctx.flags[propName] = undefined;
+                return;
+            }
+            const arg = option.args[optionArgsIndex];
+            if (!arg) {
+                const flag = next();
+                throw new UnknownOptionError(flag, opts.flags ?? []);
+            }
+            if (!arg.type) {
+                arg.type = OptionType.BOOLEAN;
+            }
+            if (option.args?.length && !option.type) {
+                // make all values required by default
+                if ((typeof arg.optionalValue === "undefined" ||
+                    arg.optionalValue === false) &&
+                    typeof arg.requiredValue === "undefined") {
+                    arg.requiredValue = true;
+                }
+            }
+            else {
+                // make non boolean value required by default
+                if (arg.type !== OptionType.BOOLEAN &&
+                    (typeof arg.optionalValue === "undefined" ||
+                        arg.optionalValue === false) &&
+                    typeof arg.requiredValue === "undefined") {
+                    arg.requiredValue = true;
+                }
+            }
+            if (!arg.requiredValue) {
+                inOptionalArg = true;
+            }
+            else if (inOptionalArg) {
+                throw new UnexpectedRequiredArgumentError(option.name);
+            }
+            let result;
+            let increase = false;
+            if (arg.list && hasNext(arg)) {
+                const parsed = next()
+                    .split(arg.separator || ",")
+                    .map((nextValue) => {
+                    const value = parseValue(option, arg, nextValue);
+                    if (typeof value === "undefined") {
+                        throw new InvalidOptionValueError(option.name, arg.type ?? "?", nextValue);
+                    }
+                    return value;
+                });
+                if (parsed?.length) {
+                    result = parsed;
+                }
+            }
+            else {
+                if (hasNext(arg)) {
+                    result = parseValue(option, arg, next());
+                }
+                else if (arg.optionalValue && arg.type === OptionType.BOOLEAN) {
+                    result = true;
+                }
+            }
+            if (increase && typeof currentValue === "undefined") {
+                argsIndex++;
+                if (!arg.variadic) {
+                    optionArgsIndex++;
+                }
+                else if (option.args[optionArgsIndex + 1]) {
+                    throw new UnexpectedArgumentAfterVariadicArgumentError(next());
+                }
+            }
+            if (typeof result !== "undefined" &&
+                (option.args.length > 1 || arg.variadic)) {
+                if (!ctx.flags[propName]) {
+                    ctx.flags[propName] = [];
+                }
+                ctx.flags[propName].push(result);
+                if (hasNext(arg)) {
+                    parseNext(option);
+                }
+            }
+            else {
+                ctx.flags[propName] = result;
+            }
+            /** Check if current option should have an argument. */
+            function hasNext(arg) {
+                if (!option.args?.length) {
+                    return false;
+                }
+                const nextValue = currentValue ?? args[argsIndex + 1];
+                if (!nextValue) {
+                    return false;
+                }
+                if (option.args.length > 1 && optionArgsIndex >= option.args.length) {
+                    return false;
+                }
+                if (arg.requiredValue) {
+                    return true;
+                }
+                // require optional values to be called with an equal sign: foo=bar
+                if (option.equalsSign && arg.optionalValue && !arg.variadic &&
+                    typeof currentValue === "undefined") {
+                    return false;
+                }
+                if (arg.optionalValue || arg.variadic) {
+                    return nextValue[0] !== "-" ||
+                        typeof currentValue !== "undefined" ||
+                        (arg.type === OptionType.NUMBER && !isNaN(Number(nextValue)));
+                }
+                return false;
+            }
+            /** Parse argument value.  */
+            function parseValue(option, arg, value) {
+                const result = opts.parse
+                    ? opts.parse({
+                        label: "Option",
+                        type: arg.type || OptionType.STRING,
+                        name: `--${option.name}`,
+                        value,
+                    })
+                    : parseDefaultType(option, arg, value);
+                if (typeof result !== "undefined") {
+                    increase = true;
+                }
+                return result;
+            }
+        }
+    }
+    return optionsMap;
+}
+function parseDottedOptions(ctx) {
+    // convert dotted option keys into nested objects
+    ctx.flags = Object.keys(ctx.flags).reduce((result, key) => {
+        if (~key.indexOf(".")) {
+            key.split(".").reduce((
+            // deno-lint-ignore no-explicit-any
+            result, subKey, index, parts) => {
+                if (index === parts.length - 1) {
+                    result[subKey] = ctx.flags[key];
+                }
+                else {
+                    result[subKey] = result[subKey] ?? {};
+                }
+                return result[subKey];
+            }, result);
+        }
+        else {
+            result[key] = ctx.flags[key];
+        }
+        return result;
+    }, {});
+}
+function splitFlags(flag) {
+    flag = flag.slice(1);
+    const normalized = [];
+    const index = flag.indexOf("=");
+    const flags = (index !== -1 ? flag.slice(0, index) : flag).split("");
+    if (isNaN(Number(flag[flag.length - 1]))) {
+        flags.forEach((val) => normalized.push(`-${val}`));
+    }
+    else {
+        normalized.push(`-${flags.shift()}`);
+        if (flags.length) {
+            normalized.push(flags.join(""));
+        }
+    }
+    if (index !== -1) {
+        normalized[normalized.length - 1] += flag.slice(index);
+    }
+    return normalized;
+}
+function parseDefaultType(option, arg, value) {
+    const type = arg.type || OptionType.STRING;
+    const parseType = DefaultTypes[type];
+    if (!parseType) {
+        throw new UnknownTypeError(type, Object.keys(DefaultTypes));
+    }
+    return parseType({
+        label: "Option",
+        type,
+        name: `--${option.name}`,
+        value,
+    });
+}

package/esm/deps/deno.land/x/cliffy@v0.25.7/flags/types/boolean.d.ts

@@ -0,0 +1,3 @@
+import type { TypeHandler } from "../types.js";
+/** Boolean type handler. Excepts `true`, `false`, `1`, `0` */
+export declare const boolean: TypeHandler<boolean>;

package/esm/deps/deno.land/x/cliffy@v0.25.7/flags/types/boolean.js

@@ -0,0 +1,11 @@
+import { InvalidTypeError } from "../_errors.js";
+/** Boolean type handler. Excepts `true`, `false`, `1`, `0` */
+export const boolean = (type) => {
+    if (~["1", "true"].indexOf(type.value)) {
+        return true;
+    }
+    if (~["0", "false"].indexOf(type.value)) {
+        return false;
+    }
+    throw new InvalidTypeError(type, ["true", "false", "1", "0"]);
+};

package/esm/deps/deno.land/x/cliffy@v0.25.7/flags/types/integer.d.ts

@@ -0,0 +1,3 @@
+import type { TypeHandler } from "../types.js";
+/** Integer type handler. Excepts any integer value. */
+export declare const integer: TypeHandler<number>;

package/esm/deps/deno.land/x/cliffy@v0.25.7/flags/types/integer.js

@@ -0,0 +1,9 @@
+import { InvalidTypeError } from "../_errors.js";
+/** Integer type handler. Excepts any integer value. */
+export const integer = (type) => {
+    const value = Number(type.value);
+    if (Number.isInteger(value)) {
+        return value;
+    }
+    throw new InvalidTypeError(type);
+};

package/esm/deps/deno.land/x/cliffy@v0.25.7/flags/types/number.d.ts

@@ -0,0 +1,3 @@
+import type { TypeHandler } from "../types.js";
+/** Number type handler. Excepts any numeric value. */
+export declare const number: TypeHandler<number>;

package/esm/deps/deno.land/x/cliffy@v0.25.7/flags/types/number.js

@@ -0,0 +1,9 @@
+import { InvalidTypeError } from "../_errors.js";
+/** Number type handler. Excepts any numeric value. */
+export const number = (type) => {
+    const value = Number(type.value);
+    if (Number.isFinite(value)) {
+        return value;
+    }
+    throw new InvalidTypeError(type);
+};

package/esm/deps/deno.land/x/cliffy@v0.25.7/flags/types/string.d.ts

@@ -0,0 +1,3 @@
+import type { TypeHandler } from "../types.js";
+/** String type handler. Excepts any value. */
+export declare const string: TypeHandler<string>;

package/esm/deps/deno.land/x/cliffy@v0.25.7/flags/types/string.js

@@ -0,0 +1,4 @@
+/** String type handler. Excepts any value. */
+export const string = ({ value }) => {
+    return value;
+};

package/esm/deps/deno.land/x/cliffy@v0.25.7/flags/types.d.ts

@@ -0,0 +1,59 @@
+/** Parser options. */
+export interface ParseFlagsOptions<TFlagOptions extends FlagOptions = FlagOptions> {
+    flags?: Array<TFlagOptions>;
+    parse?: TypeHandler<unknown>;
+    option?: (option: TFlagOptions, value?: unknown) => void;
+    stopEarly?: boolean;
+    stopOnUnknown?: boolean;
+    allowEmpty?: boolean;
+    ignoreDefaults?: Record<string, unknown>;
+    dotted?: boolean;
+}
+/** Flag options. */
+export interface FlagOptions extends ArgumentOptions {
+    name: string;
+    args?: ArgumentOptions[];
+    aliases?: string[];
+    standalone?: boolean;
+    default?: DefaultValue;
+    required?: boolean;
+    depends?: string[];
+    conflicts?: string[];
+    value?: ValueHandler;
+    collect?: boolean;
+    equalsSign?: boolean;
+}
+/** Flag argument definition. */
+export interface ArgumentOptions {
+    type?: ArgumentType | string;
+    optionalValue?: boolean;
+    requiredValue?: boolean;
+    variadic?: boolean;
+    list?: boolean;
+    separator?: string;
+}
+/** Available build-in argument types. */
+export type ArgumentType = "string" | "boolean" | "number" | "integer";
+/** Default flag value */
+export type DefaultValue<TValue = unknown> = TValue | DefaultValueHandler<TValue>;
+export type DefaultValueHandler<TValue = unknown> = () => TValue;
+/** Value handler for custom value processing. */
+export type ValueHandler<TValue = any, TReturn = TValue> = (val: TValue, previous?: TReturn) => TReturn;
+/** Result of the parseFlags method. */
+export interface ParseFlagsContext<TFlags extends Record<string, any> = Record<string, any>, TStandaloneOption extends FlagOptions = FlagOptions> {
+    flags: TFlags;
+    unknown: Array<string>;
+    literal: Array<string>;
+    standalone?: TStandaloneOption;
+    stopEarly: boolean;
+    stopOnUnknown: boolean;
+}
+/** Type details. */
+export interface ArgumentValue {
+    label: string;
+    type: string;
+    name: string;
+    value: string;
+}
+/** Custom type handler/parser. */
+export type TypeHandler<TReturn = unknown> = (arg: ArgumentValue) => TReturn;

package/esm/deps/deno.land/x/cliffy@v0.25.7/flags/types.js

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

package/esm/deps/deno.land/x/cliffy@v0.25.7/table/border.d.ts

@@ -0,0 +1,20 @@
+/** Border characters interface. */
+export interface IBorder {
+    top: string;
+    topMid: string;
+    topLeft: string;
+    topRight: string;
+    bottom: string;
+    bottomMid: string;
+    bottomLeft: string;
+    bottomRight: string;
+    left: string;
+    leftMid: string;
+    mid: string;
+    midMid: string;
+    right: string;
+    rightMid: string;
+    middle: string;
+}
+/** Default border characters. */
+export declare const border: IBorder;

package/esm/deps/deno.land/x/cliffy@v0.25.7/table/border.js

@@ -0,0 +1,18 @@
+/** Default border characters. */
+export const border = {
+    top: "─",
+    topMid: "┬",
+    topLeft: "┌",
+    topRight: "┐",
+    bottom: "─",
+    bottomMid: "┴",
+    bottomLeft: "└",
+    bottomRight: "┘",
+    left: "│",
+    leftMid: "├",
+    mid: "─",
+    midMid: "┼",
+    right: "│",
+    rightMid: "┤",
+    middle: "│",
+};

package/esm/deps/deno.land/x/cliffy@v0.25.7/table/cell.d.ts

@@ -0,0 +1,78 @@
+/** Cell type */
+export type ICell = number | string | String | Cell;
+export type Direction = "left" | "right" | "center";
+/** Cell options. */
+export interface ICellOptions {
+    border?: boolean;
+    colSpan?: number;
+    rowSpan?: number;
+    align?: Direction;
+}
+/** Cell representation. */
+export declare class Cell {
+    private value;
+    protected options: ICellOptions;
+    /** Get cell length. */
+    get length(): number;
+    /**
+     * Create a new cell. If value is a cell, the value and all options of the cell
+     * will be copied to the new cell.
+     * @param value Cell or cell value.
+     */
+    static from(value: ICell): Cell;
+    /**
+     * Cell constructor.
+     * @param value Cell value.
+     */
+    constructor(value: ICell);
+    /** Get cell value. */
+    toString(): string;
+    /**
+     * Set cell value.
+     * @param value Cell or cell value.
+     */
+    setValue(value: ICell): this;
+    /**
+     * Clone cell with all options.
+     * @param value Cell or cell value.
+     */
+    clone(value?: ICell): Cell;
+    /**
+     * Setter:
+     */
+    /**
+     * Enable/disable cell border.
+     * @param enable    Enable/disable cell border.
+     * @param override  Override existing value.
+     */
+    border(enable: boolean, override?: boolean): this;
+    /**
+     * Set col span.
+     * @param span      Number of cols to span.
+     * @param override  Override existing value.
+     */
+    colSpan(span: number, override?: boolean): this;
+    /**
+     * Set row span.
+     * @param span      Number of rows to span.
+     * @param override  Override existing value.
+     */
+    rowSpan(span: number, override?: boolean): this;
+    /**
+     * Align cell content.
+     * @param direction Align direction.
+     * @param override  Override existing value.
+     */
+    align(direction: Direction, override?: boolean): this;
+    /**
+     * Getter:
+     */
+    /** Check if cell has border. */
+    getBorder(): boolean;
+    /** Get col span. */
+    getColSpan(): number;
+    /** Get row span. */
+    getRowSpan(): number;
+    /** Get row span. */
+    getAlign(): Direction;
+}