@oclif/core 3.0.0-beta.2 → 3.0.0-beta.4

package/lib/config/plugin-loader.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const Plugin = require("./plugin");
+const util_1 = require("./util");
+const util_2 = require("../util");
+const performance_1 = require("../performance");
+// eslint-disable-next-line new-cap
+const debug = (0, util_1.Debug)();
+class PluginLoader {
+    constructor(options) {
+        this.options = options;
+        this.plugins = new Map();
+        this.errors = [];
+        this.pluginsProvided = false;
+        if (options.plugins) {
+            this.pluginsProvided = true;
+            this.plugins = Array.isArray(options.plugins) ? new Map(options.plugins.map(p => [p.name, p])) : options.plugins;
+        }
+    }
+    async loadRoot() {
+        let rootPlugin;
+        if (this.pluginsProvided) {
+            const plugins = [...this.plugins.values()];
+            rootPlugin = plugins.find(p => p.root === this.options.root) ?? plugins[0];
+        }
+        else {
+            rootPlugin = new Plugin.Plugin({ root: this.options.root });
+            await rootPlugin.load();
+        }
+        this.plugins.set(rootPlugin.name, rootPlugin);
+        return rootPlugin;
+    }
+    async loadChildren(opts) {
+        if (!this.pluginsProvided || opts.force) {
+            await this.loadUserPlugins(opts);
+            await this.loadDevPlugins(opts);
+            await this.loadCorePlugins(opts);
+        }
+        return { plugins: this.plugins, errors: this.errors };
+    }
+    async loadCorePlugins(opts) {
+        if (opts.rootPlugin.pjson.oclif.plugins) {
+            await this.loadPlugins(opts.rootPlugin.root, 'core', opts.rootPlugin.pjson.oclif.plugins);
+        }
+    }
+    async loadDevPlugins(opts) {
+        if (opts.devPlugins !== false) {
+            // do not load oclif.devPlugins in production
+            if ((0, util_2.isProd)())
+                return;
+            try {
+                const devPlugins = opts.rootPlugin.pjson.oclif.devPlugins;
+                if (devPlugins)
+                    await this.loadPlugins(opts.rootPlugin.root, 'dev', devPlugins);
+            }
+            catch (error) {
+                process.emitWarning(error);
+            }
+        }
+    }
+    async loadUserPlugins(opts) {
+        if (opts.userPlugins !== false) {
+            try {
+                const userPJSONPath = path.join(opts.dataDir, 'package.json');
+                debug('reading user plugins pjson %s', userPJSONPath);
+                const pjson = await (0, util_1.loadJSON)(userPJSONPath);
+                if (!pjson.oclif)
+                    pjson.oclif = { schema: 1 };
+                if (!pjson.oclif.plugins)
+                    pjson.oclif.plugins = [];
+                await this.loadPlugins(userPJSONPath, 'user', pjson.oclif.plugins.filter((p) => p.type === 'user'));
+                await this.loadPlugins(userPJSONPath, 'link', pjson.oclif.plugins.filter((p) => p.type === 'link'));
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    process.emitWarning(error);
+            }
+        }
+    }
+    async loadPlugins(root, type, plugins, parent) {
+        if (!plugins || plugins.length === 0)
+            return;
+        const mark = performance_1.default.mark(`config.loadPlugins#${type}`);
+        debug('loading plugins', plugins);
+        await Promise.all((plugins || []).map(async (plugin) => {
+            try {
+                const name = typeof plugin === 'string' ? plugin : plugin.name;
+                const opts = {
+                    name,
+                    type,
+                    root,
+                };
+                if (typeof plugin !== 'string') {
+                    opts.tag = plugin.tag || opts.tag;
+                    opts.root = plugin.root || opts.root;
+                }
+                if (this.plugins.has(name))
+                    return;
+                const pluginMarker = performance_1.default.mark(`plugin.load#${name}`);
+                const instance = new Plugin.Plugin(opts);
+                await instance.load();
+                pluginMarker?.addDetails({
+                    hasManifest: instance.hasManifest,
+                    commandCount: instance.commands.length,
+                    topicCount: instance.topics.length,
+                    type: instance.type,
+                    usesMain: Boolean(instance.pjson.main),
+                    name: instance.name,
+                });
+                pluginMarker?.stop();
+                this.plugins.set(instance.name, instance);
+                if (parent) {
+                    instance.parent = parent;
+                    if (!parent.children)
+                        parent.children = [];
+                    parent.children.push(instance);
+                }
+                await this.loadPlugins(instance.root, type, instance.pjson.oclif.plugins || [], instance);
+            }
+            catch (error) {
+                this.errors.push(error);
+            }
+        }));
+        mark?.addDetails({ pluginCount: plugins.length });
+        mark?.stop();
+    }
+}
+exports.default = PluginLoader;

package/lib/config/plugin.d.ts

@@ -1,4 +1,3 @@
-import { CLIError } from '../errors';
 import { Plugin as IPlugin, PluginOptions } from '../interfaces/plugin';
 import { Manifest } from '../interfaces/manifest';
 import { PJSON } from '../interfaces/pjson';
@@ -26,16 +25,11 @@ export declare class Plugin implements IPlugin {
     children: Plugin[];
     hasManifest: boolean;
     private _commandsDir;
+    private flexibleTaxonomy;
     protected _debug: (..._: any) => void;
     protected warned: boolean;
     constructor(options: PluginOptions);
-    /**
-     * Loads a plugin
-     * @param isWritingManifest - if true, exclude selected data from manifest
-     * default is false to maintain backwards compatibility
-     * @returns Promise<void>
-     */
-    load(isWritingManifest?: boolean): Promise<void>;
+    load(): Promise<void>;
     get topics(): Topic[];
     get commandsDir(): string | undefined;
     get commandIDs(): string[];
@@ -45,7 +39,7 @@ export declare class Plugin implements IPlugin {
     findCommand(id: string, opts?: {
         must: boolean;
     }): Promise<Command.Class | undefined>;
-    protected _manifest(ignoreManifest: boolean, errorOnManifestCreate?: boolean, isWritingManifest?: boolean): Promise<Manifest>;
-    protected warn(err: string | Error | CLIError, scope?: string): void;
+    private _manifest;
+    private warn;
     private addErrorScope;
 }

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,27 +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
@@ -133,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]) => ({
@@ -156,7 +150,7 @@ class Plugin {
     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)',
@@ -176,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;
@@ -212,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`);
@@ -236,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) {
@@ -249,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.js

@@ -98,7 +98,7 @@ function tsPath(root, orig, plugin) {
         return orig;
     orig = orig.startsWith(root) ? orig : path.join(root, orig);
     // NOTE: The order of these checks matter!
-    if (settings_1.settings.tsnodeEnabled === false) {
+    if (settings_1.default.tsnodeEnabled === false) {
         debug(`Skipping ts-node registration for ${root} because tsNodeEnabled is explicitly set to false`);
         return orig;
     }
@@ -124,7 +124,7 @@ function tsPath(root, orig, plugin) {
             return orig;
         }
     }
-    if (settings_1.settings.tsnodeEnabled === undefined && (0, util_1.isProd)() && plugin?.type !== 'link') {
+    if (settings_1.default.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;
     }

package/lib/errors/config.js

@@ -15,24 +15,24 @@ function displayWarnings() {
 exports.config = {
     errorLogger: undefined,
     get debug() {
-        return Boolean(settings_1.settings.debug);
+        return Boolean(settings_1.default.debug);
     },
     set debug(enabled) {
-        settings_1.settings.debug = enabled;
+        settings_1.default.debug = enabled;
         if (enabled)
             displayWarnings();
     },
     get errlog() {
-        return settings_1.settings.errlog;
+        return settings_1.default.errlog;
     },
     set errlog(errlog) {
         if (errlog) {
             this.errorLogger = new logger_1.Logger(errlog);
-            settings_1.settings.errlog = errlog;
+            settings_1.default.errlog = errlog;
         }
         else {
             delete this.errorLogger;
-            delete settings_1.settings.errlog;
+            delete settings_1.default.errlog;
         }
     },
 };

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 default function handle(err: Error & Partial<PrettyPrintableError> & Partial<OclifError> & {
     skipOclifErrorHandling?: boolean;
-}) => void;
+}): Promise<void>;

package/lib/errors/handle.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handle = void 0;
 /* eslint-disable no-process-exit */
 /* eslint-disable unicorn/no-process-exit */
 const config_1 = require("./config");
@@ -8,7 +7,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 +24,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 +36,5 @@ const handle = (err) => {
         console.error(error.stack);
         process.exit(1);
     }
-};
-exports.handle = handle;
+}
+exports.default = handle;

package/lib/errors/index.d.ts

@@ -1,4 +1,4 @@
-export { handle } from './handle';
+export { default as handle } from './handle';
 export { ExitError } from './errors/exit';
 export { ModuleLoadError } from './errors/module-load';
 export { CLIError } from './errors/cli';

package/lib/errors/index.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 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; } });
+Object.defineProperty(exports, "handle", { enumerable: true, get: function () { return handle_1.default; } });
 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");

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("./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.default.debug = true;
+    }
+    return (0, main_1.default)(options.args ?? process.argv.slice(2), options.loadOptions ?? options.dir)
+        .then(async (result) => {
+        (0, flush_1.default)();
+        return result;
+    })
+        .catch(async (error) => (0, handle_1.default)(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

@@ -10,7 +10,7 @@ const util_1 = require("../util");
 const util_2 = require("./util");
 const formatter_1 = require("./formatter");
 const config_1 = require("../config/config");
-const stream_1 = require("../cli-ux/stream");
+const stream_1 = require("../ux/stream");
 var command_2 = require("./command");
 Object.defineProperty(exports, "CommandHelp", { enumerable: true, get: function () { return command_2.CommandHelp; } });
 var util_3 = require("./util");
@@ -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';
@@ -9,10 +11,10 @@ import { CommandHelp, HelpBase, Help, loadHelpClass } from './help';
 import { toStandardizedId, toConfiguredId } from './help/util';
 import * as Parser from './parser';
 import { Hook } from './interfaces/hooks';
-import { settings, Settings } from './settings';
+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 ux from './ux';
+import { stderr, stdout } from './ux/stream';
+import Performance from './performance';
+import flush from './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");
+exports.handle = handle_1.default;
 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; } });
@@ -31,17 +33,16 @@ Object.defineProperty(exports, "toConfiguredId", { enumerable: true, get: functi
 const Parser = require("./parser");
 exports.Parser = Parser;
 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");
+exports.settings = settings_1.default;
+const ux_1 = require("./ux");
+exports.ux = ux_1.default;
+const stream_1 = require("./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("./ux/flush");
+exports.flush = flush_1.default;
 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();