avo-cli 0.0.3 → 4.2.0.beta.2

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

@@ -0,0 +1,181 @@
+import { URL } from 'node:url';
+import { BooleanFlag, CustomOptions, FlagDefinition, OptionFlag } from './interfaces';
+type NotArray<T> = T extends Array<any> ? never : T;
+/**
+ * Create a custom flag.
+ *
+ * @example
+ * type Id = string
+ * type IdOpts = { startsWith: string; length: number }
+ *
+ * export const myFlag = custom<Id, IdOpts>({
+ *   parse: async (input, opts) => {
+ *     if (input.startsWith(opts.startsWith) && input.length === opts.length) {
+ *       return input
+ *     }
+ *
+ *     throw new Error('Invalid id')
+ *   },
+ * })
+ */
+export declare function custom<T = string, P extends CustomOptions = CustomOptions>(defaults: Partial<OptionFlag<T[], P>> & {
+    multiple: true;
+} & ({
+    default: OptionFlag<T[], P>['default'];
+} | {
+    required: true;
+})): FlagDefinition<T, P, {
+    multiple: true;
+    requiredOrDefaulted: true;
+}>;
+export declare function custom<T = string, P extends CustomOptions = CustomOptions>(defaults: Partial<OptionFlag<NotArray<T>, P>> & {
+    multiple?: false | undefined;
+} & ({
+    default: OptionFlag<NotArray<T>, P>['default'];
+} | {
+    required: true;
+})): FlagDefinition<T, P, {
+    multiple: false;
+    requiredOrDefaulted: true;
+}>;
+export declare function custom<T = string, P extends CustomOptions = CustomOptions>(defaults: Partial<OptionFlag<NotArray<T>, P>> & {
+    default?: OptionFlag<NotArray<T>, P>['default'] | undefined;
+    multiple?: false | undefined;
+    required?: false | undefined;
+}): FlagDefinition<T, P, {
+    multiple: false;
+    requiredOrDefaulted: false;
+}>;
+export declare function custom<T = string, P extends CustomOptions = CustomOptions>(defaults: Partial<OptionFlag<T[], P>> & {
+    default?: OptionFlag<T[], P>['default'] | undefined;
+    multiple: true;
+    required?: false | undefined;
+}): FlagDefinition<T, P, {
+    multiple: true;
+    requiredOrDefaulted: false;
+}>;
+export declare function custom<T = string, P extends CustomOptions = CustomOptions>(): FlagDefinition<T, P, {
+    multiple: false;
+    requiredOrDefaulted: false;
+}>;
+/**
+ * A boolean flag. Defaults to `false` unless default is set to `true`.
+ *
+ * - `allowNo` option allows `--no-` prefix to negate boolean flag.
+ */
+export declare function boolean<T = boolean>(options?: Partial<BooleanFlag<T>>): BooleanFlag<T>;
+/**
+ * An integer flag. Throws an error if the provided value is not a valid integer.
+ *
+ * - `min` option allows to set a minimum value.
+ * - `max` option allows to set a maximum value.
+ */
+export declare const integer: FlagDefinition<number, {
+    max?: number;
+    min?: number;
+}, {
+    multiple: false;
+    requiredOrDefaulted: false;
+}>;
+/**
+ * A directory flag.
+ *
+ * - `exists` option allows you to throw an error if the directory does not exist.
+ */
+export declare const directory: FlagDefinition<string, {
+    exists?: boolean;
+}, {
+    multiple: false;
+    requiredOrDefaulted: false;
+}>;
+/**
+ * A file flag.
+ *
+ * - `exists` option allows you to throw an error if the file does not exist.
+ */
+export declare const file: FlagDefinition<string, {
+    exists?: boolean;
+}, {
+    multiple: false;
+    requiredOrDefaulted: false;
+}>;
+/**
+ * A URL flag that converts the provided value is a string.
+ *
+ * Throws an error if the string is not a valid URL.
+ */
+export declare const url: FlagDefinition<URL, CustomOptions, {
+    multiple: false;
+    requiredOrDefaulted: false;
+}>;
+/**
+ * A string flag.
+ */
+export declare const string: FlagDefinition<string, CustomOptions, {
+    multiple: false;
+    requiredOrDefaulted: false;
+}>;
+/**
+ * Version flag that will print the CLI version and exit.
+ */
+export declare const version: (opts?: Partial<BooleanFlag<boolean>>) => BooleanFlag<void>;
+/**
+ * A help flag that will print the CLI help and exit.
+ */
+export declare const help: (opts?: Partial<BooleanFlag<boolean>>) => BooleanFlag<void>;
+type ReadonlyElementOf<T extends ReadonlyArray<unknown>> = T[number];
+/**
+ * Create a custom flag that infers the flag type from the provided options.
+ *
+ * The provided `options` must be a readonly array in order for type inference to work.
+ *
+ * @example
+ * export default class MyCommand extends Command {
+ *   static flags = {
+ *     name: Flags.option({
+ *       options: ['foo', 'bar'] as const,
+ *     })(),
+ *   }
+ * }
+ */
+export declare function option<T extends readonly string[], P extends CustomOptions>(defaults: Partial<OptionFlag<ReadonlyElementOf<T>[], P>> & {
+    multiple: true;
+    options: T;
+} & ({
+    default: OptionFlag<ReadonlyElementOf<T>[], P>['default'] | undefined;
+} | {
+    required: true;
+})): FlagDefinition<(typeof defaults.options)[number], P, {
+    multiple: true;
+    requiredOrDefaulted: true;
+}>;
+export declare function option<T extends readonly string[], P extends CustomOptions>(defaults: Partial<OptionFlag<ReadonlyElementOf<T>, P>> & {
+    multiple?: false | undefined;
+    options: T;
+} & ({
+    default: OptionFlag<ReadonlyElementOf<T>, P>['default'];
+} | {
+    required: true;
+})): FlagDefinition<(typeof defaults.options)[number], P, {
+    multiple: false;
+    requiredOrDefaulted: true;
+}>;
+export declare function option<T extends readonly string[], P extends CustomOptions>(defaults: Partial<OptionFlag<ReadonlyElementOf<T>, P>> & {
+    default?: OptionFlag<ReadonlyElementOf<T>, P>['default'] | undefined;
+    multiple?: false | undefined;
+    options: T;
+    required?: false | undefined;
+}): FlagDefinition<(typeof defaults.options)[number], P, {
+    multiple: false;
+    requiredOrDefaulted: false;
+}>;
+export declare function option<T extends readonly string[], P extends CustomOptions>(defaults: Partial<OptionFlag<ReadonlyElementOf<T>[], P>> & {
+    default?: OptionFlag<ReadonlyElementOf<T>[], P>['default'] | undefined;
+    multiple: true;
+    options: T;
+    required?: false | undefined;
+}): FlagDefinition<(typeof defaults.options)[number], P, {
+    multiple: true;
+    requiredOrDefaulted: false;
+}>;
+export {};

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

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.help = exports.version = exports.string = exports.url = exports.file = exports.directory = exports.integer = void 0;
+exports.custom = custom;
+exports.boolean = boolean;
+exports.option = option;
+const node_url_1 = require("node:url");
+const errors_1 = require("./errors");
+const help_1 = require("./help");
+const fs_1 = require("./util/fs");
+function custom(defaults) {
+    return (options = {}) => ({
+        parse: async (input, _ctx, _opts) => input,
+        ...defaults,
+        ...options,
+        input: [],
+        multiple: Boolean(options.multiple === undefined ? (defaults?.multiple ?? false) : options.multiple),
+        type: 'option',
+    });
+}
+/**
+ * A boolean flag. Defaults to `false` unless default is set to `true`.
+ *
+ * - `allowNo` option allows `--no-` prefix to negate boolean flag.
+ */
+function boolean(options = {}) {
+    return {
+        parse: async (b, _) => b,
+        ...options,
+        allowNo: Boolean(options.allowNo),
+        type: 'boolean',
+    };
+}
+/**
+ * An integer flag. Throws an error if the provided value is not a valid integer.
+ *
+ * - `min` option allows to set a minimum value.
+ * - `max` option allows to set a maximum value.
+ */
+exports.integer = custom({
+    async parse(input, _, opts) {
+        if (!/^-?\d+$/.test(input))
+            throw new errors_1.CLIError(`Expected an integer but received: ${input}`);
+        const num = Number.parseInt(input, 10);
+        if (opts.min !== undefined && num < opts.min)
+            throw new errors_1.CLIError(`Expected an integer greater than or equal to ${opts.min} but received: ${input}`);
+        if (opts.max !== undefined && num > opts.max)
+            throw new errors_1.CLIError(`Expected an integer less than or equal to ${opts.max} but received: ${input}`);
+        return num;
+    },
+});
+/**
+ * A directory flag.
+ *
+ * - `exists` option allows you to throw an error if the directory does not exist.
+ */
+exports.directory = custom({
+    async parse(input, _, opts) {
+        if (opts.exists)
+            return (0, fs_1.dirExists)(input);
+        return input;
+    },
+});
+/**
+ * A file flag.
+ *
+ * - `exists` option allows you to throw an error if the file does not exist.
+ */
+exports.file = custom({
+    async parse(input, _, opts) {
+        if (opts.exists)
+            return (0, fs_1.fileExists)(input);
+        return input;
+    },
+});
+/**
+ * A URL flag that converts the provided value is a string.
+ *
+ * Throws an error if the string is not a valid URL.
+ */
+exports.url = custom({
+    async parse(input) {
+        try {
+            return new node_url_1.URL(input);
+        }
+        catch {
+            throw new errors_1.CLIError(`Expected a valid url but received: ${input}`);
+        }
+    },
+});
+/**
+ * A string flag.
+ */
+exports.string = custom();
+/**
+ * Version flag that will print the CLI version and exit.
+ */
+const version = (opts = {}) => boolean({
+    description: 'Show CLI version.',
+    ...opts,
+    async parse(_, ctx) {
+        ctx.log(ctx.config.userAgent);
+        ctx.exit(0);
+    },
+});
+exports.version = version;
+/**
+ * A help flag that will print the CLI help and exit.
+ */
+const help = (opts = {}) => boolean({
+    description: 'Show CLI help.',
+    ...opts,
+    async parse(_, cmd) {
+        const Help = await (0, help_1.loadHelpClass)(cmd.config);
+        await new Help(cmd.config, cmd.config.pjson.oclif.helpOptions ?? cmd.config.pjson.helpOptions).showHelp(cmd.id ? [cmd.id, ...cmd.argv] : cmd.argv);
+        cmd.exit(0);
+    },
+});
+exports.help = help;
+function option(defaults) {
+    return (options = {}) => ({
+        parse: async (input, _ctx, _opts) => input,
+        ...defaults,
+        ...options,
+        input: [],
+        multiple: Boolean(options.multiple === undefined ? defaults.multiple : options.multiple),
+        type: 'option',
+    });
+}

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

@@ -0,0 +1 @@
+export declare function flush(ms?: number): Promise<void>;

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flush = flush;
+const error_1 = require("./errors/error");
+function timeout(p, ms) {
+    function wait(ms, unref = false) {
+        return new Promise((resolve) => {
+            const t = setTimeout(() => resolve(null), ms);
+            if (unref)
+                t.unref();
+        });
+    }
+    return Promise.race([p, wait(ms, true).then(() => (0, error_1.error)('timed out'))]);
+}
+async function _flush() {
+    const p = new Promise((resolve) => {
+        process.stdout.once('drain', () => resolve(null));
+    });
+    const flushed = process.stdout.write('');
+    if (flushed)
+        return;
+    return p;
+}
+async function flush(ms = 10_000) {
+    await timeout(_flush(), ms);
+}

data/payload/node_modules/@oclif/core/lib/help/command.d.ts

@@ -0,0 +1,33 @@
+import { Command } from '../command';
+import * as Interfaces from '../interfaces';
+import { HelpFormatter, HelpSectionRenderer } from './formatter';
+export declare class CommandHelp extends HelpFormatter {
+    command: Command.Loadable;
+    config: Interfaces.Config;
+    opts: Interfaces.HelpOptions;
+    constructor(command: Command.Loadable, config: Interfaces.Config, opts: Interfaces.HelpOptions);
+    protected aliases(aliases: string[] | undefined): string | undefined;
+    protected arg(arg: Command.Arg.Any): string;
+    protected args(args: Command.Arg.Any[]): [string, string | undefined][] | undefined;
+    protected defaultUsage(): string;
+    protected description(): string | undefined;
+    protected examples(examples: Command.Example[] | string | undefined): string | undefined;
+    protected flagHelpLabel(flag: Command.Flag.Any, showOptions?: boolean): string;
+    protected flags(flags: Array<Command.Flag.Any>): [string, string | undefined][] | undefined;
+    protected flagsDescriptions(flags: Array<Command.Flag.Any>): string | undefined;
+    generate(): string;
+    protected groupFlags(flags: Array<Command.Flag.Any>): {
+        flagGroups: {
+            [name: string]: Array<Command.Flag.Any>;
+        };
+        mainFlags: Array<Command.Flag.Any>;
+    };
+    protected sections(): Array<{
+        generate: HelpSectionRenderer;
+        header: string;
+    }>;
+    protected usage(): string;
+    private formatIfCommand;
+    private isCommand;
+}
+export default CommandHelp;