@oclif/core 3.0.0-beta.1 → 3.0.0-beta.3

package/README.md

@@ -11,12 +11,14 @@ base library for oclif CLIs
 Migrating
 =====
 
-See the [migration guide](./MIGRATION.md) for an overview of breaking changes that occurred between v1 and v2.
+See the [v2 migration guide](./guides/V2_MIGRATION.md) for an overview of breaking changes that occurred between v1 and v2.
+
+See the [v3 migration guide](./guides/V3_MIGRATION.md) for an overview of breaking changes that occurred between v2 and v3.
 
 CLI UX
 =====
 
-The [ux README](./src/cli-ux/README.md) contains detailed usage examples of using the `ux` export.
+The [ux README](./src/ux/README.md) contains detailed usage examples of using the `ux` export.
 
 Usage
 =====
@@ -28,7 +30,7 @@ You can, however, use `@oclif/core` in a standalone script like this:
 #!/usr/bin/env ts-node
 
 import * as fs from 'fs'
-import {Command, Flags} from '@oclif/core'
+import {Command, Flags, flush, handle} from '@oclif/core'
 
 class LS extends Command {
   static description = 'List the files in a directory.'
@@ -50,10 +52,10 @@ class LS extends Command {
   }
 }
 
-LS.run().then(() => {
-  require('@oclif/core/flush')
-}, () => {
-  require('@oclif/core/handle')
+LS.run().then(async () => {
+  await flush()
+}, async (err) => {
+  await handle(err)
 })
 ```
 

package/lib/command.d.ts

@@ -157,6 +157,8 @@ export declare namespace Command {
             [name: string]: Arg.Cached;
         };
         hasDynamicHelp?: boolean;
+        permutations?: string[];
+        aliasPermutations?: string[];
     };
     type Flag = CompletableFlag<any>;
     namespace Flag {

package/lib/command.js

@@ -4,14 +4,14 @@ exports.Command = void 0;
 const url_1 = require("url");
 const chalk = require("chalk");
 const util_1 = require("util");
-const cli_ux_1 = require("./cli-ux");
+const ux_1 = require("./ux");
 const config_1 = require("./config");
 const Errors = require("./errors");
 const Parser = require("./parser");
 const util_2 = require("./help/util");
 const flags_1 = require("./flags");
 const util_3 = require("./util");
-const stream_1 = require("./cli-ux/stream");
+const stream_1 = require("./ux/stream");
 const pjson = (0, util_3.requireJson)(__dirname, '..', 'package.json');
 /**
  * swallows stdout epipe errors
@@ -231,7 +231,7 @@ class Command {
             if (!err.message)
                 throw err;
             try {
-                cli_ux_1.ux.action.stop(chalk.bold.red('!'));
+                ux_1.default.action.stop(chalk.bold.red('!'));
             }
             catch { }
             throw err;
@@ -254,7 +254,7 @@ class Command {
         return { error: err };
     }
     logJson(json) {
-        cli_ux_1.ux.styledJSON(json);
+        ux_1.default.styledJSON(json);
     }
     removeEnvVar(envVar) {
         const keys = [];

package/lib/config/config.d.ts

@@ -1,7 +1,6 @@
 import { Options, Plugin as IPlugin } from '../interfaces/plugin';
 import { Config as IConfig, ArchTypes, PlatformTypes, LoadOptions, VersionDetails } from '../interfaces/config';
 import { Hook, Hooks, PJSON, Topic } from '../interfaces';
-import * as Plugin from './plugin';
 import { Command } from '../command';
 export declare class Config implements IConfig {
     options: Options;
@@ -22,7 +21,7 @@ export declare class Config implements IConfig {
     npmRegistry?: string;
     pjson: PJSON.CLI;
     platform: PlatformTypes;
-    plugins: IPlugin[];
+    plugins: Map<string, IPlugin>;
     root: string;
     shell: string;
     topicSeparator: ':' | ' ';
@@ -39,13 +38,15 @@ export declare class Config implements IConfig {
     private _commands;
     private _topics;
     private _commandIDs;
+    private pluginLoader;
+    private static _rootPlugin;
     constructor(options: Options);
     static load(opts?: LoadOptions): Promise<Config>;
+    static get rootPlugin(): IPlugin | undefined;
     load(): Promise<void>;
-    loadPluginsAndCommands(): Promise<void>;
-    loadCorePlugins(): Promise<void>;
-    loadDevPlugins(): Promise<void>;
-    loadUserPlugins(): Promise<void>;
+    loadPluginsAndCommands(opts?: {
+        force: boolean;
+    }): Promise<void>;
     runHook<T extends keyof Hooks>(event: T, opts: Hooks[T]['options'], timeout?: number, captureErrors?: boolean): Promise<Hook.Result<Hooks[T]['return']>>;
     runCommand<T = unknown>(id: string, argv?: string[], cachedCommand?: Command.Loadable | null): Promise<T>;
     scopedEnvVar(k: string): string | undefined;
@@ -104,6 +105,7 @@ export declare class Config implements IConfig {
     get versionDetails(): VersionDetails;
     s3Key(type: keyof PJSON.S3.Templates, ext?: '.tar.gz' | '.tar.xz' | IConfig.s3Key.Options, options?: IConfig.s3Key.Options): string;
     s3Url(key: string): string;
+    getPluginsList(): IPlugin[];
     protected dir(category: 'cache' | 'data' | 'config'): string;
     protected windowsHome(): string | undefined;
     protected windowsHomedriveHome(): string | undefined;
@@ -111,11 +113,6 @@ export declare class Config implements IConfig {
     protected macosCacheDir(): string | undefined;
     protected _shell(): string;
     protected _debug(): number;
-    protected loadPlugins(root: string, type: string, plugins: (string | {
-        root?: string;
-        name?: string;
-        tag?: string;
-    })[], parent?: Plugin.Plugin): Promise<void>;
     protected warn(err: string | Error | {
         name: string;
         detail: string;
@@ -157,4 +154,4 @@ export declare class Config implements IConfig {
       */
     private insertLegacyPlugins;
 }
-export declare function toCached(c: Command.Class, plugin?: IPlugin | undefined, isWritingManifest?: boolean): Promise<Command.Cached>;
+export declare function toCached(c: Command.Class, plugin?: IPlugin, respectNoCacheDefault?: boolean): Promise<Command.Cached>;

package/lib/config/config.js

@@ -7,19 +7,20 @@ const os = require("os");
 const path = require("path");
 const url_1 = require("url");
 const util_1 = require("util");
-const Plugin = require("./plugin");
 const util_2 = require("./util");
 const util_3 = require("../util");
 const module_loader_1 = require("../module-loader");
 const help_1 = require("../help");
-const stream_1 = require("../cli-ux/stream");
+const stream_1 = require("../ux/stream");
 const performance_1 = require("../performance");
 const settings_1 = require("../settings");
 const node_os_1 = require("node:os");
 const node_path_1 = require("node:path");
+const plugin_loader_1 = require("./plugin-loader");
 // eslint-disable-next-line new-cap
 const debug = (0, util_2.Debug)();
 const _pjson = (0, util_3.requireJson)(__dirname, '..', '..', 'package.json');
+const BASE = `${_pjson.name}@${_pjson.version}`;
 function channelFromVersion(version) {
     const m = version.match(/[^-]+(?:-([^.]+))?/);
     return (m && m[1]) || 'stable';
@@ -60,9 +61,9 @@ class Permutations extends Map {
 class Config {
     constructor(options) {
         this.options = options;
-        this._base = `${_pjson.name}@${_pjson.version}`;
+        this._base = BASE;
         this.debug = 0;
-        this.plugins = [];
+        this.plugins = new Map();
         this.topicSeparator = ':';
         this.warned = false;
         this.commandPermutations = new Permutations();
@@ -77,24 +78,46 @@ class Config {
         }
         if (typeof opts === 'string')
             opts = { root: opts };
-        if (isConfig(opts))
+        if (isConfig(opts)) {
+            /**
+             * Reload the Config based on the version required by the command.
+             * This is needed because the command is given the Config instantiated
+             * by the root plugin, which may be a different version than the one
+             * required by the command.
+             *
+             * Doing this ensures that the command can freely use any method on Config that
+             * exists in the version of Config required by the command but may not exist on the
+             * root's instance of Config.
+             */
+            if (BASE !== opts._base) {
+                debug(`reloading config from ${opts._base} to ${BASE}`);
+                const config = new Config({ ...opts.options, plugins: opts.plugins });
+                await config.load();
+                return config;
+            }
             return opts;
+        }
         const config = new Config(opts);
         await config.load();
         return config;
     }
+    static get rootPlugin() {
+        return Config._rootPlugin;
+    }
     // eslint-disable-next-line complexity
     async load() {
-        settings_1.settings.performanceEnabled = (settings_1.settings.performanceEnabled === undefined ? this.options.enablePerf : settings_1.settings.performanceEnabled) ?? false;
-        const plugin = new Plugin.Plugin({ root: this.options.root });
-        await plugin.load();
-        this.plugins.push(plugin);
-        this.root = plugin.root;
-        this.pjson = plugin.pjson;
+        settings_1.default.performanceEnabled = (settings_1.default.performanceEnabled === undefined ? this.options.enablePerf : settings_1.default.performanceEnabled) ?? false;
+        this.pluginLoader = new plugin_loader_1.default({ root: this.options.root, plugins: this.options.plugins });
+        Config._rootPlugin = await this.pluginLoader.loadRoot();
+        this.root = Config._rootPlugin.root;
+        this.pjson = Config._rootPlugin.pjson;
+        this.plugins.set(Config._rootPlugin.name, Config._rootPlugin);
+        this.root = Config._rootPlugin.root;
+        this.pjson = Config._rootPlugin.pjson;
         this.name = this.pjson.name;
         this.version = this.options.version || this.pjson.version || '0.0.0';
         this.channel = this.options.channel || channelFromVersion(this.version);
-        this.valid = plugin.valid;
+        this.valid = Config._rootPlugin.valid;
         this.arch = (os.arch() === 'ia32' ? 'x86' : os.arch());
         this.platform = WSL ? 'wsl' : os.platform();
         this.windows = this.platform === 'win32';
@@ -142,70 +165,38 @@ class Config {
                 ...s3.templates && s3.templates.vanilla,
             },
         };
-        const marker = performance_1.Performance.mark('config.load');
+        const marker = performance_1.default.mark('config.load');
         await this.loadPluginsAndCommands();
         debug('config done');
         marker?.addDetails({
-            plugins: this.plugins.length,
+            plugins: this.plugins.size,
             commandPermutations: this.commands.length,
-            commands: this.plugins.reduce((acc, p) => acc + p.commands.length, 0),
+            commands: [...this.plugins.values()].reduce((acc, p) => acc + p.commands.length, 0),
             topics: this.topics.length,
         });
         marker?.stop();
     }
-    async loadPluginsAndCommands() {
-        const marker = performance_1.Performance.mark('config.loadPluginsAndCommands');
-        await this.loadUserPlugins();
-        await this.loadDevPlugins();
-        await this.loadCorePlugins();
-        for (const plugin of this.plugins) {
+    async loadPluginsAndCommands(opts) {
+        const marker = performance_1.default.mark('config.loadPluginsAndCommands');
+        const { plugins, errors } = await this.pluginLoader.loadChildren({
+            devPlugins: this.options.devPlugins,
+            userPlugins: this.options.userPlugins,
+            dataDir: this.dataDir,
+            rootPlugin: Config._rootPlugin,
+            force: opts?.force ?? false,
+        });
+        this.plugins = plugins;
+        for (const plugin of this.plugins.values()) {
             this.loadCommands(plugin);
             this.loadTopics(plugin);
         }
-        marker?.stop();
-    }
-    async loadCorePlugins() {
-        if (this.pjson.oclif.plugins) {
-            await this.loadPlugins(this.root, 'core', this.pjson.oclif.plugins);
-        }
-    }
-    async loadDevPlugins() {
-        if (this.options.devPlugins !== false) {
-            // do not load oclif.devPlugins in production
-            if (this.isProd)
-                return;
-            try {
-                const devPlugins = this.pjson.oclif.devPlugins;
-                if (devPlugins)
-                    await this.loadPlugins(this.root, 'dev', devPlugins);
-            }
-            catch (error) {
-                process.emitWarning(error);
-            }
-        }
-    }
-    async loadUserPlugins() {
-        if (this.options.userPlugins !== false) {
-            try {
-                const userPJSONPath = path.join(this.dataDir, 'package.json');
-                debug('reading user plugins pjson %s', userPJSONPath);
-                const pjson = await (0, util_2.loadJSON)(userPJSONPath);
-                this.userPJSON = pjson;
-                if (!pjson.oclif)
-                    pjson.oclif = { schema: 1 };
-                if (!pjson.oclif.plugins)
-                    pjson.oclif.plugins = [];
-                await this.loadPlugins(userPJSONPath, 'user', pjson.oclif.plugins.filter((p) => p.type === 'user'));
-                await this.loadPlugins(userPJSONPath, 'link', pjson.oclif.plugins.filter((p) => p.type === 'link'));
-            }
-            catch (error) {
-                if (error.code !== 'ENOENT')
-                    process.emitWarning(error);
-            }
+        for (const error of errors) {
+            this.warn(error);
         }
+        marker?.stop();
     }
     async runHook(event, opts, timeout, captureErrors) {
-        const marker = performance_1.Performance.mark(`config.runHook#${event}`);
+        const marker = performance_1.default.mark(`config.runHook#${event}`);
         debug('start %s hook', event);
         const search = (m) => {
             if (typeof m === 'function')
@@ -230,7 +221,7 @@ class Config {
             successes: [],
             failures: [],
         };
-        const promises = this.plugins.map(async (p) => {
+        const promises = [...this.plugins.values()].map(async (p) => {
             const debug = require('debug')([this.bin, p.name, 'hooks', event].join(':'));
             const context = {
                 config: this,
@@ -250,7 +241,7 @@ class Config {
             };
             const hooks = p.hooks[event] || [];
             for (const hook of hooks) {
-                const marker = performance_1.Performance.mark(`config.runHook#${p.name}(${hook})`);
+                const marker = performance_1.default.mark(`config.runHook#${p.name}(${hook})`);
                 try {
                     /* eslint-disable no-await-in-loop */
                     const { isESM, module, filePath } = await module_loader_1.default.loadWithData(p, hook);
@@ -284,7 +275,7 @@ class Config {
         return final;
     }
     async runCommand(id, argv = [], cachedCommand = null) {
-        const marker = performance_1.Performance.mark(`config.runCommand#${id}`);
+        const marker = performance_1.default.mark(`config.runCommand#${id}`);
         debug('runCommand %s %o', id, argv);
         let c = cachedCommand ?? this.findCommand(id);
         if (!c) {
@@ -311,7 +302,7 @@ class Config {
             if (jitResult.failures[0])
                 throw jitResult.failures[0].error;
             if (jitResult.successes[0]) {
-                await this.loadPluginsAndCommands();
+                await this.loadPluginsAndCommands({ force: true });
                 c = this.findCommand(id) ?? c;
             }
             else {
@@ -438,7 +429,7 @@ class Config {
             cliVersion,
             architecture,
             nodeVersion,
-            pluginVersions: Object.fromEntries(this.plugins.map(p => [p.name, { version: p.version, type: p.type, root: p.root }])),
+            pluginVersions: Object.fromEntries([...this.plugins.values()].map(p => [p.name, { version: p.version, type: p.type, root: p.root }])),
             osVersion: `${os.type()} ${os.release()}`,
             shell: this.shell,
             rootPath: this.root,
@@ -460,6 +451,9 @@ class Config {
         url.pathname = path.join(url.pathname, key);
         return url.toString();
     }
+    getPluginsList() {
+        return [...this.plugins.values()];
+    }
     dir(category) {
         const base = process.env[`XDG_${category.toUpperCase()}_HOME`] ||
             (this.windows && process.env.LOCALAPPDATA) ||
@@ -504,52 +498,6 @@ class Config {
         catch { }
         return 0;
     }
-    async loadPlugins(root, type, plugins, parent) {
-        if (!plugins || plugins.length === 0)
-            return;
-        const mark = performance_1.Performance.mark(`config.loadPlugins#${type}`);
-        debug('loading plugins', plugins);
-        await Promise.all((plugins || []).map(async (plugin) => {
-            try {
-                const opts = { type, root };
-                if (typeof plugin === 'string') {
-                    opts.name = plugin;
-                }
-                else {
-                    opts.name = plugin.name || opts.name;
-                    opts.tag = plugin.tag || opts.tag;
-                    opts.root = plugin.root || opts.root;
-                }
-                const pluginMarker = performance_1.Performance.mark(`plugin.load#${opts.name}`);
-                const instance = new Plugin.Plugin(opts);
-                await instance.load();
-                pluginMarker?.addDetails({
-                    hasManifest: instance.hasManifest,
-                    commandCount: instance.commands.length,
-                    topicCount: instance.topics.length,
-                    type: instance.type,
-                    usesMain: Boolean(instance.pjson.main),
-                    name: instance.name,
-                });
-                pluginMarker?.stop();
-                if (this.plugins.find(p => p.name === instance.name))
-                    return;
-                this.plugins.push(instance);
-                if (parent) {
-                    instance.parent = parent;
-                    if (!parent.children)
-                        parent.children = [];
-                    parent.children.push(instance);
-                }
-                await this.loadPlugins(instance.root, type, instance.pjson.oclif.plugins || [], instance);
-            }
-            catch (error) {
-                this.warn(error, 'loadPlugins');
-            }
-        }));
-        mark?.addDetails({ pluginCount: plugins.length });
-        mark?.stop();
-    }
     warn(err, scope) {
         if (this.warned)
             return;
@@ -588,7 +536,8 @@ class Config {
         return (0, util_3.isProd)();
     }
     isJitPluginCommand(c) {
-        return Object.keys(this.pjson.oclif.jitPlugins ?? {}).includes(c.pluginName ?? '') && !this.plugins.find(p => p.name === c?.pluginName);
+        // Return true if the command's plugin is listed under oclif.jitPlugins AND if the plugin hasn't been loaded to this.plugins
+        return Object.keys(this.pjson.oclif.jitPlugins ?? {}).includes(c.pluginName ?? '') && Boolean(c?.pluginName && !this.plugins.has(c.pluginName));
     }
     getCmdLookupId(id) {
         if (this._commands.has(id))
@@ -605,8 +554,9 @@ class Config {
         return id;
     }
     loadCommands(plugin) {
-        const marker = performance_1.Performance.mark(`config.loadCommands#${plugin.name}`, { plugin: plugin.name });
+        const marker = performance_1.default.mark(`config.loadCommands#${plugin.name}`, { plugin: plugin.name });
         for (const command of plugin.commands) {
+            // set canonical command id
             if (this._commands.has(command.id)) {
                 const prioritizedCommand = this.determinePriority([this._commands.get(command.id), command]);
                 this._commands.set(prioritizedCommand.id, prioritizedCommand);
@@ -614,10 +564,11 @@ class Config {
             else {
                 this._commands.set(command.id, command);
             }
-            const permutations = this.flexibleTaxonomy ? (0, util_2.getCommandIdPermutations)(command.id) : [command.id];
-            for (const permutation of permutations) {
+            // set every permutation
+            for (const permutation of command.permutations ?? [command.id]) {
                 this.commandPermutations.add(permutation, command.id);
             }
+            // set command aliases
             for (const alias of command.aliases ?? []) {
                 if (this._commands.has(alias)) {
                     const prioritizedCommand = this.determinePriority([this._commands.get(alias), command]);
@@ -626,8 +577,8 @@ class Config {
                 else {
                     this._commands.set(alias, { ...command, id: alias });
                 }
-                const aliasPermutations = this.flexibleTaxonomy ? (0, util_2.getCommandIdPermutations)(alias) : [alias];
-                for (const permutation of aliasPermutations) {
+                // set every permutation of the aliases
+                for (const permutation of command.aliasPermutations ?? [alias]) {
                     this.commandPermutations.add(permutation, command.id);
                 }
             }
@@ -636,7 +587,7 @@ class Config {
         marker?.stop();
     }
     loadTopics(plugin) {
-        const marker = performance_1.Performance.mark(`config.loadTopics#${plugin.name}`, { plugin: plugin.name });
+        const marker = performance_1.default.mark(`config.loadTopics#${plugin.name}`, { plugin: plugin.name });
         for (const topic of (0, util_2.compact)(plugin.topics)) {
             const existing = this._topics.get(topic.name);
             if (existing) {
@@ -727,23 +678,20 @@ class Config {
       */
     insertLegacyPlugins(plugins) {
         for (const plugin of plugins) {
-            const idx = this.plugins.findIndex(p => p.name === plugin.name);
-            if (idx !== -1) {
-                // invalid plugin instance found in `this.plugins`
-                // replace with the oclif-compatible one
-                this.plugins.splice(idx, 1, plugin);
-            }
+            this.plugins.set(plugin.name, plugin);
             this.loadCommands(plugin);
         }
     }
 }
 exports.Config = Config;
 // when no manifest exists, the default is calculated.  This may throw, so we need to catch it
-const defaultFlagToCached = async (flag, isWritingManifest = false) => {
-    // Prefer the helpDefaultValue function (returns a friendly string for complex types)
+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: {} }, isWritingManifest);
+            return await flag.defaultHelp({ options: flag, flags: {} });
         }
         catch {
             return;
@@ -752,7 +700,7 @@ const defaultFlagToCached = async (flag, isWritingManifest = false) => {
     // if not specified, try the default function
     if (typeof flag.default === 'function') {
         try {
-            return await flag.default({ options: flag, flags: {} }, isWritingManifest);
+            return await flag.default({ options: flag, flags: {} });
         }
         catch { }
     }
@@ -760,11 +708,13 @@ const defaultFlagToCached = async (flag, isWritingManifest = false) => {
         return flag.default;
     }
 };
-const defaultArgToCached = async (arg, isWritingManifest = false) => {
-    // Prefer the helpDefaultValue function (returns a friendly string for complex types)
+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: {} }, isWritingManifest);
+            return await arg.defaultHelp({ options: arg, flags: {} });
         }
         catch {
             return;
@@ -773,7 +723,7 @@ const defaultArgToCached = async (arg, isWritingManifest = false) => {
     // if not specified, try the default function
     if (typeof arg.default === 'function') {
         try {
-            return await arg.default({ options: arg, flags: {} }, isWritingManifest);
+            return await arg.default({ options: arg, flags: {} });
         }
         catch { }
     }
@@ -781,7 +731,7 @@ const defaultArgToCached = async (arg, isWritingManifest = false) => {
         return arg.default;
     }
 };
-async function toCached(c, plugin, isWritingManifest) {
+async function toCached(c, plugin, respectNoCacheDefault = false) {
     const flags = {};
     for (const [name, flag] of Object.entries(c.flags || {})) {
         if (flag.type === 'boolean') {
@@ -803,6 +753,7 @@ async function toCached(c, plugin, isWritingManifest) {
                 deprecateAliases: c.deprecateAliases,
                 aliases: flag.aliases,
                 delimiter: flag.delimiter,
+                noCacheDefault: flag.noCacheDefault,
             };
         }
         else {
@@ -822,11 +773,12 @@ async function toCached(c, plugin, isWritingManifest) {
                 dependsOn: flag.dependsOn,
                 relationships: flag.relationships,
                 exclusive: flag.exclusive,
-                default: await defaultFlagToCached(flag, isWritingManifest),
+                default: await defaultFlagToCached(flag, respectNoCacheDefault),
                 deprecated: flag.deprecated,
                 deprecateAliases: c.deprecateAliases,
                 aliases: flag.aliases,
                 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') {
@@ -841,8 +793,9 @@ async function toCached(c, plugin, isWritingManifest) {
             description: arg.description,
             required: arg.required,
             options: arg.options,
-            default: await defaultArgToCached(arg, isWritingManifest),
+            default: await defaultArgToCached(arg, respectNoCacheDefault),
             hidden: arg.hidden,
+            noCacheDefault: arg.noCacheDefault,
         };
     }
     const stdProperties = {

package/lib/config/index.d.ts

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

package/lib/config/index.js

@@ -3,7 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.tsPath = exports.Plugin = exports.toCached = exports.Config = void 0;
 var config_1 = require("./config");
 Object.defineProperty(exports, "Config", { enumerable: true, get: function () { return config_1.Config; } });
-Object.defineProperty(exports, "toCached", { enumerable: true, get: function () { return config_1.toCached; } });
+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.d.ts

@@ -0,0 +1,30 @@
+import { Plugin as IPlugin } from '../interfaces/plugin';
+type PluginLoaderOptions = {
+    root: string;
+    plugins?: IPlugin[] | PluginsMap;
+};
+type LoadOpts = {
+    devPlugins?: boolean;
+    userPlugins?: boolean;
+    dataDir: string;
+    rootPlugin: IPlugin;
+    force?: boolean;
+};
+type PluginsMap = Map<string, IPlugin>;
+export default class PluginLoader {
+    options: PluginLoaderOptions;
+    plugins: PluginsMap;
+    errors: (string | Error)[];
+    private pluginsProvided;
+    constructor(options: PluginLoaderOptions);
+    loadRoot(): Promise<IPlugin>;
+    loadChildren(opts: LoadOpts): Promise<{
+        plugins: PluginsMap;
+        errors: (string | Error)[];
+    }>;
+    private loadCorePlugins;
+    private loadDevPlugins;
+    private loadUserPlugins;
+    private loadPlugins;
+}
+export {};