@eggjs/bin 7.0.0-beta.4 → 7.0.0

package/README.md

@@ -21,14 +21,14 @@
 [node-version-image]: https://img.shields.io/node/v/@eggjs/bin.svg?style=flat-square
 [node-version-url]: https://nodejs.org/en/download/
 
-egg developer tool, extends [@artus-cli/artus-cli].
+egg developer tool, base on [oclif](https://oclif.io/).
 
 ---
 
 ## Install
 
 ```bash
-npm i egg-bin --save-dev
+npm i @eggjs/bin --save-dev
 ```
 
 ## Usage
@@ -78,7 +78,7 @@ egg-bin dev
 #### dev options
 
 - `--framework` egg web framework root path.
-- `--port` server port. If not specified, the port is obtained in the following order: [_egg.js_ configuration](https://www.eggjs.org/basics/config) `config/config.*.js` > `process.env.EGG_BIN_DEFAULT_PORT` > 7001 > other available ports.
+- `--port` server port. If not specified, the port is obtained in the following order: [_egg.js_ configuration](https://eggjs.org/basics/config) `config/config.*.js` > `process.env.EGG_BIN_DEFAULT_PORT` > 7001 > other available ports.
 - `--workers` worker process number, default to `1` worker at local mode.
 - `--sticky` start a sticky cluster server, default to `false`.
 
@@ -103,8 +103,6 @@ Create `.vscode/launch.json` file:
       ],
       "console": "integratedTerminal",
       "restart": true,
-      "protocol": "auto",
-      "port": 9229,
       "autoAttachChildProcesses": true
     },
     {
@@ -118,8 +116,6 @@ Create `.vscode/launch.json` file:
         "--",
         "--inspect-brk"
       ],
-      "protocol": "auto",
-      "port": 9229,
       "autoAttachChildProcesses": true
     }
   ]
@@ -192,7 +188,7 @@ You can pass any mocha argv.
 
 - `-x` add dir ignore coverage, support multiple argv
 - `--prerequire` prerequire files for coverage instrument, you can use this options if load files slowly when call `mm.app` or `mm.cluster`
-- `--typescript` / `--ts` enable typescript support. If true, will auto add `.ts` extension and ignore `typings` and `d.ts`.
+- `--typescript` enable typescript support. If `true`, will auto add `.ts` extension and ignore `typings` and `d.ts`.
 - `--c8` c8 instruments passthrough. you can use this to overwrite egg-bin's default c8 instruments and add additional ones.
   >
   > - egg-bin have some default instruments passed to c8 like `-r` and `--temp-directory`
@@ -210,7 +206,7 @@ COV_EXCLUDES="app/plugins/c*,app/autocreate/**" egg-bin cov
 
 ## Custom egg-bin for your team
 
-See <https://artus-cli.github.io>
+See <https://oclif.io/docs/configuring_your_cli/>
 
 ## License
 
@@ -224,4 +220,3 @@ Made with [contributors-img](https://contrib.rocks).
 
 [mocha]: https://mochajs.org
 [glob]: https://github.com/isaacs/node-glob
-[@artus-cli/artus-cli]: https://github.com/artus-cli/artus-cli

package/bin/dev.js

@@ -1,6 +1,8 @@
-#!/usr/bin/env -S node --loader ts-node/esm --disable-warning=ExperimentalWarning
+#!/usr/bin/env -S node --loader ts-node/esm --disable-warning=ExperimentalWarning --no-deprecation
 
-// eslint-disable-next-line n/shebang
-import {execute} from '@oclif/core'
+import { execute } from '@oclif/core';
 
-await execute({development: true, dir: import.meta.url})
+await execute({
+  // development: true,
+  dir: import.meta.url,
+});

package/bin/run.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
 
-import {execute} from '@oclif/core'
+import { execute } from '@oclif/core';
 
-await execute({dir: import.meta.url})
+await execute({ dir: import.meta.url });

package/dist/commonjs/baseCommand.d.ts

@@ -0,0 +1,49 @@
+import { ForkOptions } from 'node:child_process';
+import { Command, Flags, Interfaces } from '@oclif/core';
+import { PackageEgg } from './types.js';
+export declare class ForkError extends Error {
+    code: number | null;
+    constructor(message: string, code: number | null);
+}
+export interface ForkNodeOptions extends ForkOptions {
+    dryRun?: boolean;
+}
+type Flags<T extends typeof Command> = Interfaces.InferredFlags<typeof BaseCommand['baseFlags'] & T['flags']>;
+type Args<T extends typeof Command> = Interfaces.InferredArgs<T['args']>;
+export declare abstract class BaseCommand<T extends typeof Command> extends Command {
+    #private;
+    static enableJsonFlag: boolean;
+    static baseFlags: {
+        'dry-run': Interfaces.BooleanFlag<boolean>;
+        require: Interfaces.OptionFlag<string[] | undefined, Interfaces.CustomOptions>;
+        import: Interfaces.OptionFlag<string[] | undefined, Interfaces.CustomOptions>;
+        base: Interfaces.OptionFlag<string, Interfaces.CustomOptions>;
+        tscompiler: Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
+        typescript: Interfaces.BooleanFlag<boolean>;
+        ts: Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
+        javascript: Interfaces.BooleanFlag<boolean>;
+        declarations: Interfaces.BooleanFlag<boolean>;
+        inspect: Interfaces.BooleanFlag<boolean>;
+        'inspect-brk': Interfaces.BooleanFlag<boolean>;
+    };
+    protected flags: Flags<T>;
+    protected args: Args<T>;
+    protected env: {
+        [x: string]: string | undefined;
+        TZ?: string;
+    };
+    protected pkg: Record<string, any>;
+    protected isESM: boolean;
+    protected pkgEgg: PackageEgg;
+    protected globalExecArgv: string[];
+    init(): Promise<void>;
+    protected catch(err: Error & {
+        exitCode?: number;
+    }): Promise<any>;
+    protected finally(_: Error | undefined): Promise<any>;
+    protected formatRequires(): Promise<string[]>;
+    protected formatImportModule(modulePath: string): string;
+    protected addNodeOptions(options: string): void;
+    protected forkNode(modulePath: string, forkArgs: string[], options?: ForkNodeOptions): Promise<void>;
+}
+export {};

package/dist/commonjs/baseCommand.js

@@ -0,0 +1,370 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseCommand = exports.ForkError = void 0;
+const node_util_1 = require("node:util");
+const node_url_1 = require("node:url");
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const core_1 = require("@oclif/core");
+const utils_1 = require("@eggjs/utils");
+const runscript_1 = require("runscript");
+const utils_js_1 = require("./utils.js");
+const debug = (0, node_util_1.debuglog)('@eggjs/bin/baseCommand');
+// only hook once and only when ever start any child.
+const children = new Set();
+let hadHook = false;
+function graceful(proc) {
+    // save child ref
+    children.add(proc);
+    // only hook once
+    /* c8 ignore else */
+    if (!hadHook) {
+        hadHook = true;
+        let signal;
+        ['SIGINT', 'SIGQUIT', 'SIGTERM'].forEach(event => {
+            process.once(event, () => {
+                signal = event;
+                process.exit(0);
+            });
+        });
+        process.once('exit', (code) => {
+            for (const child of children) {
+                debug('process exit code: %o, kill child %o with %o', code, child.pid, signal);
+                child.kill(signal);
+            }
+        });
+    }
+}
+class ForkError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+    }
+}
+exports.ForkError = ForkError;
+class BaseCommand extends core_1.Command {
+    // add the --json flag
+    static enableJsonFlag = false;
+    // define flags that can be inherited by any command that extends BaseCommand
+    static baseFlags = {
+        // 'log-level': Flags.option({
+        //   default: 'info',
+        //   helpGroup: 'GLOBAL',
+        //   options: ['debug', 'warn', 'error', 'info', 'trace'] as const,
+        //   summary: 'Specify level for logging.',
+        // })(),
+        'dry-run': core_1.Flags.boolean({
+            default: false,
+            helpGroup: 'GLOBAL',
+            summary: 'whether show full command script only',
+            char: 'd',
+        }),
+        require: core_1.Flags.string({
+            helpGroup: 'GLOBAL',
+            summary: 'require the given module',
+            char: 'r',
+            multiple: true,
+        }),
+        import: core_1.Flags.string({
+            helpGroup: 'GLOBAL',
+            summary: 'import the given module, only work on ESM',
+            multiple: true,
+        }),
+        base: core_1.Flags.string({
+            helpGroup: 'GLOBAL',
+            summary: 'directory of application',
+            aliases: ['baseDir'],
+            default: process.cwd(),
+        }),
+        tscompiler: core_1.Flags.string({
+            helpGroup: 'GLOBAL',
+            summary: 'TypeScript compiler, like ts-node/register',
+            aliases: ['tsc'],
+        }),
+        // flag with no value (--typescript)
+        typescript: core_1.Flags.boolean({
+            helpGroup: 'GLOBAL',
+            description: '[default: true] use TypeScript to run the test',
+            allowNo: true,
+        }),
+        ts: core_1.Flags.string({
+            helpGroup: 'GLOBAL',
+            description: 'shortcut for --typescript, e.g.: --ts=false',
+            options: ['true', 'false'],
+        }),
+        javascript: core_1.Flags.boolean({
+            helpGroup: 'GLOBAL',
+            description: 'use JavaScript to run the test',
+            aliases: ['js'],
+        }),
+        declarations: core_1.Flags.boolean({
+            helpGroup: 'GLOBAL',
+            description: 'whether create typings, will add `--require egg-ts-helper/register`',
+            aliases: ['dts'],
+        }),
+        // https://nodejs.org/dist/latest-v18.x/docs/api/cli.html#--inspect-brkhostport
+        inspect: core_1.Flags.boolean({
+            helpGroup: 'GLOBAL',
+            description: 'Activate inspector',
+        }),
+        'inspect-brk': core_1.Flags.boolean({
+            helpGroup: 'GLOBAL',
+            description: 'Activate inspector and break at start of user script',
+        }),
+    };
+    flags;
+    args;
+    env = { ...process.env };
+    pkg;
+    isESM;
+    pkgEgg;
+    globalExecArgv = [];
+    async init() {
+        await super.init();
+        debug('[init] raw args: %o, NODE_ENV: %o', this.argv, this.env.NODE_ENV);
+        const { args, flags } = await this.parse({
+            flags: this.ctor.flags,
+            baseFlags: super.ctor.baseFlags,
+            enableJsonFlag: this.ctor.enableJsonFlag,
+            args: this.ctor.args,
+            strict: this.ctor.strict,
+        });
+        this.flags = flags;
+        this.args = args;
+        await this.#afterInit();
+    }
+    async #afterInit() {
+        const { args, flags } = this;
+        debug('before: args: %o, flags: %o', args, flags);
+        if (!node_path_1.default.isAbsolute(flags.base)) {
+            flags.base = node_path_1.default.join(process.cwd(), flags.base);
+        }
+        const pkg = await (0, utils_js_1.readPackageJSON)(flags.base);
+        this.pkg = pkg;
+        this.pkgEgg = pkg.egg ?? {};
+        flags.tscompiler = flags.tscompiler ?? this.env.TS_COMPILER ?? this.pkgEgg.tscompiler;
+        let typescript = flags.typescript;
+        // keep compatible with old ts flag: `--ts=true` or `--ts=false`
+        if (flags.ts === 'true') {
+            typescript = true;
+        }
+        else if (flags.ts === 'false') {
+            typescript = false;
+        }
+        if (typescript === undefined) {
+            // try to ready EGG_TYPESCRIPT env first, only accept 'true' or 'false' string
+            if (this.env.EGG_TYPESCRIPT === 'false') {
+                typescript = false;
+                debug('detect typescript=%o from EGG_TYPESCRIPT=%o', false, this.env.EGG_TYPESCRIPT);
+            }
+            else if (this.env.EGG_TYPESCRIPT === 'true') {
+                typescript = true;
+                debug('detect typescript=%o from EGG_TYPESCRIPT=%o', true, this.env.EGG_TYPESCRIPT);
+            }
+            else if (typeof this.pkgEgg.typescript === 'boolean') {
+                // read `egg.typescript` from package.json if not pass argv
+                typescript = this.pkgEgg.typescript;
+                debug('detect typescript=%o from pkg.egg.typescript=%o', typescript, this.pkgEgg.typescript);
+            }
+            else if (pkg.dependencies?.typescript) {
+                // auto detect pkg.dependencies.typescript or pkg.devDependencies.typescript
+                typescript = true;
+                debug('detect typescript=%o from pkg.dependencies.typescript=%o', true, pkg.dependencies.typescript);
+            }
+            else if (pkg.devDependencies?.typescript) {
+                typescript = true;
+                debug('detect typescript=%o from pkg.devDependencies.typescript=%o', true, pkg.devDependencies.typescript);
+            }
+            else if (await (0, utils_js_1.hasTsConfig)(flags.base)) {
+                // tsconfig.json exists
+                typescript = true;
+                debug('detect typescript=%o cause tsconfig.json exists', true);
+            }
+            else if (flags.tscompiler) {
+                typescript = true;
+                debug('detect typescript=%o from --tscompiler=%o', true, flags.tscompiler);
+            }
+        }
+        flags.typescript = typescript;
+        this.isESM = pkg.type === 'module';
+        if (typescript) {
+            const findPaths = [(0, utils_js_1.getSourceDirname)()];
+            if (flags.tscompiler) {
+                // try app baseDir first on custom tscompiler
+                // then try to find tscompiler in @eggjs/bin/node_modules
+                findPaths.unshift(flags.base);
+            }
+            flags.tscompiler = flags.tscompiler ?? 'ts-node/register';
+            const tsNodeRegister = (0, utils_1.importResolve)(flags.tscompiler, {
+                paths: findPaths,
+            });
+            flags.tscompiler = tsNodeRegister;
+            // should require tsNodeRegister on current process, let it can require *.ts files
+            // e.g.: dev command will execute egg loader to find configs and plugins
+            // await importModule(tsNodeRegister);
+            // let child process auto require ts-node too
+            this.addNodeOptions(this.formatImportModule(tsNodeRegister));
+            // tell egg loader to load ts file
+            // see https://github.com/eggjs/egg-core/blob/master/lib/loader/egg_loader.js#L443
+            this.env.EGG_TYPESCRIPT = 'true';
+            // set current process.env.EGG_TYPESCRIPT too
+            process.env.EGG_TYPESCRIPT = 'true';
+            // load files from tsconfig on startup
+            this.env.TS_NODE_FILES = process.env.TS_NODE_FILES ?? 'true';
+            // keep same logic with egg-core, test cmd load files need it
+            // see https://github.com/eggjs/egg-core/blob/master/lib/loader/egg_loader.js#L49
+            // addNodeOptionsToEnv(`--require ${importResolve('tsconfig-paths/register', {
+            //   paths: [ getSourceDirname() ],
+            // })}`, ctx.env);
+        }
+        if (this.isESM) {
+            // use ts-node/esm loader on esm
+            let esmLoader = (0, utils_1.importResolve)('ts-node/esm', {
+                paths: [(0, utils_js_1.getSourceDirname)()],
+            });
+            // ES Module loading with absolute path fails on windows
+            // https://github.com/nodejs/node/issues/31710#issuecomment-583916239
+            // https://nodejs.org/api/url.html#url_url_pathtofileurl_path
+            // Error [ERR_UNSUPPORTED_ESM_URL_SCHEME]: Only URLs with a scheme in: file, data, and node are supported by the default ESM loader. On Windows, absolute paths must be valid file:// URLs. Received protocol 'd:'
+            esmLoader = (0, node_url_1.pathToFileURL)(esmLoader).href;
+            // wait for https://github.com/nodejs/node/issues/40940
+            this.addNodeOptions('--no-warnings');
+            this.addNodeOptions(`--loader ${esmLoader}`);
+        }
+        if (flags.declarations === undefined) {
+            if (typeof this.pkgEgg.declarations === 'boolean') {
+                // read `egg.declarations` from package.json if not pass argv
+                flags.declarations = this.pkgEgg.declarations;
+                debug('detect declarations from pkg.egg.declarations=%o', this.pkgEgg.declarations);
+            }
+        }
+        if (flags.declarations) {
+            const etsBin = (0, utils_1.importResolve)('egg-ts-helper/dist/bin', {
+                paths: [
+                    flags.base,
+                    (0, utils_js_1.getSourceDirname)(),
+                ],
+            });
+            debug('run ets first: %o', etsBin);
+            await (0, runscript_1.runScript)(`node ${etsBin}`);
+        }
+        if (this.pkgEgg.revert) {
+            const reverts = Array.isArray(this.pkgEgg.revert) ? this.pkgEgg.revert : [this.pkgEgg.revert];
+            for (const revert of reverts) {
+                this.globalExecArgv.push(`--security-revert=${revert}`);
+            }
+        }
+        let hasInspectOption = false;
+        if (flags.inspect) {
+            this.addNodeOptions('--inspect');
+            hasInspectOption = true;
+        }
+        if (flags['inspect-brk']) {
+            this.addNodeOptions('--inspect-brk');
+            hasInspectOption = true;
+        }
+        if (hasInspectOption) {
+            Reflect.set(flags, 'timeout', 0);
+            debug('set timeout = 0 when inspect enable');
+        }
+        else if (this.env.JB_DEBUG_FILE) {
+            // others like WebStorm 2019 will pass NODE_OPTIONS, and @eggjs/bin itself will be debug, so could detect `process.env.JB_DEBUG_FILE`.
+            Reflect.set(flags, 'timeout', 0);
+            debug('set timeout = false when process.env.JB_DEBUG_FILE=%o', this.env.JB_DEBUG_FILE);
+        }
+        debug('baseDir: %o, isESM: %o', flags.base, this.isESM);
+        debug('set NODE_OPTIONS: %o', this.env.NODE_OPTIONS);
+        debug('after: args: %o, flags: %o', args, flags);
+        debug('enter real command: %o', this.id);
+    }
+    async catch(err) {
+        // add any custom logic to handle errors from the command
+        // or simply return the parent class error handling
+        return super.catch(err);
+    }
+    async finally(_) {
+        // called after run and catch regardless of whether or not the command errored
+        return super.finally(_);
+    }
+    async formatRequires() {
+        const requires = this.flags.require ?? [];
+        const imports = this.flags.import ?? [];
+        let eggRequires = this.pkgEgg.require ?? [];
+        if (typeof eggRequires === 'string') {
+            eggRequires = [eggRequires];
+        }
+        let eggImports = this.pkgEgg.import ?? [];
+        if (typeof eggImports === 'string') {
+            eggImports = [eggImports];
+        }
+        return [
+            ...requires,
+            ...imports,
+            ...eggRequires,
+            ...eggImports,
+        ];
+    }
+    formatImportModule(modulePath) {
+        if (this.isESM) {
+            return `--import ${(0, node_url_1.pathToFileURL)(modulePath).href}`;
+        }
+        return `--require ${modulePath}`;
+    }
+    addNodeOptions(options) {
+        if (this.env.NODE_OPTIONS) {
+            if (!this.env.NODE_OPTIONS.includes(options)) {
+                this.env.NODE_OPTIONS = `${this.env.NODE_OPTIONS} ${options}`;
+            }
+        }
+        else {
+            this.env.NODE_OPTIONS = options;
+        }
+    }
+    async forkNode(modulePath, forkArgs, options = {}) {
+        const env = {
+            ...this.env,
+            ...options.env,
+        };
+        const forkExecArgv = [
+            ...this.globalExecArgv,
+            ...options.execArgv || [],
+        ];
+        const NODE_OPTIONS = env.NODE_OPTIONS ? `NODE_OPTIONS='${env.NODE_OPTIONS}' ` : '';
+        const forkExecArgvString = forkExecArgv.length ? ' ' + forkExecArgv.join(' ') + ' ' : ' ';
+        const forkArgsString = forkArgs.map(a => `'${a}'`).join(' ');
+        const fullCommand = `${NODE_OPTIONS}${process.execPath}${forkExecArgvString}${modulePath} ${forkArgsString}`;
+        if (options.dryRun) {
+            console.log('dry run: $ %s', fullCommand);
+            return;
+        }
+        options = {
+            stdio: 'inherit',
+            env,
+            cwd: this.flags.base,
+            ...options,
+            execArgv: forkExecArgv,
+        };
+        const proc = (0, node_child_process_1.fork)(modulePath, forkArgs, options);
+        debug('Run fork pid: %o\n\n$ %s\n\n', proc.pid, fullCommand);
+        graceful(proc);
+        return new Promise((resolve, reject) => {
+            proc.once('exit', code => {
+                debug('fork pid: %o exit code %o', proc.pid, code);
+                children.delete(proc);
+                if (code !== 0) {
+                    const err = new ForkError(modulePath + ' ' + forkArgs.join(' ') + ' exit with code ' + code, code);
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    }
+}
+exports.BaseCommand = BaseCommand;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"baseCommand.js","sourceRoot":"","sources":["../../src/baseCommand.ts"],"names":[],"mappings":";;;;;;AAAA,yCAAqC;AACrC,uCAAyC;AACzC,0DAA6B;AAC7B,2DAAqE;AACrE,sCAAyD;AACzD,wCAA6C;AAC7C,yCAAsC;AACtC,yCAGoB;AAGpB,MAAM,KAAK,GAAG,IAAA,oBAAQ,EAAC,wBAAwB,CAAC,CAAC;AAEjD,qDAAqD;AACrD,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAgB,CAAC;AACzC,IAAI,OAAO,GAAG,KAAK,CAAC;AACpB,SAAS,QAAQ,CAAC,IAAkB;IAClC,iBAAiB;IACjB,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAEnB,iBAAiB;IACjB,oBAAoB;IACpB,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO,GAAG,IAAI,CAAC;QACf,IAAI,MAAsB,CAAC;QAC3B,CAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,CAAE,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;YACjD,OAAO,CAAC,IAAI,CAAC,KAAK,EAAE,GAAG,EAAE;gBACvB,MAAM,GAAG,KAAuB,CAAC;gBACjC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YAClB,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,IAAY,EAAE,EAAE;YACpC,KAAK,MAAM,KAAK,IAAI,QAAQ,EAAE,CAAC;gBAC7B,KAAK,CAAC,8CAA8C,EAAE,IAAI,EAAE,KAAK,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;gBAC/E,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YACrB,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;AACH,CAAC;AAED,MAAa,SAAU,SAAQ,KAAK;IAClC,IAAI,CAAgB;IACpB,YAAY,OAAe,EAAE,IAAmB;QAC9C,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;CACF;AAND,8BAMC;AASD,MAAsB,WAAsC,SAAQ,cAAO;IACzE,sBAAsB;IACtB,MAAM,CAAC,cAAc,GAAG,KAAK,CAAC;IAE9B,6EAA6E;IAC7E,MAAM,CAAC,SAAS,GAAG;QACjB,8BAA8B;QAC9B,qBAAqB;QACrB,yBAAyB;QACzB,mEAAmE;QACnE,2CAA2C;QAC3C,QAAQ;QACR,SAAS,EAAE,YAAK,CAAC,OAAO,CAAC;YACvB,OAAO,EAAE,KAAK;YACd,SAAS,EAAE,QAAQ;YACnB,OAAO,EAAE,uCAAuC;YAChD,IAAI,EAAE,GAAG;SACV,CAAC;QACF,OAAO,EAAE,YAAK,CAAC,MAAM,CAAC;YACpB,SAAS,EAAE,QAAQ;YACnB,OAAO,EAAE,0BAA0B;YACnC,IAAI,EAAE,GAAG;YACT,QAAQ,EAAE,IAAI;SACf,CAAC;QACF,MAAM,EAAE,YAAK,CAAC,MAAM,CAAC;YACnB,SAAS,EAAE,QAAQ;YACnB,OAAO,EAAE,2CAA2C;YACpD,QAAQ,EAAE,IAAI;SACf,CAAC;QACF,IAAI,EAAE,YAAK,CAAC,MAAM,CAAC;YACjB,SAAS,EAAE,QAAQ;YACnB,OAAO,EAAE,0BAA0B;YACnC,OAAO,EAAE,CAAE,SAAS,CAAE;YACtB,OAAO,EAAE,OAAO,CAAC,GAAG,EAAE;SACvB,CAAC;QACF,UAAU,EAAE,YAAK,CAAC,MAAM,CAAC;YACvB,SAAS,EAAE,QAAQ;YACnB,OAAO,EAAE,4CAA4C;YACrD,OAAO,EAAE,CAAE,KAAK,CAAE;SACnB,CAAC;QACF,oCAAoC;QACpC,UAAU,EAAE,YAAK,CAAC,OAAO,CAAC;YACxB,SAAS,EAAE,QAAQ;YACnB,WAAW,EAAE,gDAAgD;YAC7D,OAAO,EAAE,IAAI;SACd,CAAC;QACF,EAAE,EAAE,YAAK,CAAC,MAAM,CAAC;YACf,SAAS,EAAE,QAAQ;YACnB,WAAW,EAAE,6CAA6C;YAC1D,OAAO,EAAE,CAAE,MAAM,EAAE,OAAO,CAAE;SAC7B,CAAC;QACF,UAAU,EAAE,YAAK,CAAC,OAAO,CAAC;YACxB,SAAS,EAAE,QAAQ;YACnB,WAAW,EAAE,gCAAgC;YAC7C,OAAO,EAAE,CAAE,IAAI,CAAE;SAClB,CAAC;QACF,YAAY,EAAE,YAAK,CAAC,OAAO,CAAC;YAC1B,SAAS,EAAE,QAAQ;YACnB,WAAW,EAAE,qEAAqE;YAClF,OAAO,EAAE,CAAE,KAAK,CAAE;SACnB,CAAC;QACF,+EAA+E;QAC/E,OAAO,EAAE,YAAK,CAAC,OAAO,CAAC;YACrB,SAAS,EAAE,QAAQ;YACnB,WAAW,EAAE,oBAAoB;SAClC,CAAC;QACF,aAAa,EAAE,YAAK,CAAC,OAAO,CAAC;YAC3B,SAAS,EAAE,QAAQ;YACnB,WAAW,EAAE,sDAAsD;SACpE,CAAC;KACH,CAAC;IAEQ,KAAK,CAAY;IACjB,IAAI,CAAW;IAEf,GAAG,GAAG,EAAE,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;IACzB,GAAG,CAAsB;IACzB,KAAK,CAAU;IACf,MAAM,CAAa;IACnB,cAAc,GAAa,EAAE,CAAC;IAEjC,KAAK,CAAC,IAAI;QACf,MAAM,KAAK,CAAC,IAAI,EAAE,CAAC;QACnB,KAAK,CAAC,mCAAmC,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QACzE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC;YACvC,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC,KAAK;YACtB,SAAS,EAAG,KAAK,CAAC,IAA2B,CAAC,SAAS;YACvD,cAAc,EAAE,IAAI,CAAC,IAAI,CAAC,cAAc;YACxC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI;YACpB,MAAM,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM;SACzB,CAAC,CAAC;QACH,IAAI,CAAC,KAAK,GAAG,KAAiB,CAAC;QAC/B,IAAI,CAAC,IAAI,GAAG,IAAe,CAAC;QAE5B,MAAM,IAAI,CAAC,UAAU,EAAE,CAAC;IAC1B,CAAC;IAED,KAAK,CAAC,UAAU;QACd,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC;QAC7B,KAAK,CAAC,6BAA6B,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;QAClD,IAAI,CAAC,mBAAI,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;YACjC,KAAK,CAAC,IAAI,GAAG,mBAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;QACpD,CAAC;QACD,MAAM,GAAG,GAAG,MAAM,IAAA,0BAAe,EAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAC9C,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;QACf,IAAI,CAAC,MAAM,GAAG,GAAG,CAAC,GAAG,IAAI,EAAE,CAAC;QAC5B,KAAK,CAAC,UAAU,GAAG,KAAK,CAAC,UAAU,IAAI,IAAI,CAAC,GAAG,CAAC,WAAW,IAAI,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC;QAEtF,IAAI,UAAU,GAAY,KAAK,CAAC,UAAU,CAAC;QAC3C,gEAAgE;QAChE,IAAI,KAAK,CAAC,EAAE,KAAK,MAAM,EAAE,CAAC;YACxB,UAAU,GAAG,IAAI,CAAC;QACpB,CAAC;aAAM,IAAI,KAAK,CAAC,EAAE,KAAK,OAAO,EAAE,CAAC;YAChC,UAAU,GAAG,KAAK,CAAC;QACrB,CAAC;QAED,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;YAC7B,8EAA8E;YAC9E,IAAI,IAAI,CAAC,GAAG,CAAC,cAAc,KAAK,OAAO,EAAE,CAAC;gBACxC,UAAU,GAAG,KAAK,CAAC;gBACnB,KAAK,CAAC,6CAA6C,EAAE,KAAK,EAAE,IAAI,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;YACvF,CAAC;iBAAM,IAAI,IAAI,CAAC,GAAG,CAAC,cAAc,KAAK,MAAM,EAAE,CAAC;gBAC9C,UAAU,GAAG,IAAI,CAAC;gBAClB,KAAK,CAAC,6CAA6C,EAAE,IAAI,EAAE,IAAI,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;YACtF,CAAC;iBAAM,IAAI,OAAO,IAAI,CAAC,MAAM,CAAC,UAAU,KAAK,SAAS,EAAE,CAAC;gBACvD,2DAA2D;gBAC3D,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC;gBACpC,KAAK,CAAC,iDAAiD,EAAE,UAAU,EAAE,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;YAC/F,CAAC;iBAAM,IAAI,GAAG,CAAC,YAAY,EAAE,UAAU,EAAE,CAAC;gBACxC,4EAA4E;gBAC5E,UAAU,GAAG,IAAI,CAAC;gBAClB,KAAK,CAAC,0DAA0D,EAAE,IAAI,EAAE,GAAG,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC;YACvG,CAAC;iBAAM,IAAI,GAAG,CAAC,eAAe,EAAE,UAAU,EAAE,CAAC;gBAC3C,UAAU,GAAG,IAAI,CAAC;gBAClB,KAAK,CAAC,6DAA6D,EAAE,IAAI,EAAE,GAAG,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC;YAC7G,CAAC;iBAAM,IAAI,MAAM,IAAA,sBAAW,EAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;gBACzC,uBAAuB;gBACvB,UAAU,GAAG,IAAI,CAAC;gBAClB,KAAK,CAAC,iDAAiD,EAAE,IAAI,CAAC,CAAC;YACjE,CAAC;iBAAM,IAAI,KAAK,CAAC,UAAU,EAAE,CAAC;gBAC5B,UAAU,GAAG,IAAI,CAAC;gBAClB,KAAK,CAAC,2CAA2C,EAAE,IAAI,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;YAC7E,CAAC;QACH,CAAC;QACD,KAAK,CAAC,UAAU,GAAG,UAAU,CAAC;QAE9B,IAAI,CAAC,KAAK,GAAG,GAAG,CAAC,IAAI,KAAK,QAAQ,CAAC;QACnC,IAAI,UAAU,EAAE,CAAC;YACf,MAAM,SAAS,GAAa,CAAE,IAAA,2BAAgB,GAAE,CAAE,CAAC;YACnD,IAAI,KAAK,CAAC,UAAU,EAAE,CAAC;gBACrB,6CAA6C;gBAC7C,yDAAyD;gBACzD,SAAS,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YAChC,CAAC;YACD,KAAK,CAAC,UAAU,GAAG,KAAK,CAAC,UAAU,IAAI,kBAAkB,CAAC;YAC1D,MAAM,cAAc,GAAG,IAAA,qBAAa,EAAC,KAAK,CAAC,UAAU,EAAE;gBACrD,KAAK,EAAE,SAAS;aACjB,CAAC,CAAC;YACH,KAAK,CAAC,UAAU,GAAG,cAAc,CAAC;YAClC,kFAAkF;YAClF,wEAAwE;YACxE,sCAAsC;YACtC,6CAA6C;YAC7C,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,kBAAkB,CAAC,cAAc,CAAC,CAAC,CAAC;YAC7D,kCAAkC;YAClC,kFAAkF;YAClF,IAAI,CAAC,GAAG,CAAC,cAAc,GAAG,MAAM,CAAC;YACjC,6CAA6C;YAC7C,OAAO,CAAC,GAAG,CAAC,cAAc,GAAG,MAAM,CAAC;YACpC,sCAAsC;YACtC,IAAI,CAAC,GAAG,CAAC,aAAa,GAAG,OAAO,CAAC,GAAG,CAAC,aAAa,IAAI,MAAM,CAAC;YAC7D,6DAA6D;YAC7D,iFAAiF;YACjF,8EAA8E;YAC9E,mCAAmC;YACnC,kBAAkB;QACpB,CAAC;QACD,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;YACf,gCAAgC;YAChC,IAAI,SAAS,GAAG,IAAA,qBAAa,EAAC,aAAa,EAAE;gBAC3C,KAAK,EAAE,CAAE,IAAA,2BAAgB,GAAE,CAAE;aAC9B,CAAC,CAAC;YACH,wDAAwD;YACxD,qEAAqE;YACrE,6DAA6D;YAC7D,kNAAkN;YAClN,SAAS,GAAG,IAAA,wBAAa,EAAC,SAAS,CAAC,CAAC,IAAI,CAAC;YAC1C,uDAAuD;YACvD,IAAI,CAAC,cAAc,CAAC,eAAe,CAAC,CAAC;YACrC,IAAI,CAAC,cAAc,CAAC,YAAY,SAAS,EAAE,CAAC,CAAC;QAC/C,CAAC;QAED,IAAI,KAAK,CAAC,YAAY,KAAK,SAAS,EAAE,CAAC;YACrC,IAAI,OAAO,IAAI,CAAC,MAAM,CAAC,YAAY,KAAK,SAAS,EAAE,CAAC;gBAClD,6DAA6D;gBAC7D,KAAK,CAAC,YAAY,GAAG,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC;gBAC9C,KAAK,CAAC,kDAAkD,EAAE,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;YACtF,CAAC;QACH,CAAC;QACD,IAAI,KAAK,CAAC,YAAY,EAAE,CAAC;YACvB,MAAM,MAAM,GAAG,IAAA,qBAAa,EAAC,wBAAwB,EAAE;gBACrD,KAAK,EAAE;oBACL,KAAK,CAAC,IAAI;oBACV,IAAA,2BAAgB,GAAE;iBACnB;aACF,CAAC,CAAC;YACH,KAAK,CAAC,mBAAmB,EAAE,MAAM,CAAC,CAAC;YACnC,MAAM,IAAA,qBAAS,EAAC,QAAQ,MAAM,EAAE,CAAC,CAAC;QACpC,CAAC;QAED,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;YACvB,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAE,IAAI,CAAC,MAAM,CAAC,MAAM,CAAE,CAAC;YAChG,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;gBAC7B,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,qBAAqB,MAAM,EAAE,CAAC,CAAC;YAC1D,CAAC;QACH,CAAC;QAED,IAAI,gBAAgB,GAAG,KAAK,CAAC;QAC7B,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;YAClB,IAAI,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;YACjC,gBAAgB,GAAG,IAAI,CAAC;QAC1B,CAAC;QACD,IAAI,KAAK,CAAC,aAAa,CAAC,EAAE,CAAC;YACzB,IAAI,CAAC,cAAc,CAAC,eAAe,CAAC,CAAC;YACrC,gBAAgB,GAAG,IAAI,CAAC;QAC1B,CAAC;QACD,IAAI,gBAAgB,EAAE,CAAC;YACrB,OAAO,CAAC,GAAG,CAAC,KAAK,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC;YACjC,KAAK,CAAC,qCAAqC,CAAC,CAAC;QAC/C,CAAC;aAAM,IAAI,IAAI,CAAC,GAAG,CAAC,aAAa,EAAE,CAAC;YAClC,sIAAsI;YACtI,OAAO,CAAC,GAAG,CAAC,KAAK,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC;YACjC,KAAK,CAAC,uDAAuD,EAAE,IAAI,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;QACzF,CAAC;QAED,KAAK,CAAC,wBAAwB,EAAE,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;QACxD,KAAK,CAAC,sBAAsB,EAAE,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;QACrD,KAAK,CAAC,4BAA4B,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;QACjD,KAAK,CAAC,wBAAwB,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC;IAC3C,CAAC;IAES,KAAK,CAAC,KAAK,CAAC,GAAgC;QACpD,yDAAyD;QACzD,mDAAmD;QACnD,OAAO,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAC1B,CAAC;IAES,KAAK,CAAC,OAAO,CAAC,CAAoB;QAC1C,8EAA8E;QAC9E,OAAO,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IAC1B,CAAC;IAES,KAAK,CAAC,cAAc;QAC5B,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,IAAI,EAAE,CAAC;QAC1C,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,IAAI,EAAE,CAAC;QACxC,IAAI,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC,OAAmB,IAAI,EAAE,CAAC;QACxD,IAAI,OAAO,WAAW,KAAK,QAAQ,EAAE,CAAC;YACpC,WAAW,GAAG,CAAE,WAAW,CAAE,CAAC;QAChC,CAAC;QACD,IAAI,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,MAAkB,IAAI,EAAE,CAAC;QACtD,IAAI,OAAO,UAAU,KAAK,QAAQ,EAAE,CAAC;YACnC,UAAU,GAAG,CAAE,UAAU,CAAE,CAAC;QAC9B,CAAC;QACD,OAAO;YACL,GAAG,QAAQ;YACX,GAAG,OAAO;YACV,GAAG,WAAW;YACd,GAAG,UAAU;SACd,CAAC;IACJ,CAAC;IAES,kBAAkB,CAAC,UAAkB;QAC7C,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;YACf,OAAO,YAAY,IAAA,wBAAa,EAAC,UAAU,CAAC,CAAC,IAAI,EAAE,CAAC;QACtD,CAAC;QACD,OAAO,aAAa,UAAU,EAAE,CAAC;IACnC,CAAC;IAES,cAAc,CAAC,OAAe;QACtC,IAAI,IAAI,CAAC,GAAG,CAAC,YAAY,EAAE,CAAC;YAC1B,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;gBAC7C,IAAI,CAAC,GAAG,CAAC,YAAY,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,YAAY,IAAI,OAAO,EAAE,CAAC;YAChE,CAAC;QACH,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,GAAG,CAAC,YAAY,GAAG,OAAO,CAAC;QAClC,CAAC;IACH,CAAC;IAES,KAAK,CAAC,QAAQ,CAAC,UAAkB,EAAE,QAAkB,EAAE,UAA2B,EAAE;QAC5F,MAAM,GAAG,GAAG;YACV,GAAG,IAAI,CAAC,GAAG;YACX,GAAG,OAAO,CAAC,GAAG;SACf,CAAC;QACF,MAAM,YAAY,GAAG;YACnB,GAAG,IAAI,CAAC,cAAc;YACtB,GAAG,OAAO,CAAC,QAAQ,IAAI,EAAE;SAC1B,CAAC;QACF,MAAM,YAAY,GAAG,GAAG,CAAC,YAAY,CAAC,CAAC,CAAC,iBAAiB,GAAG,CAAC,YAAY,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC;QACnF,MAAM,kBAAkB,GAAG,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,GAAG,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC;QAC1F,MAAM,cAAc,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC7D,MAAM,WAAW,GAAG,GAAG,YAAY,GAAG,OAAO,CAAC,QAAQ,GAAG,kBAAkB,GAAG,UAAU,IAAI,cAAc,EAAE,CAAC;QAC7G,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;YACnB,OAAO,CAAC,GAAG,CAAC,eAAe,EAAE,WAAW,CAAC,CAAC;YAC1C,OAAO;QACT,CAAC;QAED,OAAO,GAAG;YACR,KAAK,EAAE,SAAS;YAChB,GAAG;YACH,GAAG,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI;YACpB,GAAG,OAAO;YACV,QAAQ,EAAE,YAAY;SACvB,CAAC;QACF,MAAM,IAAI,GAAG,IAAA,yBAAI,EAAC,UAAU,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;QACjD,KAAK,CAAC,8BAA8B,EAClC,IAAI,CAAC,GAAG,EACR,WAAW,CAAC,CAAC;QACf,QAAQ,CAAC,IAAI,CAAC,CAAC;QAEf,OAAO,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YAC3C,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE;gBACvB,KAAK,CAAC,2BAA2B,EAAE,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;gBACnD,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;gBACtB,IAAI,IAAI,KAAK,CAAC,EAAE,CAAC;oBACf,MAAM,GAAG,GAAG,IAAI,SAAS,CAAC,UAAU,GAAG,GAAG,GAAG,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,kBAAkB,GAAG,IAAI,EAAE,IAAI,CAAC,CAAC;oBACnG,MAAM,CAAC,GAAG,CAAC,CAAC;gBACd,CAAC;qBAAM,CAAC;oBACN,OAAO,EAAE,CAAC;gBACZ,CAAC;YACH,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC;;AA3UH,kCA4UC"}

package/dist/commonjs/commands/cov.d.ts

@@ -0,0 +1,22 @@
+import Test from './test.js';
+import { ForkNodeOptions } from '../baseCommand.js';
+export default class Cov<T extends typeof Cov> extends Test<T> {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        prerequire: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        exclude: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        c8: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        bail: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        timeout: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        'no-timeout': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        grep: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        changed: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        mochawesome: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        parallel: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        jobs: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        'auto-agent': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    protected get defaultExcludes(): string[];
+    protected forkNode(modulePath: string, forkArgs: string[], options?: ForkNodeOptions): Promise<void>;
+}

package/dist/commonjs/commands/cov.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_path_1 = __importDefault(require("node:path"));
+const promises_1 = __importDefault(require("node:fs/promises"));
+const core_1 = require("@oclif/core");
+const test_js_1 = __importDefault(require("./test.js"));
+const utils_1 = require("@eggjs/utils");
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+class Cov extends test_js_1.default {
+    static description = 'Run the test with coverage';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> test/index.test.ts',
+    ];
+    static flags = {
+        ...test_js_1.default.flags,
+        // will use on egg-mock https://github.com/eggjs/egg-mock/blob/84a64bd19d0569ec94664c898fb1b28367b95d60/index.js#L7
+        prerequire: core_1.Flags.boolean({
+            description: 'prerequire files for coverage instrument',
+        }),
+        exclude: core_1.Flags.string({
+            description: 'coverage ignore, one or more files patterns`',
+            multiple: true,
+            char: 'x',
+        }),
+        c8: core_1.Flags.string({
+            description: 'c8 instruments passthrough`',
+            default: '--temp-directory node_modules/.c8_output -r text-summary -r json-summary -r json -r lcov -r cobertura',
+        }),
+    };
+    get defaultExcludes() {
+        return [
+            'example/',
+            'examples/',
+            'mocks**/',
+            'docs/',
+            // https://github.com/JaKXz/test-exclude/blob/620a7be412d4fc2070d50f0f63e3228314066fc9/index.js#L73
+            'test/**',
+            'test{,-*}.js',
+            '**/*.test.js',
+            '**/__tests__/**',
+            '**/node_modules/**',
+            'typings',
+            '**/*.d.ts',
+        ];
+    }
+    async forkNode(modulePath, forkArgs, options = {}) {
+        const { flags } = this;
+        if (flags.prerequire) {
+            this.env.EGG_BIN_PREREQUIRE = 'true';
+        }
+        // add c8 args
+        // https://github.com/eggjs/egg/issues/3930
+        const c8Args = [
+            // '--show-process-tree',
+            ...flags.c8.split(' ').filter(a => a.trim()),
+        ];
+        if (flags.typescript) {
+            this.env.SPAWN_WRAP_SHIM_ROOT = node_path_1.default.join(flags.base, 'node_modules');
+            c8Args.push('--extension');
+            c8Args.push('.ts');
+        }
+        const excludes = new Set([
+            ...process.env.COV_EXCLUDES?.split(',') ?? [],
+            ...this.defaultExcludes,
+            ...Array.from(flags.exclude ?? []),
+        ]);
+        for (const exclude of excludes) {
+            c8Args.push('-x');
+            c8Args.push(exclude);
+        }
+        const c8File = (0, utils_1.importResolve)('c8/bin/c8.js');
+        const outputDir = node_path_1.default.join(flags.base, 'node_modules/.c8_output');
+        await promises_1.default.rm(outputDir, { force: true, recursive: true });
+        const coverageDir = node_path_1.default.join(flags.base, 'coverage');
+        await promises_1.default.rm(coverageDir, { force: true, recursive: true });
+        const execArgv = [
+            ...this.globalExecArgv,
+            ...options.execArgv || [],
+        ];
+        this.globalExecArgv = [];
+        // $ c8 node mocha
+        await super.forkNode(c8File, [
+            ...c8Args,
+            process.execPath,
+            ...execArgv,
+            modulePath,
+            ...forkArgs,
+        ]);
+    }
+}
+exports.default = Cov;
+//# sourceMappingURL=data:application/json;base64,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