@oclif/core 3.0.0-beta.9 → 3.0.1

package/lib/config/ts-node.js

@@ -1,38 +1,47 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tsPath = void 0;
-const fs = require("fs");
-const path = require("path");
+exports.tsPath = exports.TS_CONFIGS = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const errors_1 = require("../errors");
 const settings_1 = require("../settings");
-const util_1 = require("../util");
+const fs_1 = require("../util/fs");
+const util_1 = require("../util/util");
 const util_2 = require("./util");
-const config_1 = require("./config");
-const errors_1 = require("../errors");
 // eslint-disable-next-line new-cap
 const debug = (0, util_2.Debug)('ts-node');
-const TS_CONFIGS = {};
+exports.TS_CONFIGS = {};
 const REGISTERED = new Set();
+/**
+ * Cache the root plugin so that we can reference it later when determining if
+ * we should skip ts-node registration for an ESM plugin.
+ */
+let ROOT_PLUGIN;
 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 {
+            debug(`Could not find typescript dependency. Skipping ts-node registration for ${root}.`);
+            (0, errors_1.memoizedWarn)('Could not find typescript. Please ensure that typescript is a devDependency. Falling back to compiled source.');
+            return;
         }
-        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, fs_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.');
         }
-        TS_CONFIGS[root] = tsconfig;
+        exports.TS_CONFIGS[root] = tsconfig;
         return tsconfig;
     }
 }
@@ -45,40 +54,46 @@ function registerTSNode(root) {
     debug('registering ts-node at', root);
     const tsNodePath = require.resolve('ts-node', { paths: [root, __dirname] });
     debug('ts-node path:', tsNodePath);
-    const tsNode = require(tsNodePath);
-    const typeRoots = [
-        path.join(root, 'node_modules', '@types'),
-    ];
+    let tsNode;
+    try {
+        tsNode = require(tsNodePath);
+    }
+    catch {
+        debug(`Could not find ts-node at ${tsNodePath}. Skipping ts-node registration for ${root}.`);
+        (0, errors_1.memoizedWarn)(`Could not find ts-node at ${tsNodePath}. Please ensure that ts-node is a devDependency. Falling back to compiled source.`);
+        return;
+    }
+    const typeRoots = [(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: {
+            emitDecoratorMetadata: tsconfig.compilerOptions.emitDecoratorMetadata ?? false,
             esModuleInterop: tsconfig.compilerOptions.esModuleInterop,
-            target: tsconfig.compilerOptions.target ?? 'es2019',
             experimentalDecorators: tsconfig.compilerOptions.experimentalDecorators ?? false,
-            emitDecoratorMetadata: tsconfig.compilerOptions.emitDecoratorMetadata ?? false,
             module: tsconfig.compilerOptions.module ?? 'commonjs',
-            sourceMap: tsconfig.compilerOptions.sourceMap ?? true,
             rootDirs,
+            sourceMap: tsconfig.compilerOptions.sourceMap ?? true,
+            target: tsconfig.compilerOptions.target ?? 'es2019',
             typeRoots,
         },
-        skipProject: true,
-        transpileOnly: true,
+        cwd: root,
         esm: tsconfig['ts-node']?.esm ?? true,
+        experimentalSpecifierResolution: tsconfig['ts-node']?.experimentalSpecifierResolution ?? 'explicit',
         scope: true,
         scopeDir: root,
-        cwd: root,
-        experimentalSpecifierResolution: tsconfig['ts-node']?.experimentalSpecifierResolution ?? 'explicit',
+        skipProject: true,
+        transpileOnly: true,
     };
     if (tsconfig.compilerOptions.moduleResolution) {
         // @ts-expect-error TSNode.RegisterOptions.compilerOptions is typed as a plain object
@@ -92,39 +107,37 @@ function registerTSNode(root) {
     REGISTERED.add(root);
     return tsconfig;
 }
-// eslint-disable-next-line complexity
 function tsPath(root, orig, plugin) {
+    if (plugin?.isRoot)
+        ROOT_PLUGIN = 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.default.tsnodeEnabled === false) {
+    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 if plugin is an ESM plugin executing from a CJS plugin
-    if (plugin?.moduleType === 'module' && config_1.Config.rootPlugin?.moduleType === 'commonjs') {
-        debug(`Skipping ts-node registration for ${root} because it's an ESM module but the root plugin is CommonJS`);
+    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 || ROOT_PLUGIN?.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: ${ROOT_PLUGIN?.moduleType})))`);
         if (plugin.type === 'link')
-            (0, errors_1.memoizedWarn)(`${plugin.name} is a linked ESM module and cannot be auto-compiled from a CommonJS root plugin. Existing compiled source will be used instead.`);
+            (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 plugin is an ESM plugin being executed from an ESM root plugin, check to see if ts-node/esm loader has been set
-    // either in the NODE_OPTIONS env var or from the exec args. If the ts-node/esm loader has NOT been loaded then we want
-    // to skip ts-node registration so that it falls back on the compiled source.
-    if (plugin?.moduleType === 'module') {
-        const tsNodeEsmLoaderInExecArgv = process.execArgv.includes('--loader') && process.execArgv.includes('ts-node/esm');
-        const tsNodeEsmLoaderInNodeOptions = process.env.NODE_OPTIONS?.includes('--loader=ts-node/esm') ?? false;
-        if (!tsNodeEsmLoaderInExecArgv && !tsNodeEsmLoaderInNodeOptions) {
-            debug(`Skipping ts-node registration for ${root} because it's an ESM module but the ts-node/esm loader hasn't been run`);
-            debug('try setting NODE_OPTIONS="--loader ts-node/esm" in your environment.');
-            if (plugin.type === 'link') {
-                (0, errors_1.memoizedWarn)(`${plugin.name} is a linked ESM module and cannot be auto-compiled without setting NODE_OPTIONS="--loader=ts-node/esm" in the environment. Existing compiled source will be used instead.`);
-            }
-            return orig;
-        }
-    }
-    if (settings_1.default.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;
     }
@@ -132,22 +145,22 @@ function tsPath(root, orig, plugin) {
         const tsconfig = registerTSNode(root);
         if (!tsconfig)
             return orig;
-        const { rootDir, rootDirs, outDir } = tsconfig.compilerOptions;
+        const { outDir, rootDir, rootDirs } = tsconfig.compilerOptions;
         const rootDirPath = rootDir || (rootDirs || [])[0];
         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

@@ -1,16 +1,6 @@
-export declare function flatMap<T, U>(arr: T[], fn: (i: T) => U[]): U[];
-export declare function mapValues<T extends Record<string, any>, TResult>(obj: {
-    [P in keyof T]: T[P];
-}, 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 +23,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,54 +1,11 @@
 "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 = void 0;
 const debug = require('debug');
-function flatMap(arr, fn) {
-    return arr.reduce((arr, i) => [...arr, ...fn(i)], []);
-}
-exports.flatMap = flatMap;
-function mapValues(obj, fn) {
-    return Object.entries(obj)
-        .reduce((o, [k, v]) => {
-        o[k] = fn(v, k);
-        return o;
-    }, {});
-}
-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 +17,9 @@ function displayWarnings() {
 }
 function Debug(...scope) {
     if (!debug)
-        return (..._) => { };
+        return (..._) => {
+            // noop
+        };
     const d = debug(['config', ...scope].join(':'));
     if (d.enabled)
         displayWarnings();
@@ -89,7 +48,7 @@ function getPermutations(arr) {
 }
 exports.getPermutations = getPermutations;
 function getCommandIdPermutations(commandId) {
-    return getPermutations(commandId.split(':')).flatMap(c => c.join(':'));
+    return getPermutations(commandId.split(':')).flatMap((c) => c.join(':'));
 }
 exports.getCommandIdPermutations = getCommandIdPermutations;
 /**
@@ -111,17 +70,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.d.ts

@@ -1,6 +1,6 @@
 import { Logger } from './logger';
 export declare const config: {
-    errorLogger: Logger | undefined;
     debug: boolean;
     errlog: string | undefined;
+    errorLogger: Logger | undefined;
 };

package/lib/errors/config.js

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

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

@@ -1,28 +1,28 @@
-import { PrettyPrintableError, OclifError } from '../../interfaces/errors';
+import { OclifError, PrettyPrintableError } from '../../interfaces/errors';
 /**
  * properties specific to internal oclif error handling
  */
 export declare function addOclifExitCode(error: Record<string, any>, options?: {
-    exit?: number | false;
+    exit?: false | number;
 }): OclifError;
 export declare class CLIError extends Error implements OclifError {
-    oclif: OclifError['oclif'];
     code?: string;
+    oclif: OclifError['oclif'];
     suggestions?: string[];
-    constructor(error: string | Error, options?: {
-        exit?: number | false;
+    constructor(error: Error | string, options?: {
+        exit?: false | number;
     } & PrettyPrintableError);
-    get stack(): string;
     /**
      * @deprecated `render` Errors display should be handled by display function, like pretty-print
      * @return {string} returns a string representing the dispay of the error
      */
     render(): string;
     get bang(): string | undefined;
+    get stack(): string;
 }
 export declare namespace CLIError {
     class Warn extends CLIError {
-        constructor(err: string | Error);
+        constructor(err: Error | string);
         get bang(): string | undefined;
     }
 }

package/lib/errors/errors/cli.js

@@ -1,17 +1,19 @@
 "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 clean_stack_1 = tslib_1.__importDefault(require("clean-stack"));
+const indent_string_1 = tslib_1.__importDefault(require("indent-string"));
+const wrap_ansi_1 = tslib_1.__importDefault(require("wrap-ansi"));
+const screen_1 = require("../../screen");
 const config_1 = require("../config");
 /**
  * properties specific to internal oclif error handling
  */
 function addOclifExitCode(error, options) {
     if (!('oclif' in error)) {
+        ;
         error.oclif = {};
     }
     error.oclif.exit = options?.exit === undefined ? 2 : options.exit;
@@ -19,16 +21,15 @@ function addOclifExitCode(error, options) {
 }
 exports.addOclifExitCode = addOclifExitCode;
 class CLIError extends Error {
+    code;
+    oclif = {};
+    suggestions;
     constructor(error, options = {}) {
         super(error instanceof Error ? error.message : error);
-        this.oclif = {};
         addOclifExitCode(this, options);
         this.code = options.code;
         this.suggestions = options.suggestions;
     }
-    get stack() {
-        return cs(super.stack, { pretty: true });
-    }
     /**
      * @deprecated `render` Errors display should be handled by display function, like pretty-print
      * @return {string} returns a string representing the dispay of the error
@@ -38,18 +39,21 @@ 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, { hard: true, trim: false });
+        output = (0, indent_string_1.default)(output, 3);
+        output = (0, indent_string_1.default)(output, 1, { includeEmptyLines: true, indent: this.bang });
+        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 { }
     }
+    get stack() {
+        return (0, clean_stack_1.default)(super.stack, { pretty: true });
+    }
 }
 exports.CLIError = CLIError;
 (function (CLIError) {
@@ -60,10 +64,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';
+import { CLIError } from './cli';
 export declare class ExitError extends CLIError implements OclifError {
-    oclif: {
-        exit: number;
-    };
     code: string;
     constructor(exitCode?: number);
     render(): string;

package/lib/errors/errors/exit.js

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExitError = void 0;
 const cli_1 = require("./cli");
 class ExitError extends cli_1.CLIError {
+    code = 'EEXIT';
     constructor(exitCode = 1) {
         super(`EEXIT: ${exitCode}`, { exit: exitCode });
-        this.code = 'EEXIT';
     }
     render() {
         return '';

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

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

package/lib/errors/errors/module-load.js

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ModuleLoadError = void 0;
 const cli_1 = require("./cli");
 class ModuleLoadError extends cli_1.CLIError {
+    code = 'MODULE_NOT_FOUND';
     constructor(message) {
         super(`[MODULE_NOT_FOUND] ${message}`, { exit: 1 });
-        this.code = 'MODULE_NOT_FOUND';
         this.name = 'ModuleLoadError';
     }
 }

package/lib/errors/errors/pretty-print.d.ts

@@ -1,7 +1,7 @@
 import { PrettyPrintableError } from '../../interfaces/errors';
 type CLIErrorDisplayOptions = {
-    name?: string;
     bang?: string;
+    name?: string;
 };
 export declare function applyPrettyPrintOptions(error: Error, options: PrettyPrintableError): PrettyPrintableError;
 export default function prettyPrint(error: Error & PrettyPrintableError & CLIErrorDisplayOptions): string | undefined;

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

@@ -1,15 +1,17 @@
 "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 indent_string_1 = tslib_1.__importDefault(require("indent-string"));
+const wrap_ansi_1 = tslib_1.__importDefault(require("wrap-ansi"));
+const screen_1 = require("../../screen");
 const config_1 = require("../config");
 function applyPrettyPrintOptions(error, options) {
     const prettyErrorKeys = ['message', 'code', 'ref', 'suggestions'];
     for (const key of prettyErrorKeys) {
         const applyOptionsKey = !(key in error) && options[key];
         if (applyOptionsKey) {
+            ;
             error[key] = options[key];
         }
     }
@@ -22,14 +24,14 @@ const formatSuggestions = (suggestions) => {
         return undefined;
     if (suggestions.length === 1)
         return `${label} ${suggestions[0]}`;
-    const multiple = suggestions.map(suggestion => `* ${suggestion}`).join('\n');
-    return `${label}\n${indent(multiple, 2)}`;
+    const multiple = suggestions.map((suggestion) => `* ${suggestion}`).join('\n');
+    return `${label}\n${(0, indent_string_1.default)(multiple, 2)}`;
 };
 function prettyPrint(error) {
     if (config_1.config.debug) {
         return error.stack;
     }
-    const { message, code, suggestions, ref, name: errorSuffix, bang } = error;
+    const { bang, code, message, name: errorSuffix, ref, suggestions } = error;
     // errorSuffix is pulled from the 'name' property on CLIError
     // and is like either Error or Warning
     const formattedHeader = message ? `${errorSuffix || 'Error'}: ${message}` : undefined;
@@ -39,10 +41,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, { hard: true, trim: false });
+    output = (0, indent_string_1.default)(output, 3);
+    output = (0, indent_string_1.default)(output, 1, { includeEmptyLines: true, indent: bang || '' });
+    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 default 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 {};