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

package/lib/module-loader.d.ts

@@ -1,82 +1,71 @@
-import { Config as IConfig } from './interfaces';
-import { Plugin as IPlugin } from './interfaces';
+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 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 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 isPathModule(filePath: string): boolean;

package/lib/module-loader.js

@@ -1,177 +1,210 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const path = require("path");
-const url = require("url");
-const fs = require("fs-extra");
+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 config_1 = require("./config");
+const node_url_1 = require("node:url");
+const ts_node_1 = require("./config/ts-node");
 const getPackageType = require('get-package-type');
 /**
  * Defines file extension resolution when source files do not have an extension.
  */
 // 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;
+    }
+}
+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`);
     }
-    /**
-     * 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;
+    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';
         }
-        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 (fs.existsSync(filePath)) {
-                fileExists = true;
-                try {
-                    if (fs.lstatSync(filePath)?.isDirectory?.()) {
-                        fileExists = false;
-                        isDirectory = true;
-                    }
+        case '.mjs':
+        case '.mts': {
+            return 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, ts_node_1.tsPath)(config.root, modulePath, config) : (0, ts_node_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 (fs.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;
@@ -22,7 +22,7 @@ export declare class InvalidArgsSpecError extends CLIParseError {
 }
 export declare class RequiredArgsError extends CLIParseError {
     args: Arg<any>[];
-    constructor({ args, parse, flagsWithMultiple }: CLIParseErrorOptions & {
+    constructor({ args, parse, flagsWithMultiple, }: CLIParseErrorOptions & {
         args: Arg<any>[];
         flagsWithMultiple?: string[];
     });

package/lib/parser/errors.js

@@ -1,14 +1,16 @@
 "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/util");
 var errors_2 = require("../errors");
 Object.defineProperty(exports, "CLIError", { enumerable: true, get: function () { return errors_2.CLIError; } });
 class CLIParseError extends errors_1.CLIError {
+    parse;
     constructor(options) {
         options.message += '\nSee more help with --help';
         super(options.message);
@@ -17,11 +19,12 @@ class CLIParseError extends errors_1.CLIError {
 }
 exports.CLIParseError = CLIParseError;
 class InvalidArgsSpecError extends CLIParseError {
+    args;
     constructor({ args, parse }) {
         let message = 'Invalid argument spec';
-        const namedArgs = Object.values(args).filter(a => a.name);
+        const namedArgs = Object.values(args).filter((a) => a.name);
         if (namedArgs.length > 0) {
-            const list = (0, list_1.renderList)(namedArgs.map(a => [`${a.name} (${a.required ? 'required' : 'optional'})`, a.description]));
+            const list = (0, list_1.renderList)(namedArgs.map((a) => [`${a.name} (${a.required ? 'required' : 'optional'})`, a.description]));
             message += `:\n${list}`;
         }
         super({ parse, message });
@@ -30,15 +33,16 @@ class InvalidArgsSpecError extends CLIParseError {
 }
 exports.InvalidArgsSpecError = InvalidArgsSpecError;
 class RequiredArgsError extends CLIParseError {
-    constructor({ args, parse, flagsWithMultiple }) {
+    args;
+    constructor({ args, parse, flagsWithMultiple, }) {
         let message = `Missing ${args.length} required arg${args.length === 1 ? '' : 's'}`;
-        const namedArgs = args.filter(a => a.name);
+        const namedArgs = args.filter((a) => a.name);
         if (namedArgs.length > 0) {
-            const list = (0, list_1.renderList)(namedArgs.map(a => [a.name, a.description]));
+            const list = (0, list_1.renderList)(namedArgs.map((a) => [a.name, a.description]));
             message += `:\n${list}`;
         }
         if (flagsWithMultiple?.length) {
-            const flags = flagsWithMultiple.map(f => `--${f}`).join(', ');
+            const flags = flagsWithMultiple.map((f) => `--${f}`).join(', ');
             message += `\n\nNote: ${flags} allow${flagsWithMultiple.length === 1 ? 's' : ''} multiple values. Because of this you need to provide all arguments before providing ${flagsWithMultiple.length === 1 ? 'that flag' : 'those flags'}.`;
             message += '\nAlternatively, you can use "--" to signify the end of the flags and the beginning of arguments.';
         }
@@ -48,6 +52,7 @@ class RequiredArgsError extends CLIParseError {
 }
 exports.RequiredArgsError = RequiredArgsError;
 class RequiredFlagError extends CLIParseError {
+    flag;
     constructor({ flag, parse }) {
         const usage = (0, list_1.renderList)((0, help_1.flagUsages)([flag], { displayRequired: false }));
         const message = `Missing required flag:\n${usage}`;
@@ -57,6 +62,7 @@ class RequiredFlagError extends CLIParseError {
 }
 exports.RequiredFlagError = RequiredFlagError;
 class UnexpectedArgsError extends CLIParseError {
+    args;
     constructor({ parse, args }) {
         const message = `Unexpected argument${args.length === 1 ? '' : 's'}: ${args.join(', ')}`;
         super({ parse, message });
@@ -65,6 +71,7 @@ class UnexpectedArgsError extends CLIParseError {
 }
 exports.UnexpectedArgsError = UnexpectedArgsError;
 class NonExistentFlagsError extends CLIParseError {
+    flags;
     constructor({ parse, flags }) {
         const message = `Nonexistent flag${flags.length === 1 ? '' : 's'}: ${flags.join(', ')}`;
         super({ parse, message });
@@ -88,10 +95,10 @@ class ArgInvalidOptionError extends CLIParseError {
 exports.ArgInvalidOptionError = ArgInvalidOptionError;
 class FailedFlagValidationError extends CLIParseError {
     constructor({ parse, failed }) {
-        const reasons = failed.map(r => r.reason);
+        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,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.flagUsages = exports.flagUsage = void 0;
-const chalk = require("chalk");
-const util_1 = require("../util");
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const util_1 = require("../util/util");
 function flagUsage(flag, options = {}) {
     const label = [];
     if (flag.helpLabel) {
@@ -18,14 +19,13 @@ 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;
 function flagUsages(flags, options = {}) {
     if (flags.length === 0)
         return [];
-    return (0, util_1.sortBy)(flags, f => [f.char ? -1 : 1, f.char, f.name])
-        .map(f => flagUsage(f, options));
+    return (0, util_1.sortBy)(flags, (f) => [f.char ? -1 : 1, f.char, f.name]).map((f) => flagUsage(f, options));
 }
 exports.flagUsages = flagUsages;