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

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

@@ -1,4 +1,5 @@
-import { Plugin } from '../interfaces';
+import { Plugin, TSConfig } from '../interfaces';
+export declare const TS_CONFIGS: Record<string, TSConfig>;
 /**
  * Convert a path from the compiled ./lib files to the ./src typescript source
  * this is for developing typescript plugins/CLIs

package/lib/config/ts-node.js

@@ -1,37 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tsPath = void 0;
-const fs = require("fs");
-const path = require("path");
-const settings_1 = require("../settings");
+exports.tsPath = exports.TS_CONFIGS = void 0;
 const util_1 = require("../util");
+const node_path_1 = require("node:path");
+const config_1 = require("./config");
 const util_2 = require("./util");
+const node_fs_1 = require("node:fs");
 const errors_1 = require("../errors");
+const settings_1 = require("../settings");
 // eslint-disable-next-line new-cap
 const debug = (0, util_2.Debug)('ts-node');
-const TS_CONFIGS = {};
+exports.TS_CONFIGS = {};
 const REGISTERED = new Set();
 function loadTSConfig(root) {
-    if (TS_CONFIGS[root])
-        return TS_CONFIGS[root];
-    const tsconfigPath = path.join(root, 'tsconfig.json');
+    if (exports.TS_CONFIGS[root])
+        return exports.TS_CONFIGS[root];
+    const tsconfigPath = (0, node_path_1.join)(root, 'tsconfig.json');
     let typescript;
     try {
         typescript = require('typescript');
     }
     catch {
         try {
-            typescript = require(path.join(root, 'node_modules', 'typescript'));
+            typescript = require((0, node_path_1.join)(root, 'node_modules', 'typescript'));
         }
         catch { }
     }
-    if (fs.existsSync(tsconfigPath) && typescript) {
-        const tsconfig = typescript.parseConfigFileTextToJson(tsconfigPath, fs.readFileSync(tsconfigPath, 'utf8')).config;
+    if ((0, node_fs_1.existsSync)(tsconfigPath) && typescript) {
+        const tsconfig = typescript.parseConfigFileTextToJson(tsconfigPath, (0, util_1.readJsonSync)(tsconfigPath, false)).config;
         if (!tsconfig || !tsconfig.compilerOptions) {
-            throw new Error(`Could not read and parse tsconfig.json at ${tsconfigPath}, or it ` +
-                'did not contain a "compilerOptions" section.');
+            throw new Error(`Could not read and parse tsconfig.json at ${tsconfigPath}, or it `
+                + 'did not contain a "compilerOptions" section.');
         }
-        TS_CONFIGS[root] = tsconfig;
+        exports.TS_CONFIGS[root] = tsconfig;
         return tsconfig;
     }
 }
@@ -46,19 +47,19 @@ function registerTSNode(root) {
     debug('ts-node path:', tsNodePath);
     const tsNode = require(tsNodePath);
     const typeRoots = [
-        path.join(root, 'node_modules', '@types'),
+        (0, node_path_1.join)(root, 'node_modules', '@types'),
     ];
     const rootDirs = [];
     if (tsconfig.compilerOptions.rootDirs) {
         for (const r of tsconfig.compilerOptions.rootDirs) {
-            rootDirs.push(path.join(root, r));
+            rootDirs.push((0, node_path_1.join)(root, r));
         }
     }
     else if (tsconfig.compilerOptions.rootDir) {
-        rootDirs.push(path.join(root, tsconfig.compilerOptions.rootDir));
+        rootDirs.push((0, node_path_1.join)(root, tsconfig.compilerOptions.rootDir));
     }
     else {
-        rootDirs.push(path.join(root, 'src'));
+        rootDirs.push((0, node_path_1.join)(root, 'src'));
     }
     const conf = {
         compilerOptions: {
@@ -94,26 +95,32 @@ function registerTSNode(root) {
 function tsPath(root, orig, plugin) {
     if (!orig)
         return orig;
-    orig = orig.startsWith(root) ? orig : path.join(root, orig);
+    orig = orig.startsWith(root) ? orig : (0, node_path_1.join)(root, orig);
     // NOTE: The order of these checks matter!
     if (settings_1.settings.tsnodeEnabled === false) {
         debug(`Skipping ts-node registration for ${root} because tsNodeEnabled is explicitly set to false`);
         return orig;
     }
-    // Skip ts-node registration for ESM plugins.
-    // The node ecosystem is not mature enough to support auto-transpiling ESM modules at this time.
-    // See the following:
-    // - https://github.com/TypeStrong/ts-node/issues/1791#issuecomment-1149754228
-    // - https://github.com/nodejs/node/issues/49432
-    // - https://github.com/nodejs/node/pull/49407
-    // - https://github.com/nodejs/node/issues/34049
-    if (plugin?.moduleType === 'module') {
-        debug(`Skipping ts-node registration for ${root} because it's an ESM module`);
+    const isProduction = (0, util_1.isProd)();
+    /**
+     * Skip ts-node registration for ESM plugins.
+     * The node ecosystem is not mature enough to support auto-transpiling ESM modules at this time.
+     * See the following:
+     * - https://github.com/TypeStrong/ts-node/issues/1791#issuecomment-1149754228
+     * - https://github.com/nodejs/node/issues/49432
+     * - https://github.com/nodejs/node/pull/49407
+     * - https://github.com/nodejs/node/issues/34049
+     *
+     * We still register ts-node for ESM plugins when NODE_ENV is "test" or "development" and root plugin is also ESM.
+     * In other words, this allows plugins to be auto-transpiled when developing locally using `bin/dev.js`.
+     */
+    if ((isProduction || config_1.Config.rootPlugin?.moduleType === 'commonjs') && plugin?.moduleType === 'module') {
+        debug(`Skipping ts-node registration for ${root} because it's an ESM module (NODE_ENV: ${process.env.NODE_ENV}, root plugin module type: ${config_1.Config.rootPlugin?.moduleType})))`);
         if (plugin.type === 'link')
             (0, errors_1.memoizedWarn)(`${plugin.name} is a linked ESM module and cannot be auto-transpiled. Existing compiled source will be used instead.`);
         return orig;
     }
-    if (settings_1.settings.tsnodeEnabled === undefined && (0, util_1.isProd)() && plugin?.type !== 'link') {
+    if (settings_1.settings.tsnodeEnabled === undefined && isProduction && plugin?.type !== 'link') {
         debug(`Skipping ts-node registration for ${root} because NODE_ENV is NOT "test" or "development"`);
         return orig;
     }
@@ -126,17 +133,17 @@ function tsPath(root, orig, plugin) {
         if (!rootDirPath || !outDir)
             return orig;
         // rewrite path from ./lib/foo to ./src/foo
-        const lib = path.join(root, outDir); // ./lib
-        const src = path.join(root, rootDirPath); // ./src
-        const relative = path.relative(lib, orig); // ./commands
+        const lib = (0, node_path_1.join)(root, outDir); // ./lib
+        const src = (0, node_path_1.join)(root, rootDirPath); // ./src
+        const relative = (0, node_path_1.relative)(lib, orig); // ./commands
         // For hooks, it might point to a js file, not a module. Something like "./hooks/myhook.js" which doesn't need the js.
-        const out = path.join(src, relative).replace(/\.js$/, ''); // ./src/commands
+        const out = (0, node_path_1.join)(src, relative).replace(/\.js$/, ''); // ./src/commands
         // this can be a directory of commands or point to a hook file
         // if it's a directory, we check if the path exists. If so, return the path to the directory.
         // For hooks, it might point to a module, not a file. Something like "./hooks/myhook"
         // That file doesn't exist, and the real file is "./hooks/myhook.ts"
         // In that case we attempt to resolve to the filename. If it fails it will revert back to the lib path
-        if (fs.existsSync(out) || fs.existsSync(out + '.ts'))
+        if ((0, node_fs_1.existsSync)(out) || (0, node_fs_1.existsSync)(out + '.ts'))
             return out;
         return orig;
     }

package/lib/config/util.d.ts

@@ -4,13 +4,9 @@ export declare function mapValues<T extends Record<string, any>, TResult>(obj: {
 }, fn: (i: T[keyof T], k: keyof T) => TResult): {
     [P in keyof T]: TResult;
 };
-export declare function exists(path: string): Promise<boolean>;
 export declare function resolvePackage(id: string, paths: {
     paths: string[];
 }): string;
-export declare function loadJSON(path: string): Promise<any>;
-export declare function compact<T>(a: (T | undefined)[]): T[];
-export declare function uniq<T>(arr: T[]): T[];
 export declare function Debug(...scope: string[]): (..._: any) => void;
 export declare function getPermutations(arr: string[]): Array<string[]>;
 export declare function getCommandIdPermutations(commandId: string): string[];
@@ -33,4 +29,4 @@ export declare function getCommandIdPermutations(commandId: string): string[];
  * @param commandIds string[]
  * @returns string[]
  */
-export declare function collectUsableIds(commandIds: string[]): Set<string>;
+export declare const collectUsableIds: (commandIds: string[]) => Set<string>;

package/lib/config/util.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.collectUsableIds = exports.getCommandIdPermutations = exports.getPermutations = exports.Debug = exports.uniq = exports.compact = exports.loadJSON = exports.resolvePackage = exports.exists = exports.mapValues = exports.flatMap = void 0;
-const fs = require("fs");
+exports.collectUsableIds = exports.getCommandIdPermutations = exports.getPermutations = exports.Debug = exports.resolvePackage = exports.mapValues = exports.flatMap = void 0;
 const debug = require('debug');
 function flatMap(arr, fn) {
     return arr.reduce((arr, i) => [...arr, ...fn(i)], []);
@@ -15,40 +14,10 @@ function mapValues(obj, fn) {
     }, {});
 }
 exports.mapValues = mapValues;
-function exists(path) {
-    // eslint-disable-next-line no-promise-executor-return
-    return new Promise(resolve => resolve(fs.existsSync(path)));
-}
-exports.exists = exists;
 function resolvePackage(id, paths) {
     return require.resolve(id, paths);
 }
 exports.resolvePackage = resolvePackage;
-function loadJSON(path) {
-    debug('config')('loadJSON %s', path);
-    return new Promise((resolve, reject) => {
-        fs.readFile(path, 'utf8', (err, d) => {
-            try {
-                if (err)
-                    reject(err);
-                else
-                    resolve(JSON.parse(d));
-            }
-            catch (error) {
-                reject(error);
-            }
-        });
-    });
-}
-exports.loadJSON = loadJSON;
-function compact(a) {
-    return a.filter((a) => Boolean(a));
-}
-exports.compact = compact;
-function uniq(arr) {
-    return [...new Set(arr)].sort();
-}
-exports.uniq = uniq;
 function displayWarnings() {
     if (process.listenerCount('warning') > 1)
         return;
@@ -60,7 +29,9 @@ function displayWarnings() {
 }
 function Debug(...scope) {
     if (!debug)
-        return (..._) => { };
+        return (..._) => {
+            // noop
+        };
     const d = debug(['config', ...scope].join(':'));
     if (d.enabled)
         displayWarnings();
@@ -111,17 +82,5 @@ exports.getCommandIdPermutations = getCommandIdPermutations;
  * @param commandIds string[]
  * @returns string[]
  */
-function collectUsableIds(commandIds) {
-    const usuableIds = [];
-    for (const id of commandIds) {
-        const parts = id.split(':');
-        while (parts.length > 0) {
-            const name = parts.join(':');
-            if (name)
-                usuableIds.push(name);
-            parts.pop();
-        }
-    }
-    return new Set(usuableIds);
-}
+const collectUsableIds = (commandIds) => new Set(commandIds.flatMap(id => id.split(':').map((_, i, a) => a.slice(0, i + 1).join(':'))));
 exports.collectUsableIds = collectUsableIds;

package/lib/errors/config.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.config = void 0;
-const settings_1 = require("../settings");
 const logger_1 = require("./logger");
+const settings_1 = require("../settings");
 function displayWarnings() {
     if (process.listenerCount('warning') > 1)
         return;

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

@@ -1,4 +1,4 @@
-import { PrettyPrintableError, OclifError } from '../../interfaces/errors';
+import { OclifError, PrettyPrintableError } from '../../interfaces/errors';
 /**
  * properties specific to internal oclif error handling
  */

package/lib/errors/errors/cli.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CLIError = exports.addOclifExitCode = void 0;
-const chalk = require("chalk");
-const indent = require("indent-string");
-const cs = require("clean-stack");
-const wrap = require("wrap-ansi");
-const screen = require("../../screen");
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const config_1 = require("../config");
+const clean_stack_1 = tslib_1.__importDefault(require("clean-stack"));
+const screen_1 = require("../../screen");
+const indent_string_1 = tslib_1.__importDefault(require("indent-string"));
+const wrap_ansi_1 = tslib_1.__importDefault(require("wrap-ansi"));
 /**
  * properties specific to internal oclif error handling
  */
@@ -27,7 +28,7 @@ class CLIError extends Error {
         this.suggestions = options.suggestions;
     }
     get stack() {
-        return cs(super.stack, { pretty: true });
+        return (0, clean_stack_1.default)(super.stack, { pretty: true });
     }
     /**
      * @deprecated `render` Errors display should be handled by display function, like pretty-print
@@ -38,15 +39,15 @@ class CLIError extends Error {
             return this.stack;
         }
         let output = `${this.name}: ${this.message}`;
-        output = wrap(output, screen.errtermwidth - 6, { trim: false, hard: true });
-        output = indent(output, 3);
-        output = indent(output, 1, { indent: this.bang, includeEmptyLines: true });
-        output = indent(output, 1);
+        output = (0, wrap_ansi_1.default)(output, screen_1.errtermwidth - 6, { trim: false, hard: true });
+        output = (0, indent_string_1.default)(output, 3);
+        output = (0, indent_string_1.default)(output, 1, { indent: this.bang, includeEmptyLines: true });
+        output = (0, indent_string_1.default)(output, 1);
         return output;
     }
     get bang() {
         try {
-            return chalk.red(process.platform === 'win32' ? '»' : '›');
+            return chalk_1.default.red(process.platform === 'win32' ? '»' : '›');
         }
         catch { }
     }
@@ -60,10 +61,10 @@ exports.CLIError = CLIError;
         }
         get bang() {
             try {
-                return chalk.yellow(process.platform === 'win32' ? '»' : '›');
+                return chalk_1.default.yellow(process.platform === 'win32' ? '»' : '›');
             }
             catch { }
         }
     }
     CLIError.Warn = Warn;
-})(CLIError = exports.CLIError || (exports.CLIError = {}));
+})(CLIError || (exports.CLIError = CLIError = {}));

package/lib/errors/errors/exit.d.ts

@@ -1,9 +1,6 @@
 import { CLIError } from './cli';
 import { OclifError } from '../../interfaces';
 export declare class ExitError extends CLIError implements OclifError {
-    oclif: {
-        exit: number;
-    };
     code: string;
     constructor(exitCode?: number);
     render(): string;

package/lib/errors/errors/module-load.d.ts

@@ -1,9 +1,6 @@
 import { CLIError } from './cli';
 import { OclifError } from '../../interfaces';
 export declare class ModuleLoadError extends CLIError implements OclifError {
-    oclif: {
-        exit: number;
-    };
     code: string;
     constructor(message: string);
 }

package/lib/errors/errors/pretty-print.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.applyPrettyPrintOptions = void 0;
-const wrap = require("wrap-ansi");
-const indent = require("indent-string");
-const screen = require("../../screen");
+const tslib_1 = require("tslib");
 const config_1 = require("../config");
+const screen_1 = require("../../screen");
+const indent_string_1 = tslib_1.__importDefault(require("indent-string"));
+const wrap_ansi_1 = tslib_1.__importDefault(require("wrap-ansi"));
 function applyPrettyPrintOptions(error, options) {
     const prettyErrorKeys = ['message', 'code', 'ref', 'suggestions'];
     for (const key of prettyErrorKeys) {
@@ -23,7 +24,7 @@ const formatSuggestions = (suggestions) => {
     if (suggestions.length === 1)
         return `${label} ${suggestions[0]}`;
     const multiple = suggestions.map(suggestion => `* ${suggestion}`).join('\n');
-    return `${label}\n${indent(multiple, 2)}`;
+    return `${label}\n${(0, indent_string_1.default)(multiple, 2)}`;
 };
 function prettyPrint(error) {
     if (config_1.config.debug) {
@@ -39,10 +40,10 @@ function prettyPrint(error) {
     const formatted = [formattedHeader, formattedCode, formattedSuggestions, formattedReference]
         .filter(Boolean)
         .join('\n');
-    let output = wrap(formatted, screen.errtermwidth - 6, { trim: false, hard: true });
-    output = indent(output, 3);
-    output = indent(output, 1, { indent: bang || '', includeEmptyLines: true });
-    output = indent(output, 1);
+    let output = (0, wrap_ansi_1.default)(formatted, screen_1.errtermwidth - 6, { trim: false, hard: true });
+    output = (0, indent_string_1.default)(output, 3);
+    output = (0, indent_string_1.default)(output, 1, { indent: bang || '', includeEmptyLines: true });
+    output = (0, indent_string_1.default)(output, 1);
     return output;
 }
 exports.default = prettyPrint;

package/lib/errors/handle.d.ts

@@ -1,4 +1,14 @@
 import { OclifError, PrettyPrintableError } from '../interfaces';
-export declare function handle(err: Error & Partial<PrettyPrintableError> & Partial<OclifError> & {
+/**
+ * This is an odd abstraction for process.exit, but it allows us to stub it in tests.
+ *
+ * https://github.com/sinonjs/sinon/issues/562
+ */
+export declare const Exit: {
+    exit(code?: number): never;
+};
+type ErrorToHandle = Error & Partial<PrettyPrintableError> & Partial<OclifError> & {
     skipOclifErrorHandling?: boolean;
-}): Promise<void>;
+};
+export declare function handle(err: ErrorToHandle): Promise<void>;
+export {};

package/lib/errors/handle.js

@@ -1,41 +1,50 @@
 "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");
-const pretty_print_1 = require("./errors/pretty-print");
-const _1 = require(".");
-const clean = require("clean-stack");
+exports.handle = exports.Exit = void 0;
+const tslib_1 = require("tslib");
 const cli_1 = require("./errors/cli");
+const _1 = require(".");
+const clean_stack_1 = tslib_1.__importDefault(require("clean-stack"));
+const config_1 = require("./config");
+const pretty_print_1 = tslib_1.__importDefault(require("./errors/pretty-print"));
+/**
+ * This is an odd abstraction for process.exit, but it allows us to stub it in tests.
+ *
+ * https://github.com/sinonjs/sinon/issues/562
+ */
+exports.Exit = {
+    exit(code = 0) {
+        process.exit(code);
+    },
+};
 async function handle(err) {
     try {
         if (!err)
             err = new cli_1.CLIError('no error?');
         if (err.message === 'SIGINT')
-            process.exit(1);
+            exports.Exit.exit(1);
         const shouldPrint = !(err instanceof _1.ExitError) && !err.skipOclifErrorHandling;
         const pretty = (0, pretty_print_1.default)(err);
-        const stack = clean(err.stack || '', { pretty: true });
+        const stack = (0, clean_stack_1.default)(err.stack || '', { pretty: true });
         if (shouldPrint) {
-            console.error(pretty ? pretty : stack);
+            console.error(pretty ?? stack);
         }
-        const exitCode = err.oclif?.exit !== undefined && err.oclif?.exit !== false ? err.oclif?.exit : 1;
+        const exitCode = err.oclif?.exit ?? 1;
         if (config_1.config.errorLogger && err.code !== 'EEXIT') {
             if (stack) {
                 config_1.config.errorLogger.log(stack);
             }
             await config_1.config.errorLogger.flush()
-                .then(() => process.exit(exitCode))
+                .then(() => exports.Exit.exit(exitCode))
                 .catch(console.error);
         }
         else
-            process.exit(exitCode);
+            exports.Exit.exit(exitCode);
     }
     catch (error) {
         console.error(err.stack);
         console.error(error.stack);
-        process.exit(1);
+        exports.Exit.exit(1);
     }
 }
 exports.handle = handle;

package/lib/errors/index.d.ts

@@ -1,11 +1,10 @@
+import { PrettyPrintableError } from '../interfaces';
 export { handle } from './handle';
 export { ExitError } from './errors/exit';
 export { ModuleLoadError } from './errors/module-load';
 export { CLIError } from './errors/cli';
 export { Logger } from './logger';
 export { config } from './config';
-import { PrettyPrintableError } from '../interfaces';
-export { PrettyPrintableError };
 export declare function exit(code?: number): never;
 export declare function error(input: string | Error, options: {
     exit: false;
@@ -15,3 +14,4 @@ export declare function error(input: string | Error, options?: {
 } & PrettyPrintableError): never;
 export declare function warn(input: string | Error): void;
 export declare function memoizedWarn(input: string | Error): void;
+export { PrettyPrintableError } from '../interfaces';

package/lib/errors/index.js

@@ -1,33 +1,34 @@
 "use strict";
 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;
+const tslib_1 = require("tslib");
+const cli_1 = require("./errors/cli");
+const pretty_print_1 = tslib_1.__importStar(require("./errors/pretty-print"));
+const exit_1 = require("./errors/exit");
+const config_1 = require("./config");
 var handle_1 = require("./handle");
 Object.defineProperty(exports, "handle", { enumerable: true, get: function () { return handle_1.handle; } });
-var exit_1 = require("./errors/exit");
-Object.defineProperty(exports, "ExitError", { enumerable: true, get: function () { return exit_1.ExitError; } });
+var exit_2 = require("./errors/exit");
+Object.defineProperty(exports, "ExitError", { enumerable: true, get: function () { return exit_2.ExitError; } });
 var module_load_1 = require("./errors/module-load");
 Object.defineProperty(exports, "ModuleLoadError", { enumerable: true, get: function () { return module_load_1.ModuleLoadError; } });
-var cli_1 = require("./errors/cli");
-Object.defineProperty(exports, "CLIError", { enumerable: true, get: function () { return cli_1.CLIError; } });
+var cli_2 = require("./errors/cli");
+Object.defineProperty(exports, "CLIError", { enumerable: true, get: function () { return cli_2.CLIError; } });
 var logger_1 = require("./logger");
 Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return logger_1.Logger; } });
-var config_1 = require("./config");
-Object.defineProperty(exports, "config", { enumerable: true, get: function () { return config_1.config; } });
-const config_2 = require("./config");
-const cli_2 = require("./errors/cli");
-const exit_2 = require("./errors/exit");
-const pretty_print_1 = require("./errors/pretty-print");
+var config_2 = require("./config");
+Object.defineProperty(exports, "config", { enumerable: true, get: function () { return config_2.config; } });
 function exit(code = 0) {
-    throw new exit_2.ExitError(code);
+    throw new exit_1.ExitError(code);
 }
 exports.exit = exit;
 function error(input, options = {}) {
     let err;
     if (typeof input === 'string') {
-        err = new cli_2.CLIError(input, options);
+        err = new cli_1.CLIError(input, options);
     }
     else if (input instanceof Error) {
-        err = (0, cli_2.addOclifExitCode)(input, options);
+        err = (0, cli_1.addOclifExitCode)(input, options);
     }
     else {
         throw new TypeError('first argument must be a string or instance of Error');
@@ -36,8 +37,8 @@ function error(input, options = {}) {
     if (options.exit === false) {
         const message = (0, pretty_print_1.default)(err);
         console.error(message);
-        if (config_2.config.errorLogger)
-            config_2.config.errorLogger.log(err?.stack ?? '');
+        if (config_1.config.errorLogger)
+            config_1.config.errorLogger.log(err?.stack ?? '');
     }
     else
         throw err;
@@ -46,18 +47,18 @@ exports.error = error;
 function warn(input) {
     let err;
     if (typeof input === 'string') {
-        err = new cli_2.CLIError.Warn(input);
+        err = new cli_1.CLIError.Warn(input);
     }
     else if (input instanceof Error) {
-        err = (0, cli_2.addOclifExitCode)(input);
+        err = (0, cli_1.addOclifExitCode)(input);
     }
     else {
         throw new TypeError('first argument must be a string or instance of Error');
     }
     const message = (0, pretty_print_1.default)(err);
     console.error(message);
-    if (config_2.config.errorLogger)
-        config_2.config.errorLogger.log(err?.stack ?? '');
+    if (config_1.config.errorLogger)
+        config_1.config.errorLogger.log(err?.stack ?? '');
 }
 exports.warn = warn;
 const WARNINGS = new Set();

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/promises");
-const path_1 = require("path");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
 const stripAnsi = require("strip-ansi");
 const timestamp = () => new Date().toISOString();
 let timer;
@@ -35,8 +35,8 @@ class Logger {
                 return;
             const mylines = this.buffer;
             this.buffer = [];
-            await fs.mkdir((0, path_1.dirname)(this.file), { recursive: true });
-            await fs.appendFile(this.file, mylines.join('\n') + '\n');
+            await (0, promises_1.mkdir)((0, node_path_1.dirname)(this.file), { recursive: true });
+            await (0, promises_1.appendFile)(this.file, mylines.join('\n') + '\n');
         });
         await this.flushing;
     }

package/lib/execute.d.ts

@@ -1,4 +1,4 @@
-import * as Interfaces from './interfaces';
+import { LoadOptions } from './interfaces';
 /**
  * Load and run oclif CLI
  *
@@ -7,7 +7,7 @@ import * as Interfaces from './interfaces';
  *
  * @example For ESM dev.js
  * ```
- * #!/usr/bin/env node
+ * #!/usr/bin/env ts-node
  * void (async () => {
  *   const oclif = await import('@oclif/core')
  *   await oclif.execute({development: true, dir: import.meta.url})
@@ -25,7 +25,7 @@ import * as Interfaces from './interfaces';
  *
  * @example For CJS dev.js
  * ```
- * #!/usr/bin/env node
+ * #!/usr/bin/env ts-node
  * void (async () => {
  *   const oclif = await import('@oclif/core')
  *   await oclif.execute({development: true, dir: __dirname})
@@ -41,9 +41,9 @@ import * as Interfaces from './interfaces';
  * })()
  * ```
  */
-export default function execute(options: {
+export declare function execute(options: {
     dir: string;
     args?: string[];
-    loadOptions?: Interfaces.LoadOptions;
+    loadOptions?: LoadOptions;
     development?: boolean;
 }): Promise<unknown>;