avo-cli 0.0.3 → 4.2.0.beta.1

data/payload/node_modules/@oclif/core/lib/interfaces/pjson.d.ts

@@ -0,0 +1,314 @@
+import { HelpOptions } from './help';
+import { Theme } from './theme';
+export type CommandDiscovery = {
+    /**
+     * The strategy to use for loading commands.
+     *
+     * - `pattern` will use glob patterns to find command files in the specified `target`.
+     * - `explicit` will use `import` (or `require` for CJS) to load the commands from the
+     *    specified `target`.
+     * - `single` will use the `target` which should export a command class. This is for CLIs that
+     *    only have a single command.
+     *
+     * In both cases, the `oclif.manifest.json` file will be used to find the commands if it exists.
+     */
+    strategy: 'pattern' | 'explicit' | 'single';
+    /**
+     * If the `strategy` is `pattern`, this is the **directory** to use to find command files.
+     *
+     * If the `strategy` is `explicit`, this is the **file** that exports the commands.
+     *   - This export must be an object with keys that are the command names and values that are the command classes.
+     *   - Unless `identifier` is specified, the default export will be used.
+     *
+     * @example
+     * ```typescript
+     * // in src/commands.ts
+     * import {Command} from '@oclif/core'
+     * import Hello from './commands/hello/index.js'
+     * import HelloWorld from './commands/hello/world.js'
+     *
+     * export default {
+     *   hello: Hello,
+     *   'hello:world': HelloWorld,
+     * } satisfies Record<string, Command.Class>
+     * ```
+     */
+    target: string;
+    /**
+     * The glob patterns to use to find command files when no `oclif.manifest.json` is present.
+     * This is only used when `strategy` is `pattern`.
+     */
+    globPatterns?: string[];
+    /**
+     * The name of the export to used when loading the command object from the `target` file. Only
+     * used when `strategy` is `explicit`. Defaults to `default`.
+     *
+     * @example
+     * ```typescript
+     * // in src/commands.ts
+     * import {Command} from '@oclif/core'
+     * import Hello from './commands/hello/index.js'
+     * import HelloWorld from './commands/hello/world.js'
+     *
+     * export const MY_COMMANDS = {
+     *  hello: Hello,
+     * 'hello:world': HelloWorld,
+     * } satisfies Record<string, Command.Class>
+     * ```
+     *
+     * In the package.json:
+     * ```json
+     * {
+     *  "oclif": {
+     *   "commands": {
+     *     "strategy": "explicit",
+     *     "target": "./dist/index.js",
+     *     "identifier": "MY_COMMANDS"
+     *    }
+     * }
+     * ```
+     */
+    identifier?: string;
+};
+export type HookOptions = {
+    /**
+     * The file path containing hook.
+     */
+    target: string;
+    /**
+     * The name of the export to use when loading the hook function from the `target` file. Defaults to `default`.
+     */
+    identifier: string;
+};
+export type HelpLocationOptions = {
+    /**
+     * The file path containing help class.
+     */
+    target: string;
+    /**
+     * The name of the export to use when loading the help class from the `target` file. Defaults to `default`.
+     */
+    identifier: string;
+};
+export type S3Templates = {
+    baseDir?: string;
+    manifest?: string;
+    unversioned?: string;
+    versioned?: string;
+};
+export type S3 = {
+    acl?: string | undefined;
+    bucket?: string | undefined;
+    folder?: string | undefined;
+    gz?: boolean | undefined;
+    host?: string | undefined;
+    indexVersionLimit?: number | undefined;
+    templates?: {
+        target: S3Templates;
+        vanilla: S3Templates;
+    } | undefined;
+    xz?: boolean | undefined;
+};
+export type OclifConfiguration = {
+    /**
+     * Flags in addition to --help that should trigger help output.
+     */
+    additionalHelpFlags?: string[];
+    /**
+     * Flags in addition to --version that should trigger version output.
+     */
+    additionalVersionFlags?: string[];
+    /**
+     * Plugin aliases.
+     */
+    aliases?: {
+        [name: string]: null | string;
+    };
+    /**
+     * The name of the executable.
+     */
+    bin?: string;
+    /**
+     * Aliases for the executable.
+     */
+    binAliases?: string[];
+    commands?: string | CommandDiscovery;
+    /**
+     * Your CLI's description. Overrides the description in the package.json.
+     */
+    description?: string | undefined;
+    /**
+     * Plugins to load when in development mode.
+     */
+    devPlugins?: string[];
+    /**
+     * The directory name to use when determining the cache, config, and data directories.
+     */
+    dirname?: string;
+    /**
+     * Example plugin to use in @oclif/plugin-plugin's help output.
+     */
+    examplePlugin?: string;
+    /**
+     * Customize the exit codes for the CLI.
+     */
+    exitCodes?: {
+        default?: number;
+        failedFlagParsing?: number;
+        failedFlagValidation?: number;
+        violatedFlagConstraint?: number;
+        invalidArgsSpec?: number;
+        nonExistentFlag?: number;
+        requiredArgs?: number;
+        unexpectedArgs?: number;
+    };
+    /**
+     * Enable flexible taxonomy for commands.
+     */
+    flexibleTaxonomy?: boolean;
+    /**
+     * The location of your custom help class.
+     */
+    helpClass?: string | HelpLocationOptions;
+    /**
+     * Options for the help output.
+     */
+    helpOptions?: HelpOptions;
+    /**
+     * Register hooks to run at various points in the CLI lifecycle.
+     */
+    hooks?: {
+        [name: string]: string | string[] | HookOptions | HookOptions[] | (string | HookOptions)[];
+    };
+    /**
+     * Plugins that can be installed just-in-time.
+     */
+    jitPlugins?: Record<string, string>;
+    macos?: {
+        identifier?: string;
+        sign?: string;
+    };
+    /**
+     * Use a private or alternate npm registry.
+     */
+    npmRegistry?: string;
+    /**
+     * Script to run during postinstall on windows.
+     */
+    nsisCustomization?: string;
+    /**
+     * Plugin prefix to use when working with plugins with @oclif/plugin-plugins.
+     *
+     * Defaults to `plugin-`.
+     */
+    pluginPrefix?: string;
+    /**
+     * Plugins to load.
+     */
+    plugins?: string[];
+    /**
+     * Template string used to build links to source code in CLI's README (when using `oclif readme`).
+     */
+    repositoryPrefix?: string;
+    schema?: number;
+    /**
+     * The namespace to be used for plugins of your CLI, e.g. `@salesforce`.
+     */
+    scope?: string;
+    /**
+     * State of your CLI
+     *
+     * - `beta` - will show message to user that command or CLI is in beta
+     * - `deprecated` - will show message to user that command or CLI is deprecated
+     */
+    state?: 'beta' | 'deprecated' | string;
+    /**
+     * The theme to ship with the CLI.
+     *
+     * Can be a path to a JSON file or a Theme object.
+     */
+    theme?: string | Theme;
+    /**
+     * Separator to use for your CLI. Can be `:` or ` `.
+     */
+    topicSeparator?: ' ' | ':';
+    /**
+     * Customize the topics in the CLI.
+     */
+    topics?: {
+        [k: string]: {
+            description?: string;
+            hidden?: boolean;
+            subtopics?: OclifConfiguration['topics'];
+        };
+    };
+    /**
+     * Tar flags configuration for different platforms.
+     *
+     * {
+     *  "tarFlags": {
+     *   "win32": "--force-local",
+     *   "darwin": "--no-xattrs"
+     *  }
+     * }
+     *
+     */
+    tarFlags?: {
+        [platform: string]: string;
+    };
+    update?: {
+        autoupdate?: {
+            debounce?: number;
+            rollout?: number;
+        };
+        disableNpmLookup?: boolean;
+        node?: {
+            targets?: string[];
+            version?: string;
+            options?: string | string[];
+        };
+        s3?: S3;
+    };
+    'warn-if-update-available'?: {
+        authorization?: string;
+        message?: string;
+        registry?: string;
+        timeoutInDays?: number;
+        frequency?: number;
+        frequencyUnit?: 'days' | 'hours' | 'minutes' | 'seconds' | 'milliseconds';
+    };
+    windows?: {
+        homepage?: string;
+        keypath?: string;
+        name?: string;
+    };
+};
+export type UserPlugin = {
+    name: string;
+    tag?: string;
+    type: 'user';
+    url?: string;
+};
+export type LinkedPlugin = {
+    name: string;
+    root: string;
+    type: 'link';
+};
+export type UserPJSON = {
+    oclif: {
+        plugins?: (UserPlugin | LinkedPlugin)[];
+    };
+    private?: boolean;
+};
+export type PJSON = {
+    [k: string]: any;
+    dependencies?: {
+        [name: string]: string;
+    };
+    devDependencies?: {
+        [name: string]: string;
+    };
+    name: string;
+    oclif: OclifConfiguration;
+    version: string;
+};

data/payload/node_modules/@oclif/core/lib/interfaces/pjson.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

data/payload/node_modules/@oclif/core/lib/interfaces/plugin.d.ts

@@ -0,0 +1,104 @@
+import { Command } from '../command';
+import { Logger } from './logger';
+import { HookOptions, PJSON } from './pjson';
+import { Topic } from './topic';
+export interface PluginOptions {
+    children?: Plugin[] | undefined;
+    errorOnManifestCreate?: boolean | undefined;
+    flexibleTaxonomy?: boolean | undefined;
+    ignoreManifest?: boolean | undefined;
+    isRoot?: boolean | undefined;
+    name?: string | undefined;
+    parent?: Plugin | undefined;
+    pjson?: PJSON | undefined;
+    respectNoCacheDefault?: boolean | undefined;
+    root: string;
+    tag?: string | undefined;
+    type?: string | undefined;
+    url?: string | undefined;
+}
+export interface Options extends PluginOptions {
+    channel?: string | undefined;
+    devPlugins?: boolean | undefined;
+    enablePerf?: boolean | undefined;
+    jitPlugins?: boolean | undefined;
+    logger?: Logger | undefined;
+    pjson?: PJSON | undefined;
+    pluginAdditions?: {
+        core?: string[];
+        dev?: string[];
+        path?: string;
+    } | undefined;
+    plugins?: Map<string, Plugin> | undefined;
+    userPlugins?: boolean | undefined;
+    version?: string | undefined;
+}
+export interface Plugin {
+    /**
+     * ../config version
+     */
+    _base: string;
+    /**
+     * aliases from package.json dependencies
+     */
+    alias: string;
+    readonly commandIDs: string[];
+    commands: Command.Loadable[];
+    readonly commandsDir: string | undefined;
+    findCommand(id: string, opts: {
+        must: true;
+    }): Promise<Command.Class>;
+    findCommand(id: string, opts?: {
+        must: boolean;
+    }): Promise<Command.Class> | undefined;
+    readonly hasManifest: boolean;
+    hooks: {
+        [key: string]: HookOptions[];
+    };
+    /**
+     * True if the plugin is the root plugin.
+     */
+    isRoot: boolean;
+    load(): Promise<void>;
+    /**
+     * Plugin is written in ESM or CommonJS
+     */
+    moduleType: 'commonjs' | 'module';
+    /**
+     * name from package.json
+     */
+    name: string;
+    readonly options: Options;
+    parent?: Plugin | undefined;
+    /**
+     * full package.json
+     *
+     * parsed with read-pkg
+     */
+    pjson: PJSON;
+    /**
+     * base path of plugin
+     */
+    root: string;
+    /**
+     * npm dist-tag of plugin
+     * only used for user plugins
+     */
+    tag?: string | undefined;
+    readonly topics: Topic[];
+    /**
+     * used to tell the user how the plugin was installed
+     * examples: core, link, user, dev
+     */
+    type: string;
+    /**
+     * if it appears to be an npm package but does not look like it's really a CLI plugin, this is set to false
+     */
+    valid: boolean;
+    /**
+     * version from package.json
+     *
+     * example: 1.2.3
+     */
+    version: string;
+}

data/payload/node_modules/@oclif/core/lib/interfaces/plugin.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

data/payload/node_modules/@oclif/core/lib/interfaces/s3-manifest.d.ts

@@ -0,0 +1,14 @@
+export interface S3Manifest {
+    baseDir: string;
+    gz: string;
+    node: {
+        compatible: string;
+        recommended: string;
+    };
+    rollout?: number;
+    sha: string;
+    sha256gz: string;
+    sha256xz?: string;
+    version: string;
+    xz?: string;
+}

data/payload/node_modules/@oclif/core/lib/interfaces/s3-manifest.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

data/payload/node_modules/@oclif/core/lib/interfaces/theme.d.ts

@@ -0,0 +1,32 @@
+export declare const STANDARD_ANSI: readonly ["white", "black", "blue", "yellow", "green", "red", "magenta", "cyan", "gray", "blackBright", "redBright", "greenBright", "yellowBright", "blueBright", "magentaBright", "cyanBright", "whiteBright", "bgBlack", "bgRed", "bgGreen", "bgYellow", "bgBlue", "bgMagenta", "bgCyan", "bgWhite", "bgGray", "bgBlackBright", "bgRedBright", "bgGreenBright", "bgYellowBright", "bgBlueBright", "bgMagentaBright", "bgCyanBright", "bgWhiteBright", "bold", "underline", "dim", "italic", "strikethrough"];
+export type StandardAnsi = (typeof STANDARD_ANSI)[number];
+export type JsonTheme = {
+    brace?: string | StandardAnsi;
+    bracket?: string | StandardAnsi;
+    colon?: string | StandardAnsi;
+    comma?: string | StandardAnsi;
+    key?: string | StandardAnsi;
+    string?: string | StandardAnsi;
+    number?: string | StandardAnsi;
+    boolean?: string | StandardAnsi;
+    null?: string | StandardAnsi;
+};
+export type Theme = {
+    [key: string]: string | StandardAnsi | Theme | undefined;
+    alias?: string | StandardAnsi;
+    bin?: string | StandardAnsi;
+    command?: string | StandardAnsi;
+    commandSummary?: string | StandardAnsi;
+    dollarSign?: string | StandardAnsi;
+    flag?: string | StandardAnsi;
+    flagDefaultValue?: string | StandardAnsi;
+    flagOptions?: string | StandardAnsi;
+    flagRequired?: string | StandardAnsi;
+    flagSeparator?: string | StandardAnsi;
+    json?: JsonTheme;
+    sectionDescription?: string | StandardAnsi;
+    sectionHeader?: string | StandardAnsi;
+    spinner?: string | StandardAnsi;
+    topic?: string | StandardAnsi;
+    version?: string | StandardAnsi;
+};

data/payload/node_modules/@oclif/core/lib/interfaces/theme.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STANDARD_ANSI = void 0;
+exports.STANDARD_ANSI = [
+    'white',
+    'black',
+    'blue',
+    'yellow',
+    'green',
+    'red',
+    'magenta',
+    'cyan',
+    'gray',
+    'blackBright',
+    'redBright',
+    'greenBright',
+    'yellowBright',
+    'blueBright',
+    'magentaBright',
+    'cyanBright',
+    'whiteBright',
+    'bgBlack',
+    'bgRed',
+    'bgGreen',
+    'bgYellow',
+    'bgBlue',
+    'bgMagenta',
+    'bgCyan',
+    'bgWhite',
+    'bgGray',
+    'bgBlackBright',
+    'bgRedBright',
+    'bgGreenBright',
+    'bgYellowBright',
+    'bgBlueBright',
+    'bgMagentaBright',
+    'bgCyanBright',
+    'bgWhiteBright',
+    'bold',
+    'underline',
+    'dim',
+    'italic',
+    'strikethrough',
+];

data/payload/node_modules/@oclif/core/lib/interfaces/topic.d.ts

@@ -0,0 +1,5 @@
+export interface Topic {
+    description?: string | undefined;
+    hidden?: boolean | undefined;
+    name: string;
+}

data/payload/node_modules/@oclif/core/lib/interfaces/topic.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

data/payload/node_modules/@oclif/core/lib/interfaces/ts-config.d.ts

@@ -0,0 +1,23 @@
+export interface TSConfig {
+    compilerOptions: {
+        baseUrl?: string;
+        emitDecoratorMetadata?: boolean;
+        esModuleInterop?: boolean;
+        experimentalDecorators?: boolean;
+        jsx?: boolean;
+        module?: string;
+        moduleResolution?: string;
+        outDir?: string;
+        rootDir?: string;
+        rootDirs?: string[];
+        sourceMap?: boolean;
+        target?: string;
+    };
+    extends?: string;
+    'ts-node'?: {
+        esm?: boolean;
+        experimentalSpecifierResolution?: 'explicit' | 'node';
+        scope?: boolean;
+        swc?: boolean;
+    };
+}

data/payload/node_modules/@oclif/core/lib/interfaces/ts-config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

data/payload/node_modules/@oclif/core/lib/logger.d.ts

@@ -0,0 +1,14 @@
+import { LoadOptions } from './interfaces/config';
+import { Logger } from './interfaces/logger';
+/**
+ * Returns a logger instance for the given namespace.
+ * If a namespace is provided, a child logger is returned.
+ * If no namespace is provided, the root logger is returned.
+ */
+export declare function getLogger(namespace?: string): Logger;
+/**
+ * Convenience function to create a debug function for a specific namespace
+ */
+export declare function makeDebug(namespace: string): Logger['debug'];
+export declare function setLogger(loadOptions: LoadOptions): void;
+export declare function clearLoggers(): void;

data/payload/node_modules/@oclif/core/lib/logger.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLogger = getLogger;
+exports.makeDebug = makeDebug;
+exports.setLogger = setLogger;
+exports.clearLoggers = clearLoggers;
+const debug_1 = __importDefault(require("debug"));
+const OCLIF_NS = 'oclif';
+function makeLogger(namespace = OCLIF_NS) {
+    const debug = (0, debug_1.default)(namespace);
+    return {
+        child: (ns, delimiter) => makeLogger(`${namespace}${delimiter ?? ':'}${ns}`),
+        debug,
+        error: (formatter, ...args) => makeLogger(`${namespace}:error`).debug(formatter, ...args),
+        info: debug,
+        namespace,
+        trace: debug,
+        warn: debug,
+    };
+}
+/**
+ * Cache of logger instances. This is used to prevent creating multiple logger instances for the same namespace.
+ *
+ * The root logger is stored under the 'root' key as well as it's namespace.
+ */
+const cachedLoggers = new Map();
+/**
+ * Returns a logger instance for the given namespace.
+ * If a namespace is provided, a child logger is returned.
+ * If no namespace is provided, the root logger is returned.
+ */
+function getLogger(namespace) {
+    let rootLogger = cachedLoggers.get('root');
+    if (!rootLogger) {
+        set(makeLogger(OCLIF_NS));
+    }
+    rootLogger = cachedLoggers.get('root');
+    if (namespace) {
+        const cachedLogger = cachedLoggers.get(namespace);
+        if (cachedLogger)
+            return cachedLogger;
+        const logger = rootLogger.child(namespace);
+        cachedLoggers.set(namespace, logger);
+        return logger;
+    }
+    return rootLogger;
+}
+function ensureItMatchesInterface(newLogger) {
+    return (typeof newLogger.child === 'function' &&
+        typeof newLogger.debug === 'function' &&
+        typeof newLogger.error === 'function' &&
+        typeof newLogger.info === 'function' &&
+        typeof newLogger.trace === 'function' &&
+        typeof newLogger.warn === 'function' &&
+        typeof newLogger.namespace === 'string');
+}
+function set(newLogger) {
+    if (cachedLoggers.has(newLogger.namespace))
+        return;
+    if (cachedLoggers.has('root'))
+        return;
+    if (ensureItMatchesInterface(newLogger)) {
+        cachedLoggers.set(newLogger.namespace, newLogger);
+        cachedLoggers.set('root', newLogger);
+    }
+    else {
+        process.emitWarning('Logger does not match the Logger interface. Using default logger.');
+    }
+}
+/**
+ * Convenience function to create a debug function for a specific namespace
+ */
+function makeDebug(namespace) {
+    return (formatter, ...args) => getLogger(namespace).debug(formatter, ...args);
+}
+function setLogger(loadOptions) {
+    if (loadOptions && typeof loadOptions !== 'string' && 'logger' in loadOptions && loadOptions.logger) {
+        set(loadOptions.logger);
+    }
+    else {
+        set(makeLogger(OCLIF_NS));
+    }
+}
+function clearLoggers() {
+    cachedLoggers.clear();
+}

data/payload/node_modules/@oclif/core/lib/main.d.ts

@@ -0,0 +1,4 @@
+import * as Interfaces from './interfaces';
+export declare const helpAddition: (argv: string[], config: Interfaces.Config) => boolean;
+export declare const versionAddition: (argv: string[], config?: Interfaces.Config) => boolean;
+export declare function run(argv?: string[], options?: Interfaces.LoadOptions): Promise<unknown>;