@oclif/core 3.0.0-beta.1 → 3.0.0-beta.10

package/lib/config/plugin.js

@@ -90,7 +90,6 @@ async function findRoot(name, root) {
 class Plugin {
     constructor(options) {
         this.options = options;
-        // static loadedPlugins: {[name: string]: Plugin} = {}
         this._base = `${_pjson.name}@${_pjson.version}`;
         this.valid = false;
         this.alreadyLoaded = false;
@@ -100,26 +99,22 @@ class Plugin {
         this._debug = (0, util_2.Debug)();
         this.warned = false;
     }
-    /**
-     * Loads a plugin
-     * @param isWritingManifest - if true, exclude selected data from manifest
-     * default is false to maintain backwards compatibility
-     * @returns Promise<void>
-     */
-    async load(isWritingManifest) {
+    async load() {
         this.type = this.options.type || 'core';
         this.tag = this.options.tag;
         const root = await findRoot(this.options.name, this.options.root);
         if (!root)
-            throw new Error(`could not find package.json with ${(0, util_1.inspect)(this.options)}`);
+            throw new errors_1.CLIError(`could not find package.json with ${(0, util_1.inspect)(this.options)}`);
         this.root = root;
         this._debug('reading %s plugin %s', this.type, root);
         this.pjson = await (0, util_3.loadJSON)(path.join(root, 'package.json'));
+        this.flexibleTaxonomy = this.options?.flexibleTaxonomy || this.pjson.oclif?.flexibleTaxonomy || false;
+        this.moduleType = this.pjson.type === 'module' ? 'module' : 'commonjs';
         this.name = this.pjson.name;
         this.alias = this.options.name ?? this.pjson.name;
         const pjsonPath = path.join(root, 'package.json');
         if (!this.name)
-            throw new Error(`no name in ${pjsonPath}`);
+            throw new errors_1.CLIError(`no name in ${pjsonPath}`);
         if (!(0, util_4.isProd)() && !this.pjson.files)
             this.warn(`files attribute must be specified in ${pjsonPath}`);
         // eslint-disable-next-line new-cap
@@ -132,7 +127,7 @@ class Plugin {
             this.pjson.oclif = this.pjson['cli-engine'] || {};
         }
         this.hooks = (0, util_3.mapValues)(this.pjson.oclif.hooks || {}, i => Array.isArray(i) ? i : [i]);
-        this.manifest = await this._manifest(Boolean(this.options.ignoreManifest), Boolean(this.options.errorOnManifestCreate), isWritingManifest);
+        this.manifest = await this._manifest();
         this.commands = Object
             .entries(this.manifest.commands)
             .map(([id, c]) => ({
@@ -149,13 +144,13 @@ class Plugin {
     get commandsDir() {
         if (this._commandsDir)
             return this._commandsDir;
-        this._commandsDir = (0, ts_node_1.tsPath)(this.root, this.pjson.oclif.commands, this.type);
+        this._commandsDir = (0, ts_node_1.tsPath)(this.root, this.pjson.oclif.commands, this);
         return this._commandsDir;
     }
     get commandIDs() {
         if (!this.commandsDir)
             return [];
-        const marker = performance_1.Performance.mark(`plugin.commandIDs#${this.name}`, { plugin: this.name });
+        const marker = performance_1.default.mark(`plugin.commandIDs#${this.name}`, { plugin: this.name });
         this._debug(`loading IDs from ${this.commandsDir}`);
         const patterns = [
             '**/*.+(js|cjs|mjs|ts|tsx)',
@@ -175,7 +170,7 @@ class Plugin {
         return ids;
     }
     async findCommand(id, opts = {}) {
-        const marker = performance_1.Performance.mark(`plugin.findCommand#${this.name}.${id}`, { id, plugin: this.name });
+        const marker = performance_1.default.mark(`plugin.findCommand#${this.name}.${id}`, { id, plugin: this.name });
         const fetch = async () => {
             if (!this.commandsDir)
                 return;
@@ -211,7 +206,10 @@ class Plugin {
         marker?.stop();
         return cmd;
     }
-    async _manifest(ignoreManifest, errorOnManifestCreate = false, isWritingManifest = false) {
+    async _manifest() {
+        const ignoreManifest = Boolean(this.options.ignoreManifest);
+        const errorOnManifestCreate = Boolean(this.options.errorOnManifestCreate);
+        const respectNoCacheDefault = Boolean(this.options.respectNoCacheDefault);
         const readManifest = async (dotfile = false) => {
             try {
                 const p = path.join(this.root, `${dotfile ? '.' : ''}oclif.manifest.json`);
@@ -235,7 +233,7 @@ class Plugin {
                 }
             }
         };
-        const marker = performance_1.Performance.mark(`plugin.manifest#${this.name}`, { plugin: this.name });
+        const marker = performance_1.default.mark(`plugin.manifest#${this.name}`, { plugin: this.name });
         if (!ignoreManifest) {
             const manifest = await readManifest();
             if (manifest) {
@@ -248,7 +246,13 @@ class Plugin {
             version: this.version,
             commands: (await Promise.all(this.commandIDs.map(async (id) => {
                 try {
-                    return [id, await (0, config_1.toCached)(await this.findCommand(id, { must: true }), this, isWritingManifest)];
+                    const cached = await (0, config_1.toCached)(await this.findCommand(id, { must: true }), this, respectNoCacheDefault);
+                    if (this.flexibleTaxonomy) {
+                        const permutations = (0, util_2.getCommandIdPermutations)(id);
+                        const aliasPermutations = cached.aliases.flatMap(a => (0, util_2.getCommandIdPermutations)(a));
+                        return [id, { ...cached, permutations, aliasPermutations }];
+                    }
+                    return [id, cached];
                 }
                 catch (error) {
                     const scope = 'toCached';

package/lib/config/ts-node.d.ts

@@ -1,7 +1,8 @@
+import { Plugin } from '../interfaces';
 /**
  * Convert a path from the compiled ./lib files to the ./src typescript source
  * this is for developing typescript plugins/CLIs
  * if there is a tsconfig and the original sources exist, it attempts to require ts-node
  */
-export declare function tsPath(root: string, orig: string, type?: string): string;
-export declare function tsPath(root: string, orig: string | undefined, type?: string): string | undefined;
+export declare function tsPath(root: string, orig: string, plugin: Plugin): string;
+export declare function tsPath(root: string, orig: string | undefined, plugin?: Plugin): string | undefined;

package/lib/config/ts-node.js

@@ -6,11 +6,15 @@ const path = require("path");
 const settings_1 = require("../settings");
 const util_1 = require("../util");
 const util_2 = require("./util");
+const config_1 = require("./config");
+const errors_1 = require("../errors");
 // eslint-disable-next-line new-cap
 const debug = (0, util_2.Debug)('ts-node');
-const TYPE_ROOTS = [`${__dirname}/../node_modules/@types`];
-const ROOT_DIRS = [];
+const TS_CONFIGS = {};
+const REGISTERED = new Set();
 function loadTSConfig(root) {
+    if (TS_CONFIGS[root])
+        return TS_CONFIGS[root];
     const tsconfigPath = path.join(root, 'tsconfig.json');
     let typescript;
     try {
@@ -18,7 +22,7 @@ function loadTSConfig(root) {
     }
     catch {
         try {
-            typescript = require(root + '/node_modules/typescript');
+            typescript = require(path.join(root, 'node_modules', 'typescript'));
         }
         catch { }
     }
@@ -28,6 +32,7 @@ function loadTSConfig(root) {
             throw new Error(`Could not read and parse tsconfig.json at ${tsconfigPath}, or it ` +
                 'did not contain a "compilerOptions" section.');
         }
+        TS_CONFIGS[root] = tsconfig;
         return tsconfig;
     }
 }
@@ -35,54 +40,96 @@ function registerTSNode(root) {
     const tsconfig = loadTSConfig(root);
     if (!tsconfig)
         return;
+    if (REGISTERED.has(root))
+        return tsconfig;
     debug('registering ts-node at', root);
     const tsNodePath = require.resolve('ts-node', { paths: [root, __dirname] });
+    debug('ts-node path:', tsNodePath);
     const tsNode = require(tsNodePath);
-    TYPE_ROOTS.push(`${root}/node_modules/@types`);
+    const typeRoots = [
+        path.join(root, 'node_modules', '@types'),
+    ];
+    const rootDirs = [];
     if (tsconfig.compilerOptions.rootDirs) {
-        ROOT_DIRS.push(...tsconfig.compilerOptions.rootDirs.map(r => path.join(root, r)));
+        for (const r of tsconfig.compilerOptions.rootDirs) {
+            rootDirs.push(path.join(root, r));
+        }
+    }
+    else if (tsconfig.compilerOptions.rootDir) {
+        rootDirs.push(path.join(root, tsconfig.compilerOptions.rootDir));
     }
     else {
-        ROOT_DIRS.push(`${root}/src`);
+        rootDirs.push(path.join(root, 'src'));
     }
-    const cwd = process.cwd();
-    try {
-        process.chdir(root);
-        tsNode.register({
-            skipProject: true,
-            transpileOnly: true,
-            compilerOptions: {
-                esModuleInterop: tsconfig.compilerOptions.esModuleInterop,
-                target: tsconfig.compilerOptions.target || 'es2017',
-                experimentalDecorators: tsconfig.compilerOptions.experimentalDecorators || false,
-                emitDecoratorMetadata: tsconfig.compilerOptions.emitDecoratorMetadata || false,
-                module: 'commonjs',
-                sourceMap: true,
-                rootDirs: ROOT_DIRS,
-                typeRoots: TYPE_ROOTS,
-                jsx: 'react',
-            },
-        });
-        return tsconfig;
+    const conf = {
+        compilerOptions: {
+            esModuleInterop: tsconfig.compilerOptions.esModuleInterop,
+            target: tsconfig.compilerOptions.target ?? 'es2019',
+            experimentalDecorators: tsconfig.compilerOptions.experimentalDecorators ?? false,
+            emitDecoratorMetadata: tsconfig.compilerOptions.emitDecoratorMetadata ?? false,
+            module: tsconfig.compilerOptions.module ?? 'commonjs',
+            sourceMap: tsconfig.compilerOptions.sourceMap ?? true,
+            rootDirs,
+            typeRoots,
+        },
+        skipProject: true,
+        transpileOnly: true,
+        esm: tsconfig['ts-node']?.esm ?? true,
+        scope: true,
+        scopeDir: root,
+        cwd: root,
+        experimentalSpecifierResolution: tsconfig['ts-node']?.experimentalSpecifierResolution ?? 'explicit',
+    };
+    if (tsconfig.compilerOptions.moduleResolution) {
+        // @ts-expect-error TSNode.RegisterOptions.compilerOptions is typed as a plain object
+        conf.compilerOptions.moduleResolution = tsconfig.compilerOptions.moduleResolution;
     }
-    finally {
-        process.chdir(cwd);
+    if (tsconfig.compilerOptions.jsx) {
+        // @ts-expect-error TSNode.RegisterOptions.compilerOptions is typed as a plain object
+        conf.compilerOptions.jsx = tsconfig.compilerOptions.jsx;
     }
+    tsNode.register(conf);
+    REGISTERED.add(root);
+    return tsconfig;
 }
-function tsPath(root, orig, type) {
+// eslint-disable-next-line complexity
+function tsPath(root, orig, plugin) {
     if (!orig)
         return orig;
     orig = orig.startsWith(root) ? orig : path.join(root, orig);
-    const skipTSNode = 
-    // the CLI specifically turned it off
-    (settings_1.settings.tsnodeEnabled === false) ||
-        // the CLI didn't specify ts-node and it is production
-        (settings_1.settings.tsnodeEnabled === undefined && (0, util_1.isProd)());
-    // We always want to load the tsconfig for linked plugins.
-    if (skipTSNode && type !== 'link')
+    // NOTE: The order of these checks matter!
+    if (settings_1.settings.tsnodeEnabled === false) {
+        debug(`Skipping ts-node registration for ${root} because tsNodeEnabled is explicitly set to false`);
+        return orig;
+    }
+    // Skip ts-node registration if plugin is an ESM plugin executing from a CJS plugin
+    if (plugin?.moduleType === 'module' && config_1.Config.rootPlugin?.moduleType === 'commonjs') {
+        debug(`Skipping ts-node registration for ${root} because it's an ESM module but the root plugin is CommonJS`);
+        if (plugin.type === 'link')
+            (0, errors_1.memoizedWarn)(`${plugin.name} is a linked ESM module and cannot be auto-compiled from a CommonJS root plugin. Existing compiled source will be used instead.`);
         return orig;
+    }
+    // If plugin is an ESM plugin being executed from an ESM root plugin, check to see if ts-node/esm loader has been set
+    // either in the NODE_OPTIONS env var or from the exec args. If the ts-node/esm loader has NOT been loaded then we want
+    // to skip ts-node registration so that it falls back on the compiled source.
+    if (plugin?.moduleType === 'module') {
+        const tsNodeEsmLoaderInExecArgv = process.execArgv.includes('--loader') && process.execArgv.includes('ts-node/esm');
+        const tsNodeEsmLoaderInNodeOptions = process.env.NODE_OPTIONS?.includes('--loader=ts-node/esm') ?? false;
+        if (!tsNodeEsmLoaderInExecArgv && !tsNodeEsmLoaderInNodeOptions) {
+            debug(`Skipping ts-node registration for ${root} because it's an ESM module but the ts-node/esm loader hasn't been run`);
+            debug('try setting NODE_OPTIONS="--loader ts-node/esm" in your environment.');
+            if (plugin.type === 'link') {
+                (0, errors_1.memoizedWarn)(`${plugin.name} is a linked ESM module and cannot be auto-compiled without setting NODE_OPTIONS="--loader=ts-node/esm" in the environment. Existing compiled source will be used instead.`);
+            }
+            return orig;
+        }
+    }
+    if (settings_1.settings.tsnodeEnabled === undefined && (0, util_1.isProd)() && plugin?.type !== 'link') {
+        debug(`Skipping ts-node registration for ${root} because NODE_ENV is NOT "test" or "development"`);
+        return orig;
+    }
     try {
-        const tsconfig = type === 'link' ? registerTSNode(root) : loadTSConfig(root);
+        const tsconfig = registerTSNode(root);
         if (!tsconfig)
             return orig;
         const { rootDir, rootDirs, outDir } = tsconfig.compilerOptions;

package/lib/errors/errors/cli.d.ts

@@ -8,6 +8,7 @@ export declare function addOclifExitCode(error: Record<string, any>, options?: {
 export declare class CLIError extends Error implements OclifError {
     oclif: OclifError['oclif'];
     code?: string;
+    suggestions?: string[];
     constructor(error: string | Error, options?: {
         exit?: number | false;
     } & PrettyPrintableError);

package/lib/errors/errors/cli.js

@@ -24,6 +24,7 @@ class CLIError extends Error {
         this.oclif = {};
         addOclifExitCode(this, options);
         this.code = options.code;
+        this.suggestions = options.suggestions;
     }
     get stack() {
         return cs(super.stack, { pretty: true });

package/lib/errors/handle.d.ts

@@ -1,4 +1,4 @@
 import { OclifError, PrettyPrintableError } from '../interfaces';
-export declare const handle: (err: Error & Partial<PrettyPrintableError> & Partial<OclifError> & {
+export declare function handle(err: Error & Partial<PrettyPrintableError> & Partial<OclifError> & {
     skipOclifErrorHandling?: boolean;
-}) => void;
+}): Promise<void>;

package/lib/errors/handle.js

@@ -8,7 +8,7 @@ const pretty_print_1 = require("./errors/pretty-print");
 const _1 = require(".");
 const clean = require("clean-stack");
 const cli_1 = require("./errors/cli");
-const handle = (err) => {
+async function handle(err) {
     try {
         if (!err)
             err = new cli_1.CLIError('no error?');
@@ -25,7 +25,7 @@ const handle = (err) => {
             if (stack) {
                 config_1.config.errorLogger.log(stack);
             }
-            config_1.config.errorLogger.flush()
+            await config_1.config.errorLogger.flush()
                 .then(() => process.exit(exitCode))
                 .catch(console.error);
         }
@@ -37,5 +37,5 @@ const handle = (err) => {
         console.error(error.stack);
         process.exit(1);
     }
-};
+}
 exports.handle = handle;

package/lib/errors/index.d.ts

@@ -14,3 +14,4 @@ export declare function error(input: string | Error, options?: {
     exit?: number;
 } & PrettyPrintableError): never;
 export declare function warn(input: string | Error): void;
+export declare function memoizedWarn(input: string | Error): void;

package/lib/errors/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.warn = exports.error = exports.exit = exports.config = exports.Logger = exports.CLIError = exports.ModuleLoadError = exports.ExitError = exports.handle = void 0;
+exports.memoizedWarn = exports.warn = exports.error = exports.exit = exports.config = exports.Logger = exports.CLIError = exports.ModuleLoadError = exports.ExitError = exports.handle = void 0;
 var handle_1 = require("./handle");
 Object.defineProperty(exports, "handle", { enumerable: true, get: function () { return handle_1.handle; } });
 var exit_1 = require("./errors/exit");
@@ -60,3 +60,10 @@ function warn(input) {
         config_2.config.errorLogger.log(err?.stack ?? '');
 }
 exports.warn = warn;
+const WARNINGS = new Set();
+function memoizedWarn(input) {
+    if (!WARNINGS.has(input))
+        warn(input);
+    WARNINGS.add(input);
+}
+exports.memoizedWarn = memoizedWarn;

package/lib/errors/logger.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Logger = void 0;
-const fs = require("fs-extra");
-const path = require("path");
+const fs = require("fs/promises");
+const path_1 = require("path");
 const stripAnsi = require("strip-ansi");
 const timestamp = () => new Date().toISOString();
 let timer;
@@ -35,7 +35,7 @@ class Logger {
                 return;
             const mylines = this.buffer;
             this.buffer = [];
-            await fs.mkdirp(path.dirname(this.file));
+            await fs.mkdir((0, path_1.dirname)(this.file), { recursive: true });
             await fs.appendFile(this.file, mylines.join('\n') + '\n');
         });
         await this.flushing;

package/lib/execute.d.ts

@@ -0,0 +1,49 @@
+import * as Interfaces from './interfaces';
+/**
+ * Load and run oclif CLI
+ *
+ * @param options - options to load the CLI
+ * @returns Promise<void>
+ *
+ * @example For ESM dev.js
+ * ```
+ * #!/usr/bin/env node
+ * void (async () => {
+ *   const oclif = await import('@oclif/core')
+ *   await oclif.execute({development: true, dir: import.meta.url})
+ * })()
+ * ```
+ *
+ * @example For ESM run.js
+ * ```
+ * #!/usr/bin/env node
+ * void (async () => {
+ *   const oclif = await import('@oclif/core')
+ *   await oclif.execute({dir: import.meta.url})
+ * })()
+ * ```
+ *
+ * @example For CJS dev.js
+ * ```
+ * #!/usr/bin/env 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 default function execute(options: {
+    dir: string;
+    args?: string[];
+    loadOptions?: Interfaces.LoadOptions;
+    development?: boolean;
+}): Promise<unknown>;

package/lib/execute.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const settings_1 = require("./settings");
+const flush_1 = require("./cli-ux/flush");
+const handle_1 = require("./errors/handle");
+const main_1 = require("./main");
+/**
+ * Load and run oclif CLI
+ *
+ * @param options - options to load the CLI
+ * @returns Promise<void>
+ *
+ * @example For ESM dev.js
+ * ```
+ * #!/usr/bin/env node
+ * void (async () => {
+ *   const oclif = await import('@oclif/core')
+ *   await oclif.execute({development: true, dir: import.meta.url})
+ * })()
+ * ```
+ *
+ * @example For ESM run.js
+ * ```
+ * #!/usr/bin/env node
+ * void (async () => {
+ *   const oclif = await import('@oclif/core')
+ *   await oclif.execute({dir: import.meta.url})
+ * })()
+ * ```
+ *
+ * @example For CJS dev.js
+ * ```
+ * #!/usr/bin/env 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.development) {
+        // In dev mode -> use ts-node and dev plugins
+        process.env.NODE_ENV = 'development';
+        settings_1.settings.debug = true;
+    }
+    return (0, main_1.default)(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));
+}
+exports.default = execute;

package/lib/flags.js

@@ -4,6 +4,7 @@ exports.help = exports.version = exports.string = exports.url = exports.file = e
 const url_1 = require("url");
 const help_1 = require("./help");
 const util_1 = require("./util");
+const errors_1 = require("./errors");
 function custom(defaults) {
     return (options = {}) => {
         return {
@@ -29,12 +30,12 @@ exports.boolean = boolean;
 exports.integer = custom({
     parse: async (input, _, opts) => {
         if (!/^-?\d+$/.test(input))
-            throw new Error(`Expected an integer but received: ${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 Error(`Expected an integer greater than or equal to ${opts.min} but received: ${input}`);
+            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 Error(`Expected an integer less than or equal to ${opts.max} but received: ${input}`);
+            throw new errors_1.CLIError(`Expected an integer less than or equal to ${opts.max} but received: ${input}`);
         return num;
     },
 });
@@ -84,7 +85,8 @@ const help = (opts = {}) => {
         description: 'Show CLI help.',
         ...opts,
         parse: async (_, cmd) => {
-            new help_1.Help(cmd.config).showHelp(cmd.id ? [cmd.id, ...cmd.argv] : cmd.argv);
+            const Help = await (0, help_1.loadHelpClass)(cmd.config);
+            await new Help(cmd.config, cmd.config.pjson.helpOptions).showHelp(cmd.id ? [cmd.id, ...cmd.argv] : cmd.argv);
             cmd.exit(0);
         },
     });

package/lib/help/index.js

@@ -91,7 +91,7 @@ class Help extends HelpBase {
         const command = this.config.findCommand(subject);
         if (command) {
             if (command.hasDynamicHelp && command.pluginType !== 'jit') {
-                const dynamicCommand = await (0, config_1.toCached)(await command.load(), undefined, false);
+                const dynamicCommand = await (0, config_1.toCached)(await command.load());
                 await this.showCommandHelp(dynamicCommand);
             }
             else {
@@ -123,7 +123,7 @@ class Help extends HelpBase {
         const depth = name.split(':').length;
         const subTopics = this.sortedTopics.filter(t => t.name.startsWith(name + ':') && t.name.split(':').length === depth + 1);
         const subCommands = this.sortedCommands.filter(c => c.id.startsWith(name + ':') && c.id.split(':').length === depth + 1);
-        const plugin = this.config.plugins.find(p => p.name === command.pluginName);
+        const plugin = this.config.plugins.get(command.pluginName);
         const state = this.config.pjson?.oclif?.state || plugin?.pjson?.oclif?.state || command.state;
         if (state) {
             this.log(state === 'deprecated' ?

package/lib/index.d.ts

@@ -1,5 +1,7 @@
 import { Command } from './command';
-import { run, execute } from './main';
+import run from './main';
+import execute from './execute';
+import { handle } from './errors/handle';
 import { Config, Plugin, tsPath, toCached } from './config';
 import * as Interfaces from './interfaces';
 import * as Errors from './errors';
@@ -13,6 +15,6 @@ import { settings, Settings } from './settings';
 import { HelpSection, HelpSectionRenderer, HelpSectionKeyValueTable } from './help/formatter';
 import * as ux from './cli-ux';
 import { stderr, stdout } from './cli-ux/stream';
-import { Performance } from './performance';
-declare const flush: typeof ux.ux.flush;
-export { Args, Command, CommandHelp, Config, Errors, Flags, loadHelpClass, Help, HelpBase, HelpSection, HelpSectionRenderer, HelpSectionKeyValueTable, Hook, Interfaces, Parser, Plugin, Performance, run, toCached, tsPath, toStandardizedId, toConfiguredId, settings, Settings, flush, ux, execute, stderr, stdout, };
+import Performance from './performance';
+import { flush } from './cli-ux/flush';
+export { Args, Command, CommandHelp, Config, Errors, execute, Flags, flush, handle, Help, HelpBase, HelpSection, HelpSectionKeyValueTable, HelpSectionRenderer, Hook, Interfaces, loadHelpClass, Parser, Performance, Plugin, run, settings, Settings, stderr, stdout, toCached, toConfiguredId, toStandardizedId, tsPath, ux, };

package/lib/index.js

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.stdout = exports.stderr = exports.execute = exports.ux = exports.flush = exports.settings = exports.toConfiguredId = exports.toStandardizedId = exports.tsPath = exports.toCached = exports.run = exports.Performance = exports.Plugin = exports.Parser = exports.Interfaces = exports.HelpBase = exports.Help = exports.loadHelpClass = exports.Flags = exports.Errors = exports.Config = exports.CommandHelp = exports.Command = exports.Args = void 0;
-const semver = require("semver");
+exports.ux = exports.tsPath = exports.toStandardizedId = exports.toConfiguredId = exports.toCached = exports.stdout = exports.stderr = exports.settings = exports.run = exports.Plugin = exports.Performance = exports.Parser = exports.loadHelpClass = exports.Interfaces = exports.HelpBase = exports.Help = exports.handle = exports.flush = exports.Flags = exports.execute = exports.Errors = exports.Config = exports.CommandHelp = exports.Command = exports.Args = void 0;
 const command_1 = require("./command");
 Object.defineProperty(exports, "Command", { enumerable: true, get: function () { return command_1.Command; } });
 const main_1 = require("./main");
-Object.defineProperty(exports, "run", { enumerable: true, get: function () { return main_1.run; } });
-Object.defineProperty(exports, "execute", { enumerable: true, get: function () { return main_1.execute; } });
+exports.run = main_1.default;
+const execute_1 = require("./execute");
+exports.execute = execute_1.default;
+const handle_1 = require("./errors/handle");
+Object.defineProperty(exports, "handle", { enumerable: true, get: function () { return handle_1.handle; } });
 const config_1 = require("./config");
 Object.defineProperty(exports, "Config", { enumerable: true, get: function () { return config_1.Config; } });
 Object.defineProperty(exports, "Plugin", { enumerable: true, get: function () { return config_1.Plugin; } });
@@ -34,14 +36,13 @@ const settings_1 = require("./settings");
 Object.defineProperty(exports, "settings", { enumerable: true, get: function () { return settings_1.settings; } });
 const ux = require("./cli-ux");
 exports.ux = ux;
-const util_2 = require("./util");
 const stream_1 = require("./cli-ux/stream");
 Object.defineProperty(exports, "stderr", { enumerable: true, get: function () { return stream_1.stderr; } });
 Object.defineProperty(exports, "stdout", { enumerable: true, get: function () { return stream_1.stdout; } });
 const performance_1 = require("./performance");
-Object.defineProperty(exports, "Performance", { enumerable: true, get: function () { return performance_1.Performance; } });
-const flush = ux.flush;
-exports.flush = flush;
+exports.Performance = performance_1.default;
+const flush_1 = require("./cli-ux/flush");
+Object.defineProperty(exports, "flush", { enumerable: true, get: function () { return flush_1.flush; } });
 function checkCWD() {
     try {
         process.cwd();
@@ -52,11 +53,4 @@ function checkCWD() {
         }
     }
 }
-function checkNodeVersion() {
-    const pjson = (0, util_2.requireJson)(__dirname, '..', 'package.json');
-    if (!semver.satisfies(process.versions.node, pjson.engines.node)) {
-        stream_1.stderr.write(`WARNING\nWARNING Node version must be ${pjson.engines.node} to use this CLI\nWARNING Current node version: ${process.versions.node}\nWARNING\n`);
-    }
-}
 checkCWD();
-checkNodeVersion();