@oclif/core 3.0.0-beta.12 → 3.0.0-beta.14

package/lib/main.js

@@ -1,17 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.versionAddition = exports.helpAddition = void 0;
-const url_1 = require("url");
-const util_1 = require("util");
-const url_2 = require("url");
-const config_1 = require("./config");
+exports.run = exports.versionAddition = exports.helpAddition = void 0;
+const node_url_1 = require("node:url");
+const node_util_1 = require("node:util");
 const help_1 = require("./help");
-const stream_1 = require("./cli-ux/stream");
+const config_1 = require("./config");
 const performance_1 = require("./performance");
+const stream_1 = require("./cli-ux/stream");
 const debug = require('debug')('oclif:main');
 const log = (message = '', ...args) => {
-    message = typeof message === 'string' ? message : (0, util_1.inspect)(message);
-    stream_1.stdout.write((0, util_1.format)(message, ...args) + '\n');
+    message = typeof message === 'string' ? message : (0, node_util_1.inspect)(message);
+    stream_1.stdout.write((0, node_util_1.format)(message, ...args) + '\n');
 };
 const helpAddition = (argv, config) => {
     if (argv.length === 0 && !config.pjson.oclif.default)
@@ -35,21 +34,22 @@ const versionAddition = (argv, config) => {
 };
 exports.versionAddition = versionAddition;
 async function run(argv, options) {
-    const marker = performance_1.default.mark('main.run');
-    const initMarker = performance_1.default.mark('main.run#init');
+    const marker = performance_1.Performance.mark('main.run');
+    const initMarker = performance_1.Performance.mark('main.run#init');
     const collectPerf = async () => {
         marker?.stop();
-        initMarker?.stop();
-        await performance_1.default.collect();
-        performance_1.default.debug();
+        if (!initMarker?.stopped)
+            initMarker?.stop();
+        await performance_1.Performance.collect();
+        performance_1.Performance.debug();
     };
     debug(`process.execPath: ${process.execPath}`);
     debug(`process.execArgv: ${process.execArgv}`);
     debug('process.argv: %O', process.argv);
     argv = argv ?? process.argv.slice(2);
     // Handle the case when a file URL string or URL is passed in such as 'import.meta.url'; covert to file path.
-    if (options && ((typeof options === 'string' && options.startsWith('file://')) || options instanceof url_2.URL)) {
-        options = (0, url_1.fileURLToPath)(options);
+    if (options && ((typeof options === 'string' && options.startsWith('file://')) || options instanceof node_url_1.URL)) {
+        options = (0, node_url_1.fileURLToPath)(options);
     }
     const config = await config_1.Config.load(options ?? require.main?.filename ?? __dirname);
     let [id, ...argvSlice] = (0, help_1.normalizeArgv)(config, argv);
@@ -93,4 +93,4 @@ async function run(argv, options) {
         await collectPerf();
     }
 }
-exports.default = run;
+exports.run = run;

package/lib/module-loader.d.ts

@@ -1,81 +1,71 @@
 import { Config as IConfig, Plugin as IPlugin } from './interfaces';
+import { Command } from './command';
 /**
- * Provides a static class with several utility methods to work with Oclif config / plugin to load ESM or CJS Node
- * modules and source files.
+ * Loads and returns a module.
  *
- * @author Michael Leahy <support@typhonjs.io> (https://github.com/typhonrt)
+ * Uses `getPackageType` to determine if `type` is set to 'module. If so loads '.js' files as ESM otherwise uses
+ * a bare require to load as CJS. Also loads '.mjs' files as ESM.
+ *
+ * Uses dynamic import to load ESM source or require for CommonJS.
+ *
+ * A unique error, ModuleLoadError, combines both CJS and ESM loader module not found errors into a single error that
+ * provides a consistent stack trace and info.
+ *
+ * @param {IConfig|IPlugin} config - Oclif config or plugin config.
+ * @param {string} modulePath - NPM module name or file path to load.
+ *
+ * @returns {Promise<*>} The entire ESM module from dynamic import or CJS module by require.
+ */
+export declare function load(config: IConfig | IPlugin, modulePath: string): Promise<any>;
+/**
+ * Loads a module and returns an object with the module and data about the module.
+ *
+ * Uses `getPackageType` to determine if `type` is set to `module`. If so loads '.js' files as ESM otherwise uses
+ * a bare require to load as CJS. Also loads '.mjs' files as ESM.
+ *
+ * Uses dynamic import to load ESM source or require for CommonJS.
+ *
+ * A unique error, ModuleLoadError, combines both CJS and ESM loader module not found errors into a single error that
+ * provides a consistent stack trace and info.
+ *
+ * @param {IConfig|IPlugin} config - Oclif config or plugin config.
+ * @param {string} modulePath - NPM module name or file path to load.
+ *
+ * @returns {Promise<{isESM: boolean, module: *, filePath: string}>} An object with the loaded module & data including
+ *                                                                   file path and whether the module is ESM.
  */
-export default class ModuleLoader {
-    /**
-     * Loads and returns a module.
-     *
-     * Uses `getPackageType` to determine if `type` is set to 'module. If so loads '.js' files as ESM otherwise uses
-     * a bare require to load as CJS. Also loads '.mjs' files as ESM.
-     *
-     * Uses dynamic import to load ESM source or require for CommonJS.
-     *
-     * A unique error, ModuleLoadError, combines both CJS and ESM loader module not found errors into a single error that
-     * provides a consistent stack trace and info.
-     *
-     * @param {IConfig|IPlugin} config - Oclif config or plugin config.
-     * @param {string} modulePath - NPM module name or file path to load.
-     *
-     * @returns {Promise<*>} The entire ESM module from dynamic import or CJS module by require.
-     */
-    static load(config: IConfig | IPlugin, modulePath: string): Promise<any>;
-    /**
-     * Loads a module and returns an object with the module and data about the module.
-     *
-     * Uses `getPackageType` to determine if `type` is set to `module`. If so loads '.js' files as ESM otherwise uses
-     * a bare require to load as CJS. Also loads '.mjs' files as ESM.
-     *
-     * Uses dynamic import to load ESM source or require for CommonJS.
-     *
-     * A unique error, ModuleLoadError, combines both CJS and ESM loader module not found errors into a single error that
-     * provides a consistent stack trace and info.
-     *
-     * @param {IConfig|IPlugin} config - Oclif config or plugin config.
-     * @param {string} modulePath - NPM module name or file path to load.
-     *
-     * @returns {Promise<{isESM: boolean, module: *, filePath: string}>} An object with the loaded module & data including
-     *                                                                   file path and whether the module is ESM.
-     */
-    static loadWithData(config: IConfig | IPlugin, modulePath: string): Promise<{
-        isESM: boolean;
-        module: any;
-        filePath: string;
-    }>;
-    /**
-     * For `.js` files uses `getPackageType` to determine if `type` is set to `module` in associated `package.json`. If
-     * the `modulePath` provided ends in `.mjs` it is assumed to be ESM.
-     *
-     * @param {string} filePath - File path to test.
-     *
-     * @returns {boolean} The modulePath is an ES Module.
-     * @see https://www.npmjs.com/package/get-package-type
-     */
-    static isPathModule(filePath: string): boolean;
-    /**
-     * Resolves a modulePath first by `require.resolve` to allow Node to resolve an actual module. If this fails then
-     * the `modulePath` is resolved from the root of the provided config. `Config.tsPath` is used for initial resolution.
-     * If this file path does not exist then several extensions are tried from `s_EXTENSIONS` in order: '.js', '.mjs',
-     * '.cjs'. After a file path has been selected `isPathModule` is used to determine if the file is an ES Module.
-     *
-     * @param {IConfig|IPlugin} config - Oclif config or plugin config.
-     * @param {string} modulePath - File path to load.
-     *
-     * @returns {{isESM: boolean, filePath: string}} An object including file path and whether the module is ESM.
-     */
-    static resolvePath(config: IConfig | IPlugin, modulePath: string): {
-        isESM: boolean;
-        filePath: string;
-    };
-    /**
-     * Try adding the different extensions from `s_EXTENSIONS` to find the file.
-     *
-     * @param {string} filePath - File path to load.
-     *
-     * @returns {string | null} Modified file path including extension or null if file is not found.
-     */
-    static findFile(filePath: string): string | null;
-}
+export declare function loadWithData(config: IConfig | IPlugin, modulePath: string): Promise<{
+    isESM: boolean;
+    module: any;
+    filePath: string;
+}>;
+/**
+ * Loads a module and returns an object with the module and data about the module.
+ *
+ * Uses cached `isESM` and `relativePath` in plugin manifest to determine if dynamic import (isESM = true)
+ * or require (isESM = false | undefined) should be used.
+ *
+ * A unique error, ModuleLoadError, combines both CJS and ESM loader module not found errors into a single error that
+ * provides a consistent stack trace and info.
+ *
+ * @param {Command.Cached} cached - Cached command data from plugin manifest.
+ * @param {string} modulePath - NPM module name or file path to load.
+ *
+ * @returns {Promise<{isESM: boolean, module: *, filePath: string}>} An object with the loaded module & data including
+ *                                                                   file path and whether the module is ESM.
+ */
+export declare function loadWithDataFromManifest(cached: Command.Cached, modulePath: string): Promise<{
+    isESM: boolean;
+    module: any;
+    filePath: string;
+}>;
+/**
+   * For `.js` files uses `getPackageType` to determine if `type` is set to `module` in associated `package.json`. If
+   * the `modulePath` provided ends in `.mjs` it is assumed to be ESM.
+   *
+   * @param {string} filePath - File path to test.
+   *
+   * @returns {boolean} The modulePath is an ES Module.
+   * @see https://www.npmjs.com/package/get-package-type
+   */
+export declare function isPathModule(filePath: string): boolean;

package/lib/module-loader.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const path = require("path");
-const url = require("url");
-const fs_1 = require("fs");
+exports.isPathModule = exports.loadWithDataFromManifest = exports.loadWithData = exports.load = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
 const errors_1 = require("./errors");
+const node_url_1 = require("node:url");
 const config_1 = require("./config");
 const getPackageType = require('get-package-type');
 /**
@@ -11,167 +12,196 @@ const getPackageType = require('get-package-type');
  */
 // eslint-disable-next-line camelcase
 const s_EXTENSIONS = ['.ts', '.js', '.mjs', '.cjs'];
-const isPlugin = (config) => {
-    return config.type !== undefined;
-};
+const isPlugin = (config) => config.type !== undefined;
 /**
- * Provides a static class with several utility methods to work with Oclif config / plugin to load ESM or CJS Node
- * modules and source files.
+ * Loads and returns a module.
  *
- * @author Michael Leahy <support@typhonjs.io> (https://github.com/typhonrt)
+ * Uses `getPackageType` to determine if `type` is set to 'module. If so loads '.js' files as ESM otherwise uses
+ * a bare require to load as CJS. Also loads '.mjs' files as ESM.
+ *
+ * Uses dynamic import to load ESM source or require for CommonJS.
+ *
+ * A unique error, ModuleLoadError, combines both CJS and ESM loader module not found errors into a single error that
+ * provides a consistent stack trace and info.
+ *
+ * @param {IConfig|IPlugin} config - Oclif config or plugin config.
+ * @param {string} modulePath - NPM module name or file path to load.
+ *
+ * @returns {Promise<*>} The entire ESM module from dynamic import or CJS module by require.
  */
-// eslint-disable-next-line unicorn/no-static-only-class
-class ModuleLoader {
-    /**
-     * Loads and returns a module.
-     *
-     * Uses `getPackageType` to determine if `type` is set to 'module. If so loads '.js' files as ESM otherwise uses
-     * a bare require to load as CJS. Also loads '.mjs' files as ESM.
-     *
-     * Uses dynamic import to load ESM source or require for CommonJS.
-     *
-     * A unique error, ModuleLoadError, combines both CJS and ESM loader module not found errors into a single error that
-     * provides a consistent stack trace and info.
-     *
-     * @param {IConfig|IPlugin} config - Oclif config or plugin config.
-     * @param {string} modulePath - NPM module name or file path to load.
-     *
-     * @returns {Promise<*>} The entire ESM module from dynamic import or CJS module by require.
-     */
-    static async load(config, modulePath) {
-        let filePath;
-        let isESM;
-        try {
-            ({ isESM, filePath } = ModuleLoader.resolvePath(config, modulePath));
-            // It is important to await on import to catch the error code.
-            return isESM ? await import(url.pathToFileURL(filePath).href) : require(filePath);
-        }
-        catch (error) {
-            if (error.code === 'MODULE_NOT_FOUND' || error.code === 'ERR_MODULE_NOT_FOUND') {
-                throw new errors_1.ModuleLoadError(`${isESM ? 'import()' : 'require'} failed to load ${filePath || modulePath}`);
-            }
-            throw error;
-        }
+async function load(config, modulePath) {
+    let filePath;
+    let isESM;
+    try {
+        ({ isESM, filePath } = resolvePath(config, modulePath));
+        return isESM ? await import((0, node_url_1.pathToFileURL)(filePath).href) : require(filePath);
     }
-    /**
-     * Loads a module and returns an object with the module and data about the module.
-     *
-     * Uses `getPackageType` to determine if `type` is set to `module`. If so loads '.js' files as ESM otherwise uses
-     * a bare require to load as CJS. Also loads '.mjs' files as ESM.
-     *
-     * Uses dynamic import to load ESM source or require for CommonJS.
-     *
-     * A unique error, ModuleLoadError, combines both CJS and ESM loader module not found errors into a single error that
-     * provides a consistent stack trace and info.
-     *
-     * @param {IConfig|IPlugin} config - Oclif config or plugin config.
-     * @param {string} modulePath - NPM module name or file path to load.
-     *
-     * @returns {Promise<{isESM: boolean, module: *, filePath: string}>} An object with the loaded module & data including
-     *                                                                   file path and whether the module is ESM.
-     */
-    static async loadWithData(config, modulePath) {
-        let filePath;
-        let isESM;
-        try {
-            ({ isESM, filePath } = ModuleLoader.resolvePath(config, modulePath));
-            const module = isESM ? await import(url.pathToFileURL(filePath).href) : require(filePath);
-            return { isESM, module, filePath };
+    catch (error) {
+        if (error.code === 'MODULE_NOT_FOUND' || error.code === 'ERR_MODULE_NOT_FOUND') {
+            throw new errors_1.ModuleLoadError(`${isESM ? 'import()' : 'require'} failed to load ${filePath || modulePath}`);
         }
-        catch (error) {
-            if (error.code === 'MODULE_NOT_FOUND' || error.code === 'ERR_MODULE_NOT_FOUND') {
-                throw new errors_1.ModuleLoadError(`${isESM ? 'import()' : 'require'} failed to load ${filePath || modulePath}: ${error.message}`);
-            }
-            throw error;
+        throw error;
+    }
+}
+exports.load = load;
+/**
+ * Loads a module and returns an object with the module and data about the module.
+ *
+ * Uses `getPackageType` to determine if `type` is set to `module`. If so loads '.js' files as ESM otherwise uses
+ * a bare require to load as CJS. Also loads '.mjs' files as ESM.
+ *
+ * Uses dynamic import to load ESM source or require for CommonJS.
+ *
+ * A unique error, ModuleLoadError, combines both CJS and ESM loader module not found errors into a single error that
+ * provides a consistent stack trace and info.
+ *
+ * @param {IConfig|IPlugin} config - Oclif config or plugin config.
+ * @param {string} modulePath - NPM module name or file path to load.
+ *
+ * @returns {Promise<{isESM: boolean, module: *, filePath: string}>} An object with the loaded module & data including
+ *                                                                   file path and whether the module is ESM.
+ */
+async function loadWithData(config, modulePath) {
+    let filePath;
+    let isESM;
+    try {
+        ({ isESM, filePath } = resolvePath(config, modulePath));
+        const module = isESM ? await import((0, node_url_1.pathToFileURL)(filePath).href) : require(filePath);
+        return { isESM, module, filePath };
+    }
+    catch (error) {
+        if (error.code === 'MODULE_NOT_FOUND' || error.code === 'ERR_MODULE_NOT_FOUND') {
+            throw new errors_1.ModuleLoadError(`${isESM ? 'import()' : 'require'} failed to load ${filePath || modulePath}: ${error.message}`);
         }
+        throw error;
     }
-    /**
-     * For `.js` files uses `getPackageType` to determine if `type` is set to `module` in associated `package.json`. If
-     * the `modulePath` provided ends in `.mjs` it is assumed to be ESM.
-     *
-     * @param {string} filePath - File path to test.
-     *
-     * @returns {boolean} The modulePath is an ES Module.
-     * @see https://www.npmjs.com/package/get-package-type
-     */
-    static isPathModule(filePath) {
-        const extension = path.extname(filePath).toLowerCase();
-        switch (extension) {
-            case '.js':
-            case '.jsx':
-            case '.ts':
-            case '.tsx':
-                return getPackageType.sync(filePath) === 'module';
-            case '.mjs':
-            case '.mts':
-                return true;
-            default:
-                return false;
+}
+exports.loadWithData = loadWithData;
+/**
+ * Loads a module and returns an object with the module and data about the module.
+ *
+ * Uses cached `isESM` and `relativePath` in plugin manifest to determine if dynamic import (isESM = true)
+ * or require (isESM = false | undefined) should be used.
+ *
+ * A unique error, ModuleLoadError, combines both CJS and ESM loader module not found errors into a single error that
+ * provides a consistent stack trace and info.
+ *
+ * @param {Command.Cached} cached - Cached command data from plugin manifest.
+ * @param {string} modulePath - NPM module name or file path to load.
+ *
+ * @returns {Promise<{isESM: boolean, module: *, filePath: string}>} An object with the loaded module & data including
+ *                                                                   file path and whether the module is ESM.
+ */
+async function loadWithDataFromManifest(cached, modulePath) {
+    const { isESM, relativePath, id } = cached;
+    if (!relativePath) {
+        throw new errors_1.ModuleLoadError(`Cached command ${id} does not have a relative path`);
+    }
+    if (isESM === undefined) {
+        throw new errors_1.ModuleLoadError(`Cached command ${id} does not have the isESM property set`);
+    }
+    const filePath = (0, node_path_1.join)(modulePath, relativePath.join(node_path_1.sep));
+    try {
+        const module = isESM ? await import((0, node_url_1.pathToFileURL)(filePath).href) : require(filePath);
+        return { isESM, module, filePath };
+    }
+    catch (error) {
+        if (error.code === 'MODULE_NOT_FOUND' || error.code === 'ERR_MODULE_NOT_FOUND') {
+            throw new errors_1.ModuleLoadError(`${isESM ? 'import()' : 'require'} failed to load ${filePath || modulePath}: ${error.message}`);
         }
+        throw error;
     }
-    /**
-     * Resolves a modulePath first by `require.resolve` to allow Node to resolve an actual module. If this fails then
-     * the `modulePath` is resolved from the root of the provided config. `Config.tsPath` is used for initial resolution.
-     * If this file path does not exist then several extensions are tried from `s_EXTENSIONS` in order: '.js', '.mjs',
-     * '.cjs'. After a file path has been selected `isPathModule` is used to determine if the file is an ES Module.
-     *
-     * @param {IConfig|IPlugin} config - Oclif config or plugin config.
-     * @param {string} modulePath - File path to load.
-     *
-     * @returns {{isESM: boolean, filePath: string}} An object including file path and whether the module is ESM.
-     */
-    static resolvePath(config, modulePath) {
-        let isESM;
-        let filePath;
-        try {
-            filePath = require.resolve(modulePath);
-            isESM = ModuleLoader.isPathModule(filePath);
+}
+exports.loadWithDataFromManifest = loadWithDataFromManifest;
+/**
+   * For `.js` files uses `getPackageType` to determine if `type` is set to `module` in associated `package.json`. If
+   * the `modulePath` provided ends in `.mjs` it is assumed to be ESM.
+   *
+   * @param {string} filePath - File path to test.
+   *
+   * @returns {boolean} The modulePath is an ES Module.
+   * @see https://www.npmjs.com/package/get-package-type
+   */
+function isPathModule(filePath) {
+    const extension = (0, node_path_1.extname)(filePath).toLowerCase();
+    switch (extension) {
+        case '.js':
+        case '.jsx':
+        case '.ts':
+        case '.tsx': {
+            return getPackageType.sync(filePath) === 'module';
+        }
+        case '.mjs':
+        case '.mts': {
+            return true;
         }
-        catch {
-            filePath = (isPlugin(config) ? (0, config_1.tsPath)(config.root, modulePath, config) : (0, config_1.tsPath)(config.root, modulePath)) ?? modulePath;
-            let fileExists = false;
-            let isDirectory = false;
-            if ((0, fs_1.existsSync)(filePath)) {
-                fileExists = true;
-                try {
-                    if ((0, fs_1.lstatSync)(filePath)?.isDirectory?.()) {
-                        fileExists = false;
-                        isDirectory = true;
-                    }
+        default: {
+            return false;
+        }
+    }
+}
+exports.isPathModule = isPathModule;
+/**
+ * Resolves a modulePath first by `require.resolve` to allow Node to resolve an actual module. If this fails then
+ * the `modulePath` is resolved from the root of the provided config. `Config.tsPath` is used for initial resolution.
+ * If this file path does not exist then several extensions are tried from `s_EXTENSIONS` in order: '.js', '.mjs',
+ * '.cjs'. After a file path has been selected `isPathModule` is used to determine if the file is an ES Module.
+ *
+ * @param {IConfig|IPlugin} config - Oclif config or plugin config.
+ * @param {string} modulePath - File path to load.
+ *
+ * @returns {{isESM: boolean, filePath: string}} An object including file path and whether the module is ESM.
+ */
+function resolvePath(config, modulePath) {
+    let isESM;
+    let filePath;
+    try {
+        filePath = require.resolve(modulePath);
+        isESM = isPathModule(filePath);
+    }
+    catch {
+        filePath = (isPlugin(config) ? (0, config_1.tsPath)(config.root, modulePath, config) : (0, config_1.tsPath)(config.root, modulePath)) ?? modulePath;
+        let fileExists = false;
+        let isDirectory = false;
+        if ((0, node_fs_1.existsSync)(filePath)) {
+            fileExists = true;
+            try {
+                if ((0, node_fs_1.lstatSync)(filePath)?.isDirectory?.()) {
+                    fileExists = false;
+                    isDirectory = true;
                 }
-                catch { }
             }
-            if (!fileExists) {
-                // Try all supported extensions.
-                let foundPath = ModuleLoader.findFile(filePath);
-                if (!foundPath && isDirectory) {
-                    // Since filePath is a directory, try looking for index file.
-                    foundPath = ModuleLoader.findFile(path.join(filePath, 'index'));
-                }
-                if (foundPath) {
-                    filePath = foundPath;
-                }
+            catch { }
+        }
+        if (!fileExists) {
+            // Try all supported extensions.
+            let foundPath = findFile(filePath);
+            if (!foundPath && isDirectory) {
+                // Since filePath is a directory, try looking for index file.
+                foundPath = findFile((0, node_path_1.join)(filePath, 'index'));
+            }
+            if (foundPath) {
+                filePath = foundPath;
             }
-            isESM = ModuleLoader.isPathModule(filePath);
         }
-        return { isESM, filePath };
+        isESM = isPathModule(filePath);
     }
-    /**
-     * Try adding the different extensions from `s_EXTENSIONS` to find the file.
-     *
-     * @param {string} filePath - File path to load.
-     *
-     * @returns {string | null} Modified file path including extension or null if file is not found.
-     */
-    static findFile(filePath) {
-        // eslint-disable-next-line camelcase
-        for (const extension of s_EXTENSIONS) {
-            const testPath = `${filePath}${extension}`;
-            if ((0, fs_1.existsSync)(testPath)) {
-                return testPath;
-            }
+    return { isESM, filePath };
+}
+/**
+ * Try adding the different extensions from `s_EXTENSIONS` to find the file.
+ *
+ * @param {string} filePath - File path to load.
+ *
+ * @returns {string | null} Modified file path including extension or null if file is not found.
+ */
+function findFile(filePath) {
+    // eslint-disable-next-line camelcase
+    for (const extension of s_EXTENSIONS) {
+        const testPath = `${filePath}${extension}`;
+        if ((0, node_fs_1.existsSync)(testPath)) {
+            return testPath;
         }
-        return null;
     }
+    return null;
 }
-exports.default = ModuleLoader;

package/lib/parser/errors.d.ts

@@ -1,6 +1,6 @@
-import { CLIError } from '../errors';
-import { OptionFlag, Flag } from '../interfaces';
 import { Arg, ArgInput, CLIParseErrorOptions } from '../interfaces/parser';
+import { Flag, OptionFlag } from '../interfaces';
+import { CLIError } from '../errors';
 export { CLIError } from '../errors';
 export type Validation = {
     name: string;

package/lib/parser/errors.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FailedFlagValidationError = exports.ArgInvalidOptionError = exports.FlagInvalidOptionError = exports.NonExistentFlagsError = exports.UnexpectedArgsError = exports.RequiredFlagError = exports.RequiredArgsError = exports.InvalidArgsSpecError = exports.CLIParseError = exports.CLIError = void 0;
+const tslib_1 = require("tslib");
 const errors_1 = require("../errors");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const help_1 = require("./help");
 const list_1 = require("../cli-ux/list");
-const chalk = require("chalk");
-const util_1 = require("../config/util");
+const util_1 = require("../util");
 var errors_2 = require("../errors");
 Object.defineProperty(exports, "CLIError", { enumerable: true, get: function () { return errors_2.CLIError; } });
 class CLIParseError extends errors_1.CLIError {
@@ -91,7 +92,7 @@ class FailedFlagValidationError extends CLIParseError {
         const reasons = failed.map(r => r.reason);
         const deduped = (0, util_1.uniq)(reasons);
         const errString = deduped.length === 1 ? 'error' : 'errors';
-        const message = `The following ${errString} occurred:\n  ${chalk.dim(deduped.join('\n  '))}`;
+        const message = `The following ${errString} occurred:\n  ${chalk_1.default.dim(deduped.join('\n  '))}`;
         super({ parse, message });
     }
 }

package/lib/parser/help.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.flagUsages = exports.flagUsage = void 0;
-const chalk = require("chalk");
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const util_1 = require("../util");
 function flagUsage(flag, options = {}) {
     const label = [];
@@ -18,7 +19,7 @@ function flagUsage(flag, options = {}) {
     let description = flag.summary || flag.description || '';
     if (options.displayRequired && flag.required)
         description = `(required) ${description}`;
-    description = description ? chalk.dim(description) : undefined;
+    description = description ? chalk_1.default.dim(description) : undefined;
     return [` ${label.join(',').trim()}${usage}`, description];
 }
 exports.flagUsage = flagUsage;

package/lib/parser/parse.d.ts

@@ -16,4 +16,7 @@ export declare class Parser<T extends ParserInput, TFlags extends OutputFlags<T[
     private get _argTokens();
     private _setNames;
     private mapAndValidateFlags;
+    private findLongFlag;
+    private findShortFlag;
+    private findFlag;
 }