@oclif/core 3.0.0-beta.9 → 3.0.1

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");
+exports.run = exports.versionAddition = exports.helpAddition = void 0;
+const node_url_1 = require("node:url");
+const node_util_1 = require("node:util");
+const stream_1 = require("./cli-ux/stream");
 const config_1 = require("./config");
 const help_1 = require("./help");
-const stream_1 = require("./ux/stream");
 const performance_1 = require("./performance");
 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,26 +34,27 @@ 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(performance_1.OCLIF_MARKER_OWNER, 'main.run');
+    const initMarker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, '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);
     // run init hook
-    await config.runHook('init', { id, argv: argvSlice });
+    await config.runHook('init', { argv: argvSlice, id });
     // display version if applicable
     if ((0, exports.versionAddition)(argv, config)) {
         log(config.userAgent);
@@ -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 { Command } from './command';
 import { Config as IConfig, Plugin as IPlugin } from './interfaces';
 /**
- * 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<{
+    filePath: string;
+    isESM: boolean;
+    module: any;
+}>;
+/**
+ * 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<{
+    filePath: string;
+    isESM: boolean;
+    module: any;
+}>;
+/**
+ * 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_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 node_url_1 = require("node:url");
+const ts_node_1 = require("./config/ts-node");
 const errors_1 = require("./errors");
-const config_1 = require("./config");
 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 {
+        ;
+        ({ filePath, isESM } = 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 {
+        ;
+        ({ filePath, isESM } = resolvePath(config, modulePath));
+        const module = isESM ? await import((0, node_url_1.pathToFileURL)(filePath).href) : require(filePath);
+        return { filePath, isESM, module };
+    }
+    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 { id, isESM, relativePath } = 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 { filePath, isESM, module };
+    }
+    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 ((0, fs_1.existsSync)(filePath)) {
-                fileExists = true;
-                try {
-                    if ((0, fs_1.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 ((0, fs_1.existsSync)(testPath)) {
-                return testPath;
-            }
+    return { filePath, isESM };
+}
+/**
+ * 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,12 +1,12 @@
 import { CLIError } from '../errors';
-import { OptionFlag, Flag } from '../interfaces';
+import { Flag, OptionFlag } from '../interfaces';
 import { Arg, ArgInput, CLIParseErrorOptions } from '../interfaces/parser';
 export { CLIError } from '../errors';
 export type Validation = {
     name: string;
-    status: 'success' | 'failed';
-    validationFn: string;
     reason?: string;
+    status: 'failed' | 'success';
+    validationFn: string;
 };
 export declare class CLIParseError extends CLIError {
     parse: CLIParseErrorOptions['parse'];
@@ -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, flagsWithMultiple, parse, }: CLIParseErrorOptions & {
         args: Arg<any>[];
         flagsWithMultiple?: string[];
     });
@@ -35,13 +35,13 @@ export declare class RequiredFlagError extends CLIParseError {
 }
 export declare class UnexpectedArgsError extends CLIParseError {
     args: unknown[];
-    constructor({ parse, args }: CLIParseErrorOptions & {
+    constructor({ args, parse }: CLIParseErrorOptions & {
         args: unknown[];
     });
 }
 export declare class NonExistentFlagsError extends CLIParseError {
     flags: string[];
-    constructor({ parse, flags }: CLIParseErrorOptions & {
+    constructor({ flags, parse }: CLIParseErrorOptions & {
         flags: string[];
     });
 }
@@ -52,7 +52,7 @@ export declare class ArgInvalidOptionError extends CLIParseError {
     constructor(arg: Arg<any>, input: string);
 }
 export declare class FailedFlagValidationError extends CLIParseError {
-    constructor({ parse, failed }: CLIParseErrorOptions & {
+    constructor({ failed, parse }: CLIParseErrorOptions & {
         failed: Validation[];
     });
 }