avo-cli 0.0.3 → 4.2.0.beta.2

data/payload/node_modules/@oclif/core/lib/errors/error.js

@@ -0,0 +1,63 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.error = error;
+const logger_1 = require("../logger");
+const write_1 = require("../ux/write");
+const cli_1 = require("./errors/cli");
+const pretty_print_1 = __importStar(require("./errors/pretty-print"));
+function error(input, options = {}) {
+    let err;
+    if (typeof input === 'string') {
+        err = new cli_1.CLIError(input, options);
+    }
+    else if (input instanceof Error) {
+        err = (0, cli_1.addOclifExitCode)(input, options);
+    }
+    else {
+        throw new TypeError('first argument must be a string or instance of Error');
+    }
+    err = (0, pretty_print_1.applyPrettyPrintOptions)(err, options);
+    if (options.exit === false) {
+        const message = (0, pretty_print_1.default)(err);
+        if (message)
+            (0, write_1.stderr)(message);
+        if (err?.stack)
+            (0, logger_1.getLogger)().error(err.stack);
+    }
+    else
+        throw err;
+}
+exports.default = error;

data/payload/node_modules/@oclif/core/lib/errors/errors/cli.d.ts

@@ -0,0 +1,29 @@
+import { OclifError, PrettyPrintableError } from '../../interfaces/errors';
+/**
+ * properties specific to internal oclif error handling
+ */
+export declare function addOclifExitCode(error: Record<string, any>, options?: {
+    exit?: false | number | undefined;
+}): OclifError;
+export declare class CLIError extends Error implements OclifError {
+    code?: string | undefined;
+    oclif: OclifError['oclif'];
+    skipOclifErrorHandling?: boolean | undefined;
+    suggestions?: string[] | undefined;
+    constructor(error: Error | string, options?: {
+        exit?: false | number | undefined;
+    } & PrettyPrintableError);
+    get bang(): string | undefined;
+    get stack(): string;
+    /**
+     * @deprecated `render` Errors display should be handled by display function, like pretty-print
+     * @returns {string} returns a string representing the display of the error
+     */
+    render(): string;
+}
+export declare namespace CLIError {
+    class Warn extends CLIError {
+        constructor(err: Error | string);
+        get bang(): string | undefined;
+    }
+}

data/payload/node_modules/@oclif/core/lib/errors/errors/cli.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLIError = void 0;
+exports.addOclifExitCode = addOclifExitCode;
+const clean_stack_1 = __importDefault(require("clean-stack"));
+const indent_string_1 = __importDefault(require("indent-string"));
+const wrap_ansi_1 = __importDefault(require("wrap-ansi"));
+const cache_1 = __importDefault(require("../../cache"));
+const screen_1 = require("../../screen");
+const settings_1 = require("../../settings");
+const theme_1 = require("../../ux/theme");
+/**
+ * properties specific to internal oclif error handling
+ */
+function addOclifExitCode(error, options) {
+    if (!('oclif' in error)) {
+        ;
+        error.oclif = {};
+    }
+    error.oclif.exit = options?.exit === undefined ? (cache_1.default.getInstance().get('exitCodes')?.default ?? 2) : options.exit;
+    return error;
+}
+class CLIError extends Error {
+    code;
+    oclif = {};
+    skipOclifErrorHandling;
+    suggestions;
+    constructor(error, options = {}) {
+        super(error instanceof Error ? error.message : error);
+        addOclifExitCode(this, options);
+        this.code = options.code;
+        this.suggestions = options.suggestions;
+    }
+    get bang() {
+        try {
+            return (0, theme_1.colorize)('red', process.platform === 'win32' ? '»' : '›');
+        }
+        catch { }
+    }
+    get stack() {
+        return (0, clean_stack_1.default)(super.stack, { pretty: true });
+    }
+    /**
+     * @deprecated `render` Errors display should be handled by display function, like pretty-print
+     * @returns {string} returns a string representing the display of the error
+     */
+    render() {
+        if (settings_1.settings.debug) {
+            return this.stack;
+        }
+        let output = `${this.name}: ${this.message}`;
+        output = (0, wrap_ansi_1.default)(output, screen_1.errtermwidth - 6, { hard: true, trim: false });
+        output = (0, indent_string_1.default)(output, 3);
+        output = (0, indent_string_1.default)(output, 1, { includeEmptyLines: true, indent: this.bang });
+        output = (0, indent_string_1.default)(output, 1);
+        return output;
+    }
+}
+exports.CLIError = CLIError;
+(function (CLIError) {
+    class Warn extends CLIError {
+        constructor(err) {
+            super(err instanceof Error ? err.message : err);
+            this.name = 'Warning';
+        }
+        get bang() {
+            try {
+                return (0, theme_1.colorize)('yellow', process.platform === 'win32' ? '»' : '›');
+            }
+            catch { }
+        }
+    }
+    CLIError.Warn = Warn;
+})(CLIError || (exports.CLIError = CLIError = {}));

data/payload/node_modules/@oclif/core/lib/errors/errors/exit.d.ts

@@ -0,0 +1,7 @@
+import { OclifError } from '../../interfaces';
+import { CLIError } from './cli';
+export declare class ExitError extends CLIError implements OclifError {
+    code: string;
+    constructor(exitCode?: number);
+    render(): string;
+}

data/payload/node_modules/@oclif/core/lib/errors/errors/exit.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExitError = void 0;
+const cli_1 = require("./cli");
+class ExitError extends cli_1.CLIError {
+    code = 'EEXIT';
+    constructor(exitCode = 1) {
+        super(`EEXIT: ${exitCode}`, { exit: exitCode });
+    }
+    render() {
+        return '';
+    }
+}
+exports.ExitError = ExitError;

data/payload/node_modules/@oclif/core/lib/errors/errors/module-load.d.ts

@@ -0,0 +1,6 @@
+import { OclifError } from '../../interfaces';
+import { CLIError } from './cli';
+export declare class ModuleLoadError extends CLIError implements OclifError {
+    code: string;
+    constructor(message: string);
+}

data/payload/node_modules/@oclif/core/lib/errors/errors/module-load.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleLoadError = void 0;
+const cli_1 = require("./cli");
+class ModuleLoadError extends cli_1.CLIError {
+    code = 'MODULE_NOT_FOUND';
+    constructor(message) {
+        super(`[MODULE_NOT_FOUND] ${message}`, { exit: 1 });
+        this.name = 'ModuleLoadError';
+    }
+}
+exports.ModuleLoadError = ModuleLoadError;

data/payload/node_modules/@oclif/core/lib/errors/errors/pretty-print.d.ts

@@ -0,0 +1,9 @@
+import { PrettyPrintableError } from '../../interfaces/errors';
+type CLIErrorDisplayOptions = {
+    bang?: string | undefined;
+    name?: string | undefined;
+};
+export declare function applyPrettyPrintOptions(error: Error, options: PrettyPrintableError): PrettyPrintableError;
+type CombinedErrorType = Error & PrettyPrintableError & CLIErrorDisplayOptions;
+export default function prettyPrint(error: CombinedErrorType): string | undefined;
+export {};

data/payload/node_modules/@oclif/core/lib/errors/errors/pretty-print.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyPrettyPrintOptions = applyPrettyPrintOptions;
+exports.default = prettyPrint;
+const indent_string_1 = __importDefault(require("indent-string"));
+const wrap_ansi_1 = __importDefault(require("wrap-ansi"));
+const screen_1 = require("../../screen");
+const settings_1 = require("../../settings");
+function applyPrettyPrintOptions(error, options) {
+    const prettyErrorKeys = ['message', 'code', 'ref', 'suggestions'];
+    for (const key of prettyErrorKeys) {
+        const applyOptionsKey = !(key in error) && options[key];
+        if (applyOptionsKey) {
+            ;
+            error[key] = options[key];
+        }
+    }
+    return error;
+}
+const formatSuggestions = (suggestions) => {
+    const label = 'Try this:';
+    if (!suggestions || suggestions.length === 0)
+        return undefined;
+    if (suggestions.length === 1)
+        return `${label} ${suggestions[0]}`;
+    const multiple = suggestions.map((suggestion) => `* ${suggestion}`).join('\n');
+    return `${label}\n${(0, indent_string_1.default)(multiple, 2)}`;
+};
+function isCombinedErrorType(obj) {
+    return Boolean(obj) && 'name' in obj && 'message' in obj;
+}
+function prettyPrint(error) {
+    const prettyPrintedErrors = [];
+    let currentError = error;
+    let isDeep = false;
+    while (isCombinedErrorType(currentError)) {
+        if (settings_1.settings.debug && currentError.stack) {
+            prettyPrintedErrors.push(`${isDeep ? 'Caused by: ' : ''}${currentError.stack}`);
+        }
+        else {
+            const { bang, code, message, name: errorSuffix, ref, suggestions } = currentError;
+            // errorSuffix is pulled from the 'name' property on CLIError
+            // and is like either Error or Warning
+            const formattedHeader = message ? `${errorSuffix || 'Error'}: ${message}` : undefined;
+            const formattedCode = code ? `Code: ${code}` : undefined;
+            const formattedSuggestions = formatSuggestions(suggestions);
+            const formattedReference = ref ? `Reference: ${ref}` : undefined;
+            const formatted = [formattedHeader, formattedCode, formattedSuggestions, formattedReference]
+                .filter(Boolean)
+                .join('\n');
+            let output = `${isDeep ? 'Caused by: ' : ''}${formatted}`;
+            output = (0, wrap_ansi_1.default)(output, screen_1.errtermwidth - 6, { hard: true, trim: false });
+            if (!settings_1.settings.debug) {
+                output = (0, indent_string_1.default)(output, 3);
+                output = (0, indent_string_1.default)(output, 1, { includeEmptyLines: true, indent: bang || '' });
+                output = (0, indent_string_1.default)(output, 1);
+            }
+            prettyPrintedErrors.push(output);
+        }
+        isDeep = true;
+        currentError = currentError.cause ?? null;
+    }
+    return prettyPrintedErrors.join('\n');
+}

data/payload/node_modules/@oclif/core/lib/errors/exit.d.ts

@@ -0,0 +1 @@
+export declare function exit(code?: number): never;

data/payload/node_modules/@oclif/core/lib/errors/exit.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exit = exit;
+const exit_1 = require("./errors/exit");
+function exit(code = 0) {
+    throw new exit_1.ExitError(code);
+}

data/payload/node_modules/@oclif/core/lib/errors/handle.d.ts

@@ -0,0 +1,14 @@
+import { OclifError, PrettyPrintableError } from '../interfaces';
+import { CLIParseError } from '../parser/errors';
+import { CLIError } from './errors/cli';
+/**
+ * This is an odd abstraction for process.exit, but it allows us to stub it in tests.
+ *
+ * https://github.com/sinonjs/sinon/issues/562
+ */
+export declare const Exit: {
+    exit(code?: number): never;
+};
+type ErrorToHandle = Error & Partial<PrettyPrintableError> & Partial<OclifError> & Partial<CLIError> & Partial<CLIParseError>;
+export declare function handle(err: ErrorToHandle): Promise<void>;
+export {};

data/payload/node_modules/@oclif/core/lib/errors/handle.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Exit = void 0;
+exports.handle = handle;
+const clean_stack_1 = __importDefault(require("clean-stack"));
+const cache_1 = __importDefault(require("../cache"));
+const index_1 = require("../help/index");
+const logger_1 = require("../logger");
+const cli_1 = require("./errors/cli");
+const exit_1 = require("./errors/exit");
+const pretty_print_1 = __importDefault(require("./errors/pretty-print"));
+/**
+ * This is an odd abstraction for process.exit, but it allows us to stub it in tests.
+ *
+ * https://github.com/sinonjs/sinon/issues/562
+ */
+exports.Exit = {
+    exit(code = 0) {
+        // eslint-disable-next-line unicorn/no-process-exit
+        process.exit(code);
+    },
+};
+async function handle(err) {
+    try {
+        if (!err)
+            err = new cli_1.CLIError('no error?');
+        if (err.message === 'SIGINT')
+            exports.Exit.exit(1);
+        const shouldPrint = !(err instanceof exit_1.ExitError) && !err.skipOclifErrorHandling;
+        const pretty = (0, pretty_print_1.default)(err);
+        const stack = (0, clean_stack_1.default)(err.stack || '', { pretty: true });
+        if (shouldPrint) {
+            console.error(pretty ?? stack);
+            const config = cache_1.default.getInstance().get('config');
+            if (err.showHelp && err.parse?.input?.argv && config) {
+                const options = {
+                    ...(config.pjson.oclif.helpOptions ?? config.pjson.helpOptions),
+                    sections: ['flags', 'usage', 'arguments'],
+                    sendToStderr: true,
+                };
+                const help = new index_1.Help(config, options);
+                console.error();
+                await help.showHelp(process.argv.slice(2));
+            }
+        }
+        const exitCode = err.oclif?.exit ?? 1;
+        if (err.code !== 'EEXIT' && stack) {
+            (0, logger_1.getLogger)().error(stack);
+        }
+        exports.Exit.exit(exitCode);
+    }
+    catch (error) {
+        console.error(err.stack);
+        console.error(error.stack);
+        exports.Exit.exit(1);
+    }
+}

data/payload/node_modules/@oclif/core/lib/errors/index.d.ts

@@ -0,0 +1,8 @@
+export { PrettyPrintableError } from '../interfaces';
+export { error } from './error';
+export { CLIError } from './errors/cli';
+export { ExitError } from './errors/exit';
+export { ModuleLoadError } from './errors/module-load';
+export { exit } from './exit';
+export { handle } from './handle';
+export { warn } from './warn';

data/payload/node_modules/@oclif/core/lib/errors/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.warn = exports.handle = exports.exit = exports.ModuleLoadError = exports.ExitError = exports.CLIError = exports.error = void 0;
+var error_1 = require("./error");
+Object.defineProperty(exports, "error", { enumerable: true, get: function () { return error_1.error; } });
+var cli_1 = require("./errors/cli");
+Object.defineProperty(exports, "CLIError", { enumerable: true, get: function () { return cli_1.CLIError; } });
+var exit_1 = require("./errors/exit");
+Object.defineProperty(exports, "ExitError", { enumerable: true, get: function () { return exit_1.ExitError; } });
+var module_load_1 = require("./errors/module-load");
+Object.defineProperty(exports, "ModuleLoadError", { enumerable: true, get: function () { return module_load_1.ModuleLoadError; } });
+var exit_2 = require("./exit");
+Object.defineProperty(exports, "exit", { enumerable: true, get: function () { return exit_2.exit; } });
+var handle_1 = require("./handle");
+Object.defineProperty(exports, "handle", { enumerable: true, get: function () { return handle_1.handle; } });
+var warn_1 = require("./warn");
+Object.defineProperty(exports, "warn", { enumerable: true, get: function () { return warn_1.warn; } });

data/payload/node_modules/@oclif/core/lib/errors/warn.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Prints a pretty warning message to stderr.
+ *
+ * @param input The error or string to print.
+ */
+export declare function warn(input: Error | string): void;
+export declare function memoizedWarn(input: Error | string): void;
+export default warn;

data/payload/node_modules/@oclif/core/lib/errors/warn.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.warn = warn;
+exports.memoizedWarn = memoizedWarn;
+const logger_1 = require("../logger");
+const write_1 = require("../ux/write");
+const cli_1 = require("./errors/cli");
+const pretty_print_1 = __importDefault(require("./errors/pretty-print"));
+/**
+ * Prints a pretty warning message to stderr.
+ *
+ * @param input The error or string to print.
+ */
+function warn(input) {
+    let err;
+    if (typeof input === 'string') {
+        err = new cli_1.CLIError.Warn(input);
+    }
+    else if (input instanceof Error) {
+        err = (0, cli_1.addOclifExitCode)(input);
+    }
+    else {
+        throw new TypeError('first argument must be a string or instance of Error');
+    }
+    const message = (0, pretty_print_1.default)(err);
+    if (message)
+        (0, write_1.stderr)(message);
+    if (err?.stack)
+        (0, logger_1.getLogger)().error(err.stack);
+}
+const WARNINGS = new Set();
+function memoizedWarn(input) {
+    if (!WARNINGS.has(input))
+        warn(input);
+    WARNINGS.add(input);
+}
+exports.default = warn;

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

@@ -0,0 +1,44 @@
+import { LoadOptions } from './interfaces';
+/**
+ * Load and run oclif CLI
+ *
+ * @example For ESM dev.js
+ * ```
+ * #!/usr/bin/env -S node --loader ts-node/esm --no-warnings=ExperimentalWarning
+ * import { execute } from '@oclif/core'
+ *
+ * await execute({development: true, dir: import.meta.url})
+ * ```
+ *
+ * @example For ESM run.js
+ * ```
+ * #!/usr/bin/env node
+ * import { execute } from '@oclif/core'
+ *
+ * await execute({dir: import.meta.url})
+ * ```
+ *
+ * @example For CJS dev.js
+ * ```
+ * #!/usr/bin/env ts-node
+ * void (async () => {
+ *   const oclif = await import('@oclif/core')
+ *   await oclif.execute({development: true, dir: __dirname})
+ * })()
+ * ```
+ *
+ * @example For CJS run.js
+ * ```
+ * #!/usr/bin/env node
+ * void (async () => {
+ *   const oclif = await import('@oclif/core')
+ *   await oclif.execute({dir: __dirname})
+ * })()
+ * ```
+ */
+export declare function execute(options: {
+    args?: string[];
+    development?: boolean;
+    dir?: string;
+    loadOptions?: LoadOptions;
+}): Promise<unknown>;

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

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execute = execute;
+const errors_1 = require("./errors");
+const handle_1 = require("./errors/handle");
+const flush_1 = require("./flush");
+const main_1 = require("./main");
+const settings_1 = require("./settings");
+/**
+ * Load and run oclif CLI
+ *
+ * @example For ESM dev.js
+ * ```
+ * #!/usr/bin/env -S node --loader ts-node/esm --no-warnings=ExperimentalWarning
+ * import { execute } from '@oclif/core'
+ *
+ * await execute({development: true, dir: import.meta.url})
+ * ```
+ *
+ * @example For ESM run.js
+ * ```
+ * #!/usr/bin/env node
+ * import { execute } from '@oclif/core'
+ *
+ * await execute({dir: import.meta.url})
+ * ```
+ *
+ * @example For CJS dev.js
+ * ```
+ * #!/usr/bin/env ts-node
+ * void (async () => {
+ *   const oclif = await import('@oclif/core')
+ *   await oclif.execute({development: true, dir: __dirname})
+ * })()
+ * ```
+ *
+ * @example For CJS run.js
+ * ```
+ * #!/usr/bin/env node
+ * void (async () => {
+ *   const oclif = await import('@oclif/core')
+ *   await oclif.execute({dir: __dirname})
+ * })()
+ * ```
+ */
+async function execute(options) {
+    if (!options.dir && !options.loadOptions) {
+        throw new errors_1.CLIError('dir or loadOptions is required.');
+    }
+    if (options.development) {
+        // In dev mode -> use ts-node and dev plugins
+        process.env.NODE_ENV = 'development';
+        settings_1.settings.debug = true;
+    }
+    return (0, main_1.run)(options.args ?? process.argv.slice(2), options.loadOptions ?? options.dir)
+        .then(async (result) => {
+        (0, flush_1.flush)();
+        return result;
+    })
+        .catch(async (error) => (0, handle_1.handle)(error));
+}