track-cli 3.0.0-rc

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

@@ -0,0 +1,106 @@
+import { distance } from "../_utils/distance.js";
+/** Convert param case string to camel case. */
+export function paramCaseToCamelCase(str) {
+    return str.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
+}
+/** 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());
+}
+/**
+ * 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 = closest(type, types);
+    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 closest(str, arr) {
+    let minDistance = Infinity;
+    let minIndex = 0;
+    for (let i = 0; i < arr.length; i++) {
+        const dist = distance(str, arr[i]);
+        if (dist < minDistance) {
+            minDistance = dist;
+            minIndex = i;
+        }
+    }
+    return arr[minIndex];
+}
+export function getDefaultValue(option) {
+    return typeof option.default === "function"
+        ? option.default()
+        : option.default;
+}

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

@@ -0,0 +1,10 @@
+import { ParseFlagsContext, ParseFlagsOptions } from "./types.js";
+import type { FlagOptions } from "./types.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 declare function validateFlags<T extends FlagOptions = FlagOptions>(ctx: ParseFlagsContext<Record<string, unknown>>, opts: ParseFlagsOptions<T>, options?: Map<string, FlagOptions>): void;

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

@@ -0,0 +1,157 @@
+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;
+    }
+    const defaultValues = setDefaultValues(ctx, opts);
+    const optionNames = Object.keys(ctx.flags);
+    if (!optionNames.length && opts.allowEmpty) {
+        return;
+    }
+    if (ctx.standalone) {
+        validateStandaloneOption(ctx, options, optionNames, defaultValues);
+        return;
+    }
+    for (const [name, option] of options) {
+        validateUnknownOption(option, opts);
+        validateConflictingOptions(ctx, option);
+        validateDependingOptions(ctx, option, defaultValues);
+        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) {
+    const defaultValues = {};
+    if (!opts.flags?.length) {
+        return defaultValues;
+    }
+    // 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;
+            defaultValues[option.name] = true;
+            if (typeof option.value === "function") {
+                ctx.flags[name] = option.value(ctx.flags[name]);
+            }
+        }
+    }
+    return defaultValues;
+}
+function validateStandaloneOption(ctx, options, optionNames, defaultValues) {
+    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 (!defaultValues[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, defaultValues) {
+    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) && !defaultValues[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.requiredValue) {
+            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/deno.land/x/cliffy@v0.25.7/flags/deprecated.d.ts

@@ -0,0 +1,24 @@
+import type { ArgumentOptions, ArgumentValue, DefaultValue, FlagOptions, ParseFlagsContext, ParseFlagsOptions, TypeHandler, ValueHandler } from "./types.js";
+/** @deprecated Use `ParseFlagsOptions` instead. */
+export type IParseOptions<TFlagOptions extends FlagOptions = FlagOptions> = ParseFlagsOptions<TFlagOptions>;
+/** @deprecated Use `FlagOptions` instead. */
+export type IFlagOptions = FlagOptions;
+/** @deprecated Use `ArgumentOptions` instead. */
+export type IFlagArgument = ArgumentOptions;
+/** @deprecated Use `DefaultValue` instead. */
+export type IDefaultValue<TValue = unknown> = DefaultValue<TValue>;
+/** @deprecated Use `ValueHandler` instead. */
+export type IFlagValueHandler<TValue = any, TReturn = TValue> = ValueHandler<TValue, TReturn>;
+/** @deprecated Use `ParseFlagsContext` instead. */
+export type IFlagsResult<TFlags extends Record<string, any> = Record<string, any>, TStandaloneOption extends FlagOptions = FlagOptions> = ParseFlagsContext<TFlags, TStandaloneOption>;
+/** @deprecated Use `ArgumentValue` instead. */
+export type ITypeInfo = ArgumentValue;
+/** @deprecated Use `TypeHandler` instead. */
+export type ITypeHandler<TReturn = unknown> = TypeHandler<TReturn>;
+/** @deprecated Use `ArgumentType` instead. */
+export declare enum OptionType {
+    STRING = "string",
+    NUMBER = "number",
+    INTEGER = "integer",
+    BOOLEAN = "boolean"
+}

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

@@ -0,0 +1,9 @@
+// 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 = {}));

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

@@ -0,0 +1,33 @@
+import type { FlagOptions, ParseFlagsContext, ParseFlagsOptions } from "./types.js";
+/**
+ * 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 declare function parseFlags<TFlags extends Record<string, unknown>, TFlagOptions extends FlagOptions, TFlagsResult extends ParseFlagsContext>(argsOrCtx: string[] | TFlagsResult, opts?: ParseFlagsOptions<TFlagOptions>): TFlagsResult & ParseFlagsContext<TFlags, TFlagOptions>;