@oclif/core 3.0.0-beta.17 → 3.0.0-beta.18

package/lib/config/config.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toCached = exports.Config = void 0;
+exports.Config = void 0;
 const tslib_1 = require("tslib");
 const ejs = tslib_1.__importStar(require("ejs"));
 const errors_1 = require("../errors");
@@ -11,8 +11,9 @@ const util_2 = require("../util");
 const node_path_1 = require("node:path");
 const performance_1 = require("../performance");
 const plugin_loader_1 = tslib_1.__importDefault(require("./plugin-loader"));
+const is_wsl_1 = tslib_1.__importDefault(require("is-wsl"));
 const node_util_1 = require("node:util");
-const help_1 = require("../help");
+const util_3 = require("../help/util");
 const module_loader_1 = require("../module-loader");
 const settings_1 = require("../settings");
 const stream_1 = require("../cli-ux/stream");
@@ -24,15 +25,11 @@ function channelFromVersion(version) {
     const m = version.match(/[^-]+(?:-([^.]+))?/);
     return (m && m[1]) || 'stable';
 }
-const WSL = require('is-wsl');
 function isConfig(o) {
     return o && Boolean(o._base);
 }
 class Permutations extends Map {
-    constructor() {
-        super(...arguments);
-        this.validPermutations = new Map();
-    }
+    validPermutations = new Map();
     add(permutation, commandId) {
         this.validPermutations.set(permutation, commandId);
         for (const id of (0, util_1.collectUsableIds)([permutation])) {
@@ -58,17 +55,45 @@ class Permutations extends Map {
     }
 }
 class Config {
+    options;
+    _base = BASE;
+    arch;
+    bin;
+    binPath;
+    cacheDir;
+    channel;
+    configDir;
+    dataDir;
+    debug = 0;
+    dirname;
+    errlog;
+    flexibleTaxonomy;
+    home;
+    name;
+    npmRegistry;
+    pjson;
+    platform;
+    plugins = new Map();
+    root;
+    shell;
+    topicSeparator = ':';
+    userAgent;
+    userPJSON;
+    valid;
+    version;
+    windows;
+    binAliases;
+    nsisCustomization;
+    warned = false;
+    commandPermutations = new Permutations();
+    topicPermutations = new Permutations();
+    _commands = new Map();
+    _topics = new Map();
+    _commandIDs;
+    pluginLoader;
+    static _rootPlugin;
     constructor(options) {
         this.options = options;
-        this._base = BASE;
-        this.debug = 0;
-        this.plugins = new Map();
-        this.topicSeparator = ':';
-        this.warned = false;
-        this.commandPermutations = new Permutations();
-        this.topicPermutations = new Permutations();
-        this._commands = new Map();
-        this._topics = new Map();
     }
     static async load(opts = module.filename || __dirname) {
         // Handle the case when a file URL string is passed in such as 'import.meta.url'; covert to file path.
@@ -119,7 +144,7 @@ class Config {
         this.channel = this.options.channel || channelFromVersion(this.version);
         this.valid = Config._rootPlugin.valid;
         this.arch = ((0, node_os_1.arch)() === 'ia32' ? 'x86' : (0, node_os_1.arch)());
-        this.platform = WSL ? 'wsl' : (0, util_2.getPlatform)();
+        this.platform = is_wsl_1.default ? 'wsl' : (0, util_2.getPlatform)();
         this.windows = this.platform === 'win32';
         this.bin = this.pjson.oclif.bin || this.name;
         this.binAliases = this.pjson.oclif.binAliases;
@@ -379,7 +404,7 @@ class Config {
      * @returns string[]
      */
     findMatches(partialCmdId, argv) {
-        const flags = argv.filter(arg => !(0, help_1.getHelpFlagAdditions)(this).includes(arg) && arg.startsWith('-')).map(a => a.replaceAll('-', ''));
+        const flags = argv.filter(arg => !(0, util_3.getHelpFlagAdditions)(this).includes(arg) && arg.startsWith('-')).map(a => a.replaceAll('-', ''));
         const possibleMatches = [...this.commandPermutations.get(partialCmdId)].map(k => this._commands.get(k));
         const matches = possibleMatches.filter(command => {
             const cmdFlags = Object.entries(command.flags).flatMap(([flag, def]) => def.char ? [def.char, flag] : [flag]);
@@ -694,148 +719,3 @@ class Config {
     }
 }
 exports.Config = Config;
-// when no manifest exists, the default is calculated.  This may throw, so we need to catch it
-const defaultFlagToCached = async (flag, respectNoCacheDefault) => {
-    if (respectNoCacheDefault && flag.noCacheDefault)
-        return;
-    // Prefer the defaultHelp function (returns a friendly string for complex types)
-    if (typeof flag.defaultHelp === 'function') {
-        try {
-            return await flag.defaultHelp({ options: flag, flags: {} });
-        }
-        catch {
-            return;
-        }
-    }
-    // if not specified, try the default function
-    if (typeof flag.default === 'function') {
-        try {
-            return await flag.default({ options: flag, flags: {} });
-        }
-        catch { }
-    }
-    else {
-        return flag.default;
-    }
-};
-const defaultArgToCached = async (arg, respectNoCacheDefault) => {
-    if (respectNoCacheDefault && arg.noCacheDefault)
-        return;
-    // Prefer the defaultHelp function (returns a friendly string for complex types)
-    if (typeof arg.defaultHelp === 'function') {
-        try {
-            return await arg.defaultHelp({ options: arg, flags: {} });
-        }
-        catch {
-            return;
-        }
-    }
-    // if not specified, try the default function
-    if (typeof arg.default === 'function') {
-        try {
-            return await arg.default({ options: arg, flags: {} });
-        }
-        catch { }
-    }
-    else {
-        return arg.default;
-    }
-};
-async function toCached(c, plugin, respectNoCacheDefault = false) {
-    const flags = {};
-    for (const [name, flag] of Object.entries(c.flags || {})) {
-        if (flag.type === 'boolean') {
-            flags[name] = {
-                name,
-                type: flag.type,
-                char: flag.char,
-                summary: flag.summary,
-                description: flag.description,
-                hidden: flag.hidden,
-                required: flag.required,
-                helpLabel: flag.helpLabel,
-                helpGroup: flag.helpGroup,
-                allowNo: flag.allowNo,
-                dependsOn: flag.dependsOn,
-                relationships: flag.relationships,
-                exclusive: flag.exclusive,
-                deprecated: flag.deprecated,
-                deprecateAliases: c.deprecateAliases,
-                aliases: flag.aliases,
-                charAliases: flag.charAliases,
-                delimiter: flag.delimiter,
-                noCacheDefault: flag.noCacheDefault,
-            };
-        }
-        else {
-            flags[name] = {
-                name,
-                type: flag.type,
-                char: flag.char,
-                summary: flag.summary,
-                description: flag.description,
-                hidden: flag.hidden,
-                required: flag.required,
-                helpLabel: flag.helpLabel,
-                helpValue: flag.helpValue,
-                helpGroup: flag.helpGroup,
-                multiple: flag.multiple,
-                options: flag.options,
-                dependsOn: flag.dependsOn,
-                relationships: flag.relationships,
-                exclusive: flag.exclusive,
-                default: await defaultFlagToCached(flag, respectNoCacheDefault),
-                deprecated: flag.deprecated,
-                deprecateAliases: c.deprecateAliases,
-                aliases: flag.aliases,
-                charAliases: flag.charAliases,
-                delimiter: flag.delimiter,
-                noCacheDefault: flag.noCacheDefault,
-            };
-            // a command-level placeholder in the manifest so that oclif knows it should regenerate the command during help-time
-            if (typeof flag.defaultHelp === 'function') {
-                c.hasDynamicHelp = true;
-            }
-        }
-    }
-    const args = {};
-    for (const [name, arg] of Object.entries((0, util_2.ensureArgObject)(c.args))) {
-        args[name] = {
-            name,
-            description: arg.description,
-            required: arg.required,
-            options: arg.options,
-            default: await defaultArgToCached(arg, respectNoCacheDefault),
-            hidden: arg.hidden,
-            noCacheDefault: arg.noCacheDefault,
-        };
-    }
-    const stdProperties = {
-        id: c.id,
-        summary: c.summary,
-        description: c.description,
-        strict: c.strict,
-        usage: c.usage,
-        pluginName: plugin && plugin.name,
-        pluginAlias: plugin && plugin.alias,
-        pluginType: plugin && plugin.type,
-        hidden: c.hidden,
-        state: c.state,
-        aliases: c.aliases || [],
-        examples: c.examples || c.example,
-        deprecationOptions: c.deprecationOptions,
-        deprecateAliases: c.deprecateAliases,
-        flags,
-        args,
-    };
-    // do not include these properties in manifest
-    const ignoreCommandProperties = ['plugin', '_flags', '_enableJsonFlag', '_globalFlags', '_baseFlags'];
-    const stdKeys = Object.keys(stdProperties);
-    const keysToAdd = Object.keys(c).filter(property => ![...stdKeys, ...ignoreCommandProperties].includes(property));
-    const additionalProperties = {};
-    for (const key of keysToAdd) {
-        additionalProperties[key] = c[key];
-    }
-    return { ...stdProperties, ...additionalProperties };
-}
-exports.toCached = toCached;

package/lib/config/index.d.ts

@@ -1,4 +1,3 @@
 export { Config } from './config';
-export { toCached } from './config';
 export { Plugin } from './plugin';
 export { tsPath } from './ts-node';

package/lib/config/index.js

@@ -1,10 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tsPath = exports.Plugin = exports.toCached = exports.Config = void 0;
+exports.tsPath = exports.Plugin = exports.Config = void 0;
 var config_1 = require("./config");
 Object.defineProperty(exports, "Config", { enumerable: true, get: function () { return config_1.Config; } });
-var config_2 = require("./config");
-Object.defineProperty(exports, "toCached", { enumerable: true, get: function () { return config_2.toCached; } });
 var plugin_1 = require("./plugin");
 Object.defineProperty(exports, "Plugin", { enumerable: true, get: function () { return plugin_1.Plugin; } });
 var ts_node_1 = require("./ts-node");

package/lib/config/plugin-loader.js

@@ -9,11 +9,12 @@ const node_path_1 = require("node:path");
 // eslint-disable-next-line new-cap
 const debug = (0, util_2.Debug)();
 class PluginLoader {
+    options;
+    plugins = new Map();
+    errors = [];
+    pluginsProvided = false;
     constructor(options) {
         this.options = options;
-        this.plugins = new Map();
-        this.errors = [];
-        this.pluginsProvided = false;
         if (options.plugins) {
             this.pluginsProvided = true;
             this.plugins = Array.isArray(options.plugins) ? new Map(options.plugins.map(p => [p.name, p])) : options.plugins;
@@ -27,7 +28,7 @@ class PluginLoader {
         }
         else {
             const marker = performance_1.Performance.mark('plugin.load#root');
-            rootPlugin = new Plugin.Plugin({ root: this.options.root });
+            rootPlugin = new Plugin.Plugin({ root: this.options.root, isRoot: true });
             await rootPlugin.load();
             marker?.addDetails({
                 hasManifest: rootPlugin.hasManifest ?? false,

package/lib/config/plugin.d.ts

@@ -24,6 +24,7 @@ export declare class Plugin implements IPlugin {
     parent: Plugin | undefined;
     children: Plugin[];
     hasManifest: boolean;
+    isRoot: boolean;
     private _commandsDir;
     private flexibleTaxonomy;
     protected _debug: (..._: any) => void;

package/lib/config/plugin.js

@@ -7,9 +7,9 @@ const util_2 = require("../util");
 const node_path_1 = require("node:path");
 const module_loader_1 = require("../module-loader");
 const performance_1 = require("../performance");
+const cache_command_1 = require("../util/cache-command");
 const node_util_1 = require("node:util");
 const globby_1 = require("globby");
-const config_1 = require("./config");
 const ts_node_1 = require("./ts-node");
 const _pjson = (0, util_2.requireJson)(__dirname, '..', '..', 'package.json');
 function topicsToArray(input, base) {
@@ -17,9 +17,9 @@ function topicsToArray(input, base) {
         return [];
     base = base ? `${base}:` : '';
     if (Array.isArray(input)) {
-        return [...input, ...(0, util_1.flatMap)(input, t => topicsToArray(t.subtopics, `${base}${t.name}`))];
+        return [...input, input.flatMap(t => topicsToArray(t.subtopics, `${base}${t.name}`))];
     }
-    return (0, util_1.flatMap)(Object.keys(input), k => {
+    return Object.keys(input).flatMap(k => {
         input[k].name = k;
         return [{ ...input[k], name: `${base}${k}` }, ...topicsToArray(input[k].subtopics, `${base}${input[k].name}`)];
     });
@@ -95,20 +95,37 @@ const search = (cmd) => {
     return Object.values(cmd).find((cmd) => typeof cmd.run === 'function');
 };
 class Plugin {
+    options;
+    _base = `${_pjson.name}@${_pjson.version}`;
+    name;
+    version;
+    pjson;
+    type;
+    moduleType;
+    root;
+    alias;
+    tag;
+    manifest;
+    commands;
+    hooks;
+    valid = false;
+    alreadyLoaded = false;
+    parent;
+    children = [];
+    hasManifest = false;
+    isRoot = false;
+    _commandsDir;
+    flexibleTaxonomy;
+    // eslint-disable-next-line new-cap
+    _debug = (0, util_1.Debug)();
+    warned = false;
     constructor(options) {
         this.options = options;
-        this._base = `${_pjson.name}@${_pjson.version}`;
-        this.valid = false;
-        this.alreadyLoaded = false;
-        this.children = [];
-        this.hasManifest = false;
-        // eslint-disable-next-line new-cap
-        this._debug = (0, util_1.Debug)();
-        this.warned = false;
     }
     async load() {
         this.type = this.options.type || 'core';
         this.tag = this.options.tag;
+        this.isRoot = this.options.isRoot ?? false;
         if (this.options.parent)
             this.parent = this.options.parent;
         // Linked plugins already have a root so there's no need to search for it.
@@ -138,7 +155,7 @@ class Plugin {
         else {
             this.pjson.oclif = this.pjson['cli-engine'] || {};
         }
-        this.hooks = (0, util_1.mapValues)(this.pjson.oclif.hooks || {}, i => Array.isArray(i) ? i : [i]);
+        this.hooks = (0, util_2.mapValues)(this.pjson.oclif.hooks || {}, i => Array.isArray(i) ? i : [i]);
         this.manifest = await this._manifest();
         this.commands = Object
             .entries(this.manifest.commands)
@@ -255,7 +272,7 @@ class Plugin {
             version: this.version,
             commands: (await Promise.all(this.commandIDs.map(async (id) => {
                 try {
-                    const cached = await (0, config_1.toCached)(await this.findCommand(id, { must: true }), this, respectNoCacheDefault);
+                    const cached = await (0, cache_command_1.cacheCommand)(await this.findCommand(id, { must: true }), this, respectNoCacheDefault);
                     if (this.flexibleTaxonomy) {
                         const permutations = (0, util_1.getCommandIdPermutations)(id);
                         const aliasPermutations = cached.aliases.flatMap(a => (0, util_1.getCommandIdPermutations)(a));
@@ -264,7 +281,7 @@ class Plugin {
                     return [id, cached];
                 }
                 catch (error) {
-                    const scope = 'toCached';
+                    const scope = 'cacheCommand';
                     if (Boolean(errorOnManifestCreate) === false)
                         this.warn(error, scope);
                     else

package/lib/config/ts-node.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 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");
@@ -12,6 +11,11 @@ const settings_1 = require("../settings");
 const debug = (0, util_2.Debug)('ts-node');
 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 (exports.TS_CONFIGS[root])
         return exports.TS_CONFIGS[root];
@@ -105,6 +109,8 @@ function registerTSNode(root) {
     return tsconfig;
 }
 function tsPath(root, orig, plugin) {
+    if (plugin?.isRoot)
+        ROOT_PLUGIN = plugin;
     if (!orig)
         return orig;
     orig = orig.startsWith(root) ? orig : (0, node_path_1.join)(root, orig);
@@ -126,8 +132,8 @@ function tsPath(root, orig, plugin) {
      * 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 ((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-transpiled. Existing compiled source will be used instead.`);
         return orig;

package/lib/config/util.d.ts

@@ -1,9 +1,3 @@
-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 resolvePackage(id: string, paths: {
     paths: string[];
 }): string;

package/lib/config/util.js

@@ -1,19 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.collectUsableIds = exports.getCommandIdPermutations = exports.getPermutations = exports.Debug = exports.resolvePackage = exports.mapValues = exports.flatMap = void 0;
+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 resolvePackage(id, paths) {
     return require.resolve(id, paths);
 }

package/lib/errors/errors/cli.js

@@ -20,9 +20,11 @@ function addOclifExitCode(error, options) {
 }
 exports.addOclifExitCode = addOclifExitCode;
 class CLIError extends Error {
+    oclif = {};
+    code;
+    suggestions;
     constructor(error, options = {}) {
         super(error instanceof Error ? error.message : error);
-        this.oclif = {};
         addOclifExitCode(this, options);
         this.code = options.code;
         this.suggestions = options.suggestions;

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.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/handle.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.handle = exports.Exit = void 0;
 const tslib_1 = require("tslib");
 const cli_1 = require("./errors/cli");
-const _1 = require(".");
+const exit_1 = require("./errors/exit");
 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"));
@@ -23,7 +23,7 @@ async function handle(err) {
             err = new cli_1.CLIError('no error?');
         if (err.message === 'SIGINT')
             exports.Exit.exit(1);
-        const shouldPrint = !(err instanceof _1.ExitError) && !err.skipOclifErrorHandling;
+        const shouldPrint = !(err instanceof exit_1.ExitError) && !err.skipOclifErrorHandling;
         const pretty = (0, pretty_print_1.default)(err);
         const stack = (0, clean_stack_1.default)(err.stack || '', { pretty: true });
         if (shouldPrint) {

package/lib/errors/logger.js

@@ -17,10 +17,11 @@ function chomp(s) {
     return s;
 }
 class Logger {
+    file;
+    flushing = Promise.resolve();
+    buffer = [];
     constructor(file) {
         this.file = file;
-        this.flushing = Promise.resolve();
-        this.buffer = [];
     }
     log(msg) {
         msg = stripAnsi(chomp(msg));

package/lib/flags.d.ts

@@ -12,7 +12,7 @@ export declare function custom<T = string, P extends CustomOptions = CustomOptio
     multiple: true;
     requiredOrDefaulted: true;
 }>;
-export declare function custom<T = string, P extends CustomOptions = CustomOptions>(defaults: Partial<OptionFlag<T, P>> & {
+export declare function custom<T = string, P extends CustomOptions = CustomOptions>(defaults: Partial<OptionFlag<NotArray<T>, P>> & {
     multiple?: false | undefined;
 } & ({
     required: true;
@@ -22,7 +22,7 @@ export declare function custom<T = string, P extends CustomOptions = CustomOptio
     multiple: false;
     requiredOrDefaulted: true;
 }>;
-export declare function custom<T = string, P extends CustomOptions = CustomOptions>(defaults: Partial<OptionFlag<T, P>> & {
+export declare function custom<T = string, P extends CustomOptions = CustomOptions>(defaults: Partial<OptionFlag<NotArray<T>, P>> & {
     default?: OptionFlag<NotArray<T>, P>['default'] | undefined;
     multiple?: false | undefined;
     required?: false | undefined;

package/lib/help/command.js

@@ -17,6 +17,9 @@ if (process.env.ConEmuANSI === 'ON') {
     dim = chalk_1.default.gray;
 }
 class CommandHelp extends formatter_1.HelpFormatter {
+    command;
+    config;
+    opts;
     constructor(command, config, opts) {
         super(config, opts);
         this.command = command;

package/lib/help/docopts.js

@@ -59,6 +59,9 @@ const util_1 = require("../util");
  *
  */
 class DocOpts {
+    cmd;
+    flagMap;
+    flagList;
     constructor(cmd) {
         this.cmd = cmd;
         // Create a new map with references to the flags that we can manipulate.

package/lib/help/formatter.js

@@ -11,12 +11,23 @@ const widest_line_1 = tslib_1.__importDefault(require("widest-line"));
 const string_width_1 = tslib_1.__importDefault(require("string-width"));
 const wrap_ansi_1 = tslib_1.__importDefault(require("wrap-ansi"));
 class HelpFormatter {
+    indentSpacing = 2;
+    /**
+     * Takes a string and replaces `<%= prop =>` with the value of prop, where prop is anything on
+     * `config=Interfaces.Config` or `opts=Interface.HelpOptions`.
+     *
+     * ```javascript
+     * `<%= config.bin =>` // will resolve to the bin defined in `pjson.oclif`.
+     * ```
+     */
+    render;
     constructor(config, opts = {}) {
-        this.indentSpacing = 2;
         this.config = config;
         this.opts = { maxWidth: screen_1.stdtermwidth, ...opts };
         this.render = (0, util_1.template)(this);
     }
+    config;
+    opts;
     /**
      * Wrap text according to `opts.maxWidth` which is typically set to the terminal width. All text
      * will be rendered before bring wrapped, otherwise it could mess up the lengths.

package/lib/help/index.d.ts

@@ -3,7 +3,7 @@ import { Command } from '../command';
 import { CommandHelp } from './command';
 import { HelpFormatter } from './formatter';
 export { CommandHelp } from './command';
-export { standardizeIDFromArgv, loadHelpClass, getHelpFlagAdditions, normalizeArgv } from './util';
+export { standardizeIDFromArgv, getHelpFlagAdditions, normalizeArgv } from './util';
 export declare abstract class HelpBase extends HelpFormatter {
     constructor(config: Interfaces.Config, opts?: Partial<Interfaces.HelpOptions>);
     /**
@@ -39,3 +39,7 @@ export declare class Help extends HelpBase {
     protected command(command: Command.Class): string;
     protected log(...args: string[]): void;
 }
+interface HelpBaseDerived {
+    new (config: Interfaces.Config, opts?: Partial<Interfaces.HelpOptions>): HelpBase;
+}
+export declare function loadHelpClass(config: Interfaces.Config): Promise<HelpBaseDerived>;