track-cli 3.0.0-rc

package/esm/deps/deno.land/x/cliffy@v0.25.7/command/upgrade/provider/github.js

@@ -0,0 +1,118 @@
+import * as dntShim from "../../../../../../../_dnt.shims.js";
+import { Provider } from "../provider.js";
+import { bold, brightBlue } from "../../deps.js";
+export class GithubProvider extends Provider {
+    constructor({ repository, branches = true, token }) {
+        super();
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "github"
+        });
+        Object.defineProperty(this, "repositoryUrl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "https://github.com/"
+        });
+        Object.defineProperty(this, "registryUrl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "https://raw.githubusercontent.com/"
+        });
+        Object.defineProperty(this, "apiUrl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "https://api.github.com/repos/"
+        });
+        Object.defineProperty(this, "repositoryName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "listBranches", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "githubToken", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.repositoryName = repository;
+        this.listBranches = branches;
+        this.githubToken = token;
+    }
+    async getVersions(_name) {
+        const [tags, branches] = await Promise.all([
+            this.gitFetch("git/refs/tags"),
+            this.gitFetch("branches"),
+        ]);
+        const tagNames = tags
+            .map((tag) => tag.ref.replace(/^refs\/tags\//, ""))
+            .reverse();
+        const branchNames = branches
+            .sort((a, b) => (a.protected === b.protected) ? 0 : (a.protected ? 1 : -1))
+            .map((tag) => `${tag.name} ${tag.protected ? `(${bold("Protected")})` : ""}`)
+            .reverse();
+        return {
+            versions: [
+                ...tagNames,
+                ...branchNames,
+            ],
+            latest: tagNames[0],
+            tags: tagNames,
+            branches: branchNames,
+        };
+    }
+    getRepositoryUrl(_name) {
+        return new URL(`${this.repositoryName}/`, this.repositoryUrl).href;
+    }
+    getRegistryUrl(_name, version) {
+        return new URL(`${this.repositoryName}/${version}/`, this.registryUrl).href;
+    }
+    async listVersions(name, currentVersion) {
+        const { tags, branches } = await this.getVersions(name);
+        const showBranches = !!this.listBranches && branches.length > 0;
+        const indent = showBranches ? 2 : 0;
+        if (showBranches) {
+            console.log("\n" + " ".repeat(indent) + bold(brightBlue("Tags:\n")));
+        }
+        super.printVersions(tags, currentVersion, { indent });
+        if (showBranches) {
+            console.log("\n" + " ".repeat(indent) + bold(brightBlue("Branches:\n")));
+            super.printVersions(branches, currentVersion, { maxCols: 5, indent });
+            console.log();
+        }
+    }
+    getApiUrl(endpoint) {
+        return new URL(`${this.repositoryName}/${endpoint}`, this.apiUrl).href;
+    }
+    async gitFetch(endpoint) {
+        const headers = new dntShim.Headers({ "Content-Type": "application/json" });
+        if (this.githubToken) {
+            headers.set("Authorization", this.githubToken ? `token ${this.githubToken}` : "");
+        }
+        const response = await dntShim.fetch(this.getApiUrl(endpoint), {
+            method: "GET",
+            cache: "default",
+            headers,
+        });
+        if (!response.status) {
+            throw new Error("couldn't fetch versions - try again after sometime");
+        }
+        const data = await response.json();
+        if (typeof data === "object" && "message" in data &&
+            "documentation_url" in data) {
+            throw new Error(data.message + " " + data.documentation_url);
+        }
+        return data;
+    }
+}

package/esm/deps/deno.land/x/cliffy@v0.25.7/command/upgrade/provider/nest_land.d.ts

@@ -0,0 +1,14 @@
+import { Provider, Versions } from "../provider.js";
+export interface NestLandProviderOptions {
+    name?: string;
+}
+export declare class NestLandProvider extends Provider {
+    name: string;
+    private readonly repositoryUrl;
+    private readonly registryUrl;
+    private readonly moduleName?;
+    constructor({ name }?: NestLandProviderOptions);
+    getVersions(name: string): Promise<Versions>;
+    getRepositoryUrl(name: string): string;
+    getRegistryUrl(name: string, version: string): string;
+}

package/esm/deps/deno.land/x/cliffy@v0.25.7/command/upgrade/provider/nest_land.js

@@ -0,0 +1,55 @@
+import * as dntShim from "../../../../../../../_dnt.shims.js";
+import { Provider } from "../provider.js";
+export class NestLandProvider extends Provider {
+    constructor({ name } = {}) {
+        super();
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "nest.land"
+        });
+        Object.defineProperty(this, "repositoryUrl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "https://nest.land/package/"
+        });
+        Object.defineProperty(this, "registryUrl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "https://x.nest.land/"
+        });
+        Object.defineProperty(this, "moduleName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.moduleName = name;
+    }
+    async getVersions(name) {
+        const response = await dntShim.fetch(`https://nest.land/api/package-client`, {
+            method: "post",
+            body: JSON.stringify({ data: { name: this.moduleName ?? name } }),
+            headers: { "Content-Type": "application/json" },
+        });
+        if (!response.ok) {
+            throw new Error("couldn't fetch the latest version - try again after sometime");
+        }
+        const { body: { latestVersion, packageUploadNames } } = await response
+            .json();
+        return {
+            latest: latestVersion,
+            versions: packageUploadNames.map((version) => version.replace(new RegExp(`^${this.moduleName ?? name}@`), "")).reverse(),
+        };
+    }
+    getRepositoryUrl(name) {
+        return new URL(`${this.moduleName ?? name}/`, this.repositoryUrl).href;
+    }
+    getRegistryUrl(name, version) {
+        return new URL(`${this.moduleName ?? name}@${version}/`, this.registryUrl)
+            .href;
+    }
+}

package/esm/deps/deno.land/x/cliffy@v0.25.7/command/upgrade/provider.d.ts

@@ -0,0 +1,27 @@
+export interface Versions {
+    latest: string;
+    versions: Array<string>;
+}
+export interface UpgradeOptions {
+    name: string;
+    from?: string;
+    to: string;
+    args?: Array<string>;
+    main?: string;
+    importMap?: string;
+}
+export declare abstract class Provider {
+    abstract readonly name: string;
+    protected readonly maxListSize: number;
+    private maxCols;
+    abstract getVersions(name: string): Promise<Versions>;
+    abstract getRepositoryUrl(name: string): string;
+    abstract getRegistryUrl(name: string, version: string): string;
+    isOutdated(name: string, currentVersion: string, targetVersion: string): Promise<boolean>;
+    upgrade({ name, from, to, importMap, main, args }: UpgradeOptions): Promise<void>;
+    listVersions(name: string, currentVersion?: string): Promise<void>;
+    protected printVersions(versions: Array<string>, currentVersion?: string, { maxCols, indent }?: {
+        maxCols?: number;
+        indent?: number;
+    }): void;
+}

package/esm/deps/deno.land/x/cliffy@v0.25.7/command/upgrade/provider.js

@@ -0,0 +1,102 @@
+import * as dntShim from "../../../../../../_dnt.shims.js";
+import { bold, brightBlue, cyan, green, red, yellow } from "../deps.js";
+import { ValidationError } from "../_errors.js";
+import { Table } from "../../table/table.js";
+export class Provider {
+    constructor() {
+        Object.defineProperty(this, "maxListSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 25
+        });
+        Object.defineProperty(this, "maxCols", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 8
+        });
+    }
+    async isOutdated(name, currentVersion, targetVersion) {
+        const { latest, versions } = await this.getVersions(name);
+        if (targetVersion === "latest") {
+            targetVersion = latest;
+        }
+        // Check if requested version exists.
+        if (targetVersion && !versions.includes(targetVersion)) {
+            throw new ValidationError(`The provided version ${bold(red(targetVersion))} is not found.\n\n    ${cyan(`Visit ${brightBlue(this.getRepositoryUrl(name))} for available releases or run again with the ${(yellow("-l"))} or ${(yellow("--list-versions"))} command.`)}`);
+        }
+        // Check if requested version is already the latest available version.
+        if (latest && latest === currentVersion && latest === targetVersion) {
+            console.warn(yellow(`You're already using the latest available version ${currentVersion} of ${name}.`));
+            return false;
+        }
+        // Check if requested version is already installed.
+        if (targetVersion && currentVersion === targetVersion) {
+            console.warn(yellow(`You're already using version ${currentVersion} of ${name}.`));
+            return false;
+        }
+        return true;
+    }
+    async upgrade({ name, from, to, importMap, main = `${name}.ts`, args = [] }) {
+        if (to === "latest") {
+            const { latest } = await this.getVersions(name);
+            to = latest;
+        }
+        const registry = new URL(main, this.getRegistryUrl(name, to)).href;
+        const cmd = [dntShim.Deno.execPath(), "install"];
+        if (importMap) {
+            const importJson = new URL(importMap, this.getRegistryUrl(name, to)).href;
+            cmd.push("--import-map", importJson);
+        }
+        if (args.length) {
+            cmd.push(...args, "--force", "--name", name, registry);
+        }
+        else {
+            cmd.push("--no-check", "--quiet", "--force", "--name", name, registry);
+        }
+        const process = dntShim.Deno.run({ cmd, stdout: "piped", stderr: "piped" });
+        const [status, stderr] = await Promise.all([
+            process.status(),
+            process.stderrOutput(),
+            process.output(),
+        ]);
+        if (!status.success) {
+            process.close();
+            await dntShim.Deno.stderr.write(stderr);
+            throw new Error(`Failed to upgrade ${name} from ${from} to version ${to}!`);
+        }
+        process.close();
+        console.info(`Successfully upgraded ${name} from ${from} to version ${to}! (${this.getRegistryUrl(name, to)})`);
+    }
+    async listVersions(name, currentVersion) {
+        const { versions } = await this.getVersions(name);
+        this.printVersions(versions, currentVersion);
+    }
+    printVersions(versions, currentVersion, { maxCols = this.maxCols, indent = 0 } = {}) {
+        versions = versions.slice();
+        if (versions?.length) {
+            versions = versions.map((version) => currentVersion && currentVersion === version
+                ? green(`* ${version}`)
+                : `  ${version}`);
+            if (versions.length > this.maxListSize) {
+                const table = new Table().indent(indent);
+                const rowSize = Math.ceil(versions.length / maxCols);
+                const colSize = Math.min(versions.length, maxCols);
+                let versionIndex = 0;
+                for (let colIndex = 0; colIndex < colSize; colIndex++) {
+                    for (let rowIndex = 0; rowIndex < rowSize; rowIndex++) {
+                        if (!table[rowIndex]) {
+                            table[rowIndex] = [];
+                        }
+                        table[rowIndex][colIndex] = versions[versionIndex++];
+                    }
+                }
+                console.log(table.toString());
+            }
+            else {
+                console.log(versions.map((version) => " ".repeat(indent) + version).join("\n"));
+            }
+        }
+    }
+}

package/esm/deps/deno.land/x/cliffy@v0.25.7/command/upgrade/upgrade_command.d.ts

@@ -0,0 +1,17 @@
+import { Command } from "../command.js";
+import type { Provider, Versions } from "./provider.js";
+export interface UpgradeCommandOptions<TProvider extends Provider = Provider, TProviders extends TProvider | Array<TProvider> = TProvider | Array<TProvider>> {
+    provider: TProviders;
+    main?: string;
+    importMap?: string;
+    args?: Array<string>;
+}
+export declare class UpgradeCommand extends Command {
+    private readonly providers;
+    constructor({ provider, main, args, importMap }: UpgradeCommandOptions);
+    getAllVersions(): Promise<Array<string>>;
+    getLatestVersion(): Promise<string>;
+    getVersions(): Promise<Versions>;
+    private getProvider;
+    private getProviderNames;
+}

package/esm/deps/deno.land/x/cliffy@v0.25.7/command/upgrade/upgrade_command.js

@@ -0,0 +1,75 @@
+import * as dntShim from "../../../../../../_dnt.shims.js";
+import { Command } from "../command.js";
+import { ValidationError } from "../../flags/_errors.js";
+import { EnumType } from "../types/enum.js";
+export class UpgradeCommand extends Command {
+    constructor({ provider, main, args, importMap }) {
+        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());
+                dntShim.Deno.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.")
+            .complete("version", () => this.getAllVersions())
+            .action(async ({ registry, version: targetVersion, force }) => {
+            const name = this.getMainCommand().getName();
+            const currentVersion = this.getVersion();
+            if (force || !currentVersion ||
+                await registry.isOutdated(name, currentVersion, targetVersion)) {
+                await registry.upgrade({
+                    name,
+                    main,
+                    importMap,
+                    from: currentVersion,
+                    to: targetVersion,
+                    args,
+                });
+            }
+        });
+    }
+    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/deno.land/x/cliffy@v0.25.7/flags/_errors.d.ts

@@ -0,0 +1,60 @@
+import type { ArgumentValue, FlagOptions } from "./types.js";
+export declare class FlagsError extends Error {
+    constructor(message: string);
+}
+export declare class UnknownRequiredOptionError extends FlagsError {
+    constructor(option: string, options: Array<FlagOptions>);
+}
+export declare class UnknownConflictingOptionError extends FlagsError {
+    constructor(option: string, options: Array<FlagOptions>);
+}
+export declare class UnknownTypeError extends FlagsError {
+    constructor(type: string, types: Array<string>);
+}
+/**
+ * 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 declare class ValidationError extends FlagsError {
+    constructor(message: string);
+}
+export declare class DuplicateOptionError extends ValidationError {
+    constructor(name: string);
+}
+export declare class InvalidOptionError extends ValidationError {
+    constructor(option: string, options: Array<FlagOptions>);
+}
+export declare class UnknownOptionError extends ValidationError {
+    constructor(option: string, options: Array<FlagOptions>);
+}
+export declare class MissingOptionValueError extends ValidationError {
+    constructor(option: string);
+}
+export declare class InvalidOptionValueError extends ValidationError {
+    constructor(option: string, expected: string, value: string);
+}
+export declare class UnexpectedOptionValueError extends ValidationError {
+    constructor(option: string, value: string);
+}
+export declare class OptionNotCombinableError extends ValidationError {
+    constructor(option: string);
+}
+export declare class ConflictingOptionError extends ValidationError {
+    constructor(option: string, conflictingOption: string);
+}
+export declare class DependingOptionError extends ValidationError {
+    constructor(option: string, dependingOption: string);
+}
+export declare class MissingRequiredOptionError extends ValidationError {
+    constructor(option: string);
+}
+export declare class UnexpectedRequiredArgumentError extends ValidationError {
+    constructor(arg: string);
+}
+export declare class UnexpectedArgumentAfterVariadicArgumentError extends ValidationError {
+    constructor(arg: string);
+}
+export declare class InvalidTypeError extends ValidationError {
+    constructor({ label, name, value, type }: ArgumentValue, expected?: Array<string | number | boolean>);
+}

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

@@ -0,0 +1,117 @@
+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/deno.land/x/cliffy@v0.25.7/flags/_utils.d.ts

@@ -0,0 +1,18 @@
+import type { FlagOptions } from "./types.js";
+/** Convert param case string to camel case. */
+export declare function paramCaseToCamelCase(str: string): string;
+/** Convert underscore case string to camel case. */
+export declare function underscoreToCamelCase(str: string): string;
+/**
+ * Find option by flag, name or alias.
+ *
+ * @param flags Source options array.
+ * @param name  Name of the option.
+ */
+export declare function getOption<O extends FlagOptions>(flags: Array<O>, name: string): O | undefined;
+export declare function didYouMeanOption(option: string, options: Array<FlagOptions>): string;
+export declare function didYouMeanType(type: string, types: Array<string>): string;
+export declare function didYouMean(message: string, type: string, types: Array<string>): string;
+export declare function getFlag(name: string): string;
+export declare function matchWildCardOptions(name: string, flags: Array<FlagOptions>): FlagOptions | undefined;
+export declare function getDefaultValue(option: FlagOptions): unknown;