@oclif/core 2.0.1 → 2.0.2-beta.10

package/lib/command.js

@@ -1,14 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Command = void 0;
 const url_1 = require("url");
+const chalk = require("chalk");
 const util_1 = require("util");
-const index_1 = require("./index");
+const ux = require("./cli-ux");
 const config_1 = require("./config");
 const Errors = require("./errors");
 const Parser = require("./parser");
-const Flags = require("./flags");
 const util_2 = require("./help/util");
-const pjson = require('../package.json');
+const flags_1 = require("./flags");
+const util_3 = require("./util");
+const pjson = (0, util_3.requireJson)(__dirname, '..', 'package.json');
 /**
  * swallows stdout epipe errors
  * this occurs when stdout closes such as when piping to head
@@ -19,7 +22,7 @@ process.stdout.on('error', (err) => {
     throw err;
 });
 const jsonFlag = {
-    json: Flags.boolean({
+    json: (0, flags_1.boolean)({
         description: 'Format output as json.',
         helpGroup: 'GLOBAL',
     }),
@@ -35,26 +38,50 @@ class Command {
     static set enableJsonFlag(value) {
         this._enableJsonFlag = value;
         if (value === true) {
-            this.globalFlags = jsonFlag;
+            this.baseFlags = jsonFlag;
         }
         else {
-            delete this.globalFlags?.json;
+            delete this.baseFlags?.json;
             this.flags = {}; // force the flags setter to run
             delete this.flags?.json;
         }
     }
-    static get globalFlags() {
-        return this._globalFlags;
-    }
-    static set globalFlags(flags) {
-        this._globalFlags = Object.assign({}, this.globalFlags, flags);
+    /**
+     * instantiate and run the command
+     *
+     * @param {Command.Class} this - the command class
+     * @param {string[]} argv argv
+     * @param {LoadOptions} opts options
+     * @returns {Promise<unknown>} result
+     */
+    static async run(argv, opts) {
+        if (!argv)
+            argv = process.argv.slice(2);
+        // Handle the case when a file URL string is passed in such as 'import.meta.url'; covert to file path.
+        if (typeof opts === 'string' && opts.startsWith('file://')) {
+            opts = (0, url_1.fileURLToPath)(opts);
+        }
+        const config = await config_1.Config.load(opts || require.main?.filename || __dirname);
+        const cmd = new this(argv, config);
+        if (!cmd.id) {
+            const id = cmd.constructor.name.toLowerCase();
+            cmd.id = id;
+            cmd.ctor.id = id;
+        }
+        return cmd._run();
+    }
+    static get baseFlags() {
+        return this._baseFlags;
+    }
+    static set baseFlags(flags) {
+        this._baseFlags = Object.assign({}, this.baseFlags, flags);
         this.flags = {}; // force the flags setter to run
     }
     static get flags() {
         return this._flags;
     }
     static set flags(flags) {
-        this._flags = Object.assign({}, this._flags ?? {}, this.globalFlags, flags);
+        this._flags = Object.assign({}, this._flags ?? {}, this.baseFlags, flags);
     }
     constructor(argv, config) {
         this.argv = argv;
@@ -87,7 +114,7 @@ class Command {
             await this.finally(err);
         }
         if (result && this.jsonEnabled()) {
-            index_1.CliUx.ux.styledJSON(this.toSuccessJson(result));
+            ux.styledJSON(this.toSuccessJson(result));
         }
         return result;
     }
@@ -137,7 +164,7 @@ class Command {
             const deprecateAliases = this.ctor.flags[flag]?.deprecateAliases;
             const aliases = (this.ctor.flags[flag]?.aliases ?? []).map(a => a.length === 1 ? `-${a}` : `--${a}`);
             if (deprecateAliases && aliases.length > 0) {
-                const foundAliases = this.argv.filter(a => aliases.includes(a));
+                const foundAliases = aliases.filter(alias => this.argv.some(a => a.startsWith(alias)));
                 for (const alias of foundAliases) {
                     this.warn((0, util_2.formatFlagDeprecationWarning)(alias, { to: this.ctor.flags[flag]?.name }));
                 }
@@ -147,18 +174,18 @@ class Command {
     warnIfCommandDeprecated() {
         const [id] = (0, util_2.normalizeArgv)(this.config);
         if (this.ctor.deprecateAliases && this.ctor.aliases.includes(id)) {
-            const cmdName = (0, index_1.toConfiguredId)(this.ctor.id, this.config);
-            const aliasName = (0, index_1.toConfiguredId)(id, this.config);
+            const cmdName = (0, util_2.toConfiguredId)(this.ctor.id, this.config);
+            const aliasName = (0, util_2.toConfiguredId)(id, this.config);
             this.warn((0, util_2.formatCommandDeprecationWarning)(aliasName, { to: cmdName }));
         }
         if (this.ctor.state === 'deprecated') {
-            const cmdName = (0, index_1.toConfiguredId)(this.ctor.id, this.config);
+            const cmdName = (0, util_2.toConfiguredId)(this.ctor.id, this.config);
             this.warn((0, util_2.formatCommandDeprecationWarning)(cmdName, this.ctor.deprecationOptions));
         }
     }
     async parse(options, argv = this.argv) {
         if (!options)
-            options = this.constructor;
+            options = this.ctor;
         const opts = { context: this, ...options };
         // the spread operator doesn't work with getters so we have to manually add it here
         opts.flags = options?.flags;
@@ -170,14 +197,13 @@ class Command {
     async catch(err) {
         process.exitCode = process.exitCode ?? err.exitCode ?? 1;
         if (this.jsonEnabled()) {
-            index_1.CliUx.ux.styledJSON(this.toErrorJson(err));
+            ux.styledJSON(this.toErrorJson(err));
         }
         else {
             if (!err.message)
                 throw err;
             try {
-                const chalk = require('chalk');
-                index_1.CliUx.ux.action.stop(chalk.bold.red('!'));
+                ux.action.stop(chalk.bold.red('!'));
             }
             catch { }
             throw err;
@@ -200,31 +226,13 @@ class Command {
         return { error: err };
     }
 }
-exports.default = Command;
+exports.Command = Command;
 Command._base = `${pjson.name}@${pjson.version}`;
 /** An array of aliases for this command. */
 Command.aliases = [];
 /** When set to false, allows a variable amount of arguments */
 Command.strict = true;
-Command.parse = true;
-Command.parserOptions = {};
+/** An order-dependent object of arguments for the command */
+Command.args = {};
+Command.hasDynamicHelp = false;
 Command._enableJsonFlag = false;
-// eslint-disable-next-line valid-jsdoc
-/**
- * instantiate and run the command
- * @param {Interfaces.Command.Class} this Class
- * @param {string[]} argv argv
- * @param {Interfaces.LoadOptions} opts options
- */
-Command.run = async function (argv, opts) {
-    if (!argv)
-        argv = process.argv.slice(2);
-    // Handle the case when a file URL string is passed in such as 'import.meta.url'; covert to file path.
-    if (typeof opts === 'string' && opts.startsWith('file://')) {
-        opts = (0, url_1.fileURLToPath)(opts);
-    }
-    // to-do: update in node-14 to module.main
-    const config = await config_1.Config.load(opts || (module.parent && module.parent.parent && module.parent.parent.filename) || __dirname);
-    const cmd = new this(argv, config);
-    return cmd._run(argv);
-};

package/lib/config/config.d.ts

@@ -1,35 +1,36 @@
 import { Options, Plugin as IPlugin } from '../interfaces/plugin';
 import { Config as IConfig, ArchTypes, PlatformTypes, LoadOptions } from '../interfaces/config';
-import { Command, Hook, Hooks, PJSON, Topic } from '../interfaces';
+import { Hook, Hooks, PJSON, Topic } from '../interfaces';
 import * as Plugin from './plugin';
+import { Command } from '../command';
 export declare class Config implements IConfig {
     options: Options;
-    _base: string;
-    name: string;
-    version: string;
-    channel: string;
-    root: string;
+    private _base;
     arch: ArchTypes;
     bin: string;
+    binPath?: string;
     cacheDir: string;
+    channel: string;
     configDir: string;
     dataDir: string;
+    debug: number;
     dirname: string;
     errlog: string;
+    flexibleTaxonomy: boolean;
     home: string;
+    name: string;
+    npmRegistry?: string;
+    pjson: PJSON.CLI;
     platform: PlatformTypes;
+    plugins: IPlugin[];
+    root: string;
     shell: string;
-    windows: boolean;
+    topicSeparator: ':' | ' ';
     userAgent: string;
-    debug: number;
-    npmRegistry?: string;
-    pjson: PJSON.CLI;
     userPJSON?: PJSON.User;
-    plugins: IPlugin[];
-    binPath?: string;
     valid: boolean;
-    topicSeparator: ':' | ' ';
-    flexibleTaxonomy: boolean;
+    version: string;
+    windows: boolean;
     protected warned: boolean;
     private commandPermutations;
     private topicPermutations;
@@ -37,13 +38,14 @@ export declare class Config implements IConfig {
     private _topics;
     private _commandIDs;
     constructor(options: Options);
-    static load(opts?: LoadOptions): Promise<IConfig | Config>;
+    static load(opts?: LoadOptions): Promise<Config>;
     load(): Promise<void>;
+    loadPluginsAndCommands(): Promise<void>;
     loadCorePlugins(): Promise<void>;
     loadDevPlugins(): Promise<void>;
     loadUserPlugins(): Promise<void>;
     runHook<T extends keyof Hooks>(event: T, opts: Hooks[T]['options'], timeout?: number): Promise<Hook.Result<Hooks[T]['return']>>;
-    runCommand<T = unknown>(id: string, argv?: string[], cachedCommand?: Command.Loadable): Promise<T>;
+    runCommand<T = unknown>(id: string, argv?: string[], cachedCommand?: Command.Loadable | null): Promise<T>;
     scopedEnvVar(k: string): string | undefined;
     scopedEnvVarTrue(k: string): boolean;
     scopedEnvVarKey(k: string): string;
@@ -105,6 +107,7 @@ export declare class Config implements IConfig {
         detail: string;
     }, scope?: string): void;
     protected get isProd(): boolean;
+    private isJitPluginCommand;
     private getCmdLookupId;
     private getTopicLookupId;
     private loadCommands;
@@ -130,4 +133,4 @@ export declare class Config implements IConfig {
      */
     private determinePriority;
 }
-export declare function toCached(c: Command.Class, plugin?: IPlugin): Promise<Command>;
+export declare function toCached(c: Command.Class, plugin?: IPlugin): Promise<Command.Cached>;

package/lib/config/config.js

@@ -14,7 +14,7 @@ const module_loader_1 = require("../module-loader");
 const util_4 = require("../help/util");
 // eslint-disable-next-line new-cap
 const debug = (0, util_2.Debug)();
-const _pjson = require('../../package.json');
+const _pjson = (0, util_3.requireJson)(__dirname, '..', '..', 'package.json');
 function channelFromVersion(version) {
     const m = version.match(/[^-]+(?:-([^.]+))?/);
     return (m && m[1]) || 'stable';
@@ -53,7 +53,6 @@ class Permutations extends Map {
     }
 }
 class Config {
-    // eslint-disable-next-line no-useless-constructor
     constructor(options) {
         this.options = options;
         this._base = `${_pjson.name}@${_pjson.version}`;
@@ -66,7 +65,7 @@ class Config {
         this._commands = new Map();
         this._topics = new Map();
     }
-    static async load(opts = (module.parent && module.parent.parent && module.parent.parent.filename) || __dirname) {
+    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.
         if (typeof opts === 'string' && opts.startsWith('file://')) {
             opts = (0, url_1.fileURLToPath)(opts);
@@ -135,6 +134,10 @@ class Config {
                 ...s3.templates && s3.templates.vanilla,
             },
         };
+        await this.loadPluginsAndCommands();
+        debug('config done');
+    }
+    async loadPluginsAndCommands() {
         await this.loadUserPlugins();
         await this.loadDevPlugins();
         await this.loadCorePlugins();
@@ -142,7 +145,6 @@ class Config {
             this.loadCommands(plugin);
             this.loadTopics(plugin);
         }
-        debug('config done');
     }
     async loadCorePlugins() {
         if (this.pjson.oclif.plugins) {
@@ -249,28 +251,50 @@ class Config {
         debug('%s hook done', event);
         return final;
     }
-    // eslint-disable-next-line default-param-last
-    async runCommand(id, argv = [], cachedCommand) {
+    async runCommand(id, argv = [], cachedCommand = null) {
         debug('runCommand %s %o', id, argv);
-        const c = cachedCommand || this.findCommand(id);
+        let c = cachedCommand ?? this.findCommand(id);
         if (!c) {
             const matches = this.flexibleTaxonomy ? this.findMatches(id, argv) : [];
             const hookResult = this.flexibleTaxonomy && matches.length > 0 ?
                 await this.runHook('command_incomplete', { id, argv, matches }) :
                 await this.runHook('command_not_found', { id, argv });
-            if (hookResult.successes[0]) {
-                const cmdResult = hookResult.successes[0].result;
-                return cmdResult;
-            }
-            if (hookResult.failures[0]) {
+            if (hookResult.successes[0])
+                return hookResult.successes[0].result;
+            if (hookResult.failures[0])
                 throw hookResult.failures[0].error;
-            }
             throw new errors_1.CLIError(`command ${id} not found`);
         }
+        if (this.isJitPluginCommand(c)) {
+            const pluginName = c.pluginName;
+            const pluginVersion = this.pjson.oclif.jitPlugins[pluginName];
+            const jitResult = await this.runHook('jit_plugin_not_installed', {
+                id,
+                argv,
+                command: c,
+                pluginName,
+                pluginVersion,
+            });
+            if (jitResult.failures[0])
+                throw jitResult.failures[0].error;
+            if (jitResult.successes[0]) {
+                await this.loadPluginsAndCommands();
+                c = this.findCommand(id) ?? c;
+            }
+            else {
+                // this means that no jit_plugin_not_installed hook exists, so we should run the default behavior
+                const result = await this.runHook('command_not_found', { id, argv });
+                if (result.successes[0])
+                    return result.successes[0].result;
+                if (result.failures[0])
+                    throw result.failures[0].error;
+                throw new errors_1.CLIError(`command ${id} not found`);
+            }
+        }
         const command = await c.load();
         await this.runHook('prerun', { Command: command, argv });
         const result = (await command.run(argv, this));
-        await this.runHook('postrun', { Command: command, result: result, argv });
+        await this.runHook('postrun', { Command: command, result, argv });
         return result;
     }
     scopedEnvVar(k) {
@@ -489,6 +513,9 @@ class Config {
     get isProd() {
         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);
+    }
     getCmdLookupId(id) {
         if (this._commands.has(id))
             return id;
@@ -597,6 +624,14 @@ class Config {
             if (a.pluginType === 'core' && b.pluginType !== 'core') {
                 return -1;
             }
+            // if a is a jit plugin and b is not sort b first
+            if (a.pluginType === 'jit' && b.pluginType !== 'jit') {
+                return 1;
+            }
+            // if b is a jit plugin and a is not sort a first
+            if (b.pluginType === 'jit' && a.pluginType !== 'jit') {
+                return -1;
+            }
             // neither plugin is core, so do not change the order
             return 0;
         });
@@ -605,7 +640,7 @@ class Config {
 }
 exports.Config = Config;
 // when no manifest exists, the default is calculated.  This may throw, so we need to catch it
-const defaultToCached = async (flag) => {
+const defaultFlagToCached = async (flag) => {
     // Prefer the helpDefaultValue function (returns a friendly string for complex types)
     if (typeof flag.defaultHelp === 'function') {
         try {
@@ -626,6 +661,27 @@ const defaultToCached = async (flag) => {
         return flag.default;
     }
 };
+const defaultArgToCached = async (arg) => {
+    // Prefer the helpDefaultValue function (returns a friendly string for complex types)
+    if (typeof arg.defaultHelp === 'function') {
+        try {
+            return await arg.defaultHelp();
+        }
+        catch {
+            return;
+        }
+    }
+    // if not specified, try the default function
+    if (typeof arg.default === 'function') {
+        try {
+            return await arg.default({ options: {}, flags: {} });
+        }
+        catch { }
+    }
+    else {
+        return arg.default;
+    }
+};
 async function toCached(c, plugin) {
     const flags = {};
     for (const [name, flag] of Object.entries(c.flags || {})) {
@@ -647,6 +703,7 @@ async function toCached(c, plugin) {
                 deprecated: flag.deprecated,
                 deprecateAliases: c.deprecateAliases,
                 aliases: flag.aliases,
+                delimiter: flag.delimiter,
             };
         }
         else {
@@ -666,10 +723,11 @@ async function toCached(c, plugin) {
                 dependsOn: flag.dependsOn,
                 relationships: flag.relationships,
                 exclusive: flag.exclusive,
-                default: await defaultToCached(flag),
+                default: await defaultFlagToCached(flag),
                 deprecated: flag.deprecated,
                 deprecateAliases: c.deprecateAliases,
                 aliases: flag.aliases,
+                delimiter: flag.delimiter,
             };
             // a command-level placeholder in the manifest so that oclif knows it should regenerate the command during help-time
             if (typeof flag.defaultHelp === 'function') {
@@ -677,17 +735,17 @@ async function toCached(c, plugin) {
             }
         }
     }
-    // v2 commands have args as an object, so we need to normalize it to an array for forwards compatibility
-    const normalized = (Array.isArray(c.args) ? c.args ?? [] : Object.values(c.args ?? {}));
-    const argsPromise = normalized.map(async (a) => ({
-        name: a.name,
-        description: a.description,
-        required: a.required,
-        options: a.options,
-        default: typeof a.default === 'function' ? await a.default({}) : a.default,
-        hidden: a.hidden,
-    }));
-    const args = await Promise.all(argsPromise);
+    const args = {};
+    for (const [name, arg] of Object.entries((0, util_3.ensureArgObject)(c.args))) {
+        args[name] = {
+            name,
+            description: arg.description,
+            required: arg.required,
+            options: arg.options,
+            default: await defaultArgToCached(arg),
+            hidden: arg.hidden,
+        };
+    }
     const stdProperties = {
         id: c.id,
         summary: c.summary,
@@ -707,7 +765,7 @@ async function toCached(c, plugin) {
         args,
     };
     // do not include these properties in manifest
-    const ignoreCommandProperties = ['plugin', '_flags', '_enableJsonFlag', '_globalFlags'];
+    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 = {};

package/lib/config/index.js

@@ -1,11 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tsPath = exports.Plugin = exports.toCached = exports.Config = void 0;
-try {
-    // eslint-disable-next-line node/no-missing-require
-    require('fs-extra-debug');
-}
-catch { }
 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; } });

package/lib/config/plugin.d.ts

@@ -1,8 +1,9 @@
+import { CLIError } from '../errors';
 import { Plugin as IPlugin, PluginOptions } from '../interfaces/plugin';
-import { Command } from '../interfaces/command';
 import { Manifest } from '../interfaces/manifest';
 import { PJSON } from '../interfaces/pjson';
 import { Topic } from '../interfaces/topic';
+import { Command } from '../command';
 export declare class Plugin implements IPlugin {
     options: PluginOptions;
     _base: string;
@@ -36,6 +37,6 @@ export declare class Plugin implements IPlugin {
         must: boolean;
     }): Promise<Command.Class | undefined>;
     protected _manifest(ignoreManifest: boolean, errorOnManifestCreate?: boolean): Promise<Manifest>;
-    protected warn(err: any, scope?: string): void;
+    protected warn(err: string | Error | CLIError, scope?: string): void;
     private addErrorScope;
 }

package/lib/config/plugin.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Plugin = void 0;
 const errors_1 = require("../errors");
+const globby = require("globby");
 const path = require("path");
 const util_1 = require("util");
 const config_1 = require("./config");
@@ -10,17 +11,17 @@ const ts_node_1 = require("./ts-node");
 const util_3 = require("./util");
 const util_4 = require("../util");
 const module_loader_1 = require("../module-loader");
-const _pjson = require('../../package.json');
+const _pjson = (0, util_4.requireJson)(__dirname, '..', '..', 'package.json');
 function topicsToArray(input, base) {
     if (!input)
         return [];
     base = base ? `${base}:` : '';
     if (Array.isArray(input)) {
-        return input.concat((0, util_3.flatMap)(input, t => topicsToArray(t.subtopics, `${base}${t.name}`)));
+        return [...input, ...(0, util_3.flatMap)(input, t => topicsToArray(t.subtopics, `${base}${t.name}`))];
     }
     return (0, util_3.flatMap)(Object.keys(input), k => {
         input[k].name = k;
-        return [{ ...input[k], name: `${base}${k}` }].concat(topicsToArray(input[k].subtopics, `${base}${input[k].name}`));
+        return [{ ...input[k], name: `${base}${k}` }, ...topicsToArray(input[k].subtopics, `${base}${input[k].name}`)];
     });
 }
 // essentially just "cd .."
@@ -86,7 +87,6 @@ async function findRoot(name, root) {
     return findSourcesRoot(root);
 }
 class Plugin {
-    // eslint-disable-next-line no-useless-constructor
     constructor(options) {
         this.options = options;
         // static loadedPlugins: {[name: string]: Plugin} = {}
@@ -127,7 +127,12 @@ class Plugin {
         this.manifest = await this._manifest(Boolean(this.options.ignoreManifest), Boolean(this.options.errorOnManifestCreate));
         this.commands = Object
             .entries(this.manifest.commands)
-            .map(([id, c]) => ({ ...c, pluginAlias: this.alias, pluginType: this.type, load: async () => this.findCommand(id, { must: true }) }))
+            .map(([id, c]) => ({
+            ...c,
+            pluginAlias: this.alias,
+            pluginType: c.pluginType === 'jit' ? 'jit' : this.type,
+            load: async () => this.findCommand(id, { must: true }),
+        }))
             .sort((a, b) => a.id.localeCompare(b.id));
     }
     get topics() {
@@ -139,15 +144,6 @@ class Plugin {
     get commandIDs() {
         if (!this.commandsDir)
             return [];
-        let globby;
-        try {
-            const globbyPath = require.resolve('globby', { paths: [this.root, __dirname] });
-            globby = require(globbyPath);
-        }
-        catch (error) {
-            this.warn(error, 'not loading commands, globby not found');
-            return [];
-        }
         this._debug(`loading IDs from ${this.commandsDir}`);
         const patterns = [
             '**/*.+(js|cjs|mjs|ts|tsx)',

package/lib/config/util.js

@@ -4,7 +4,7 @@ exports.collectUsableIds = exports.getCommandIdPermutations = exports.getPermuta
 const fs = require("fs");
 const debug = require('debug');
 function flatMap(arr, fn) {
-    return arr.reduce((arr, i) => arr.concat(fn(i)), []);
+    return arr.reduce((arr, i) => [...arr, ...fn(i)], []);
 }
 exports.flatMap = flatMap;
 function mapValues(obj, fn) {
@@ -81,7 +81,7 @@ function getPermutations(arr) {
         for (let j = 0, len2 = partial.length; j <= len2; j++) {
             const start = partial.slice(0, j);
             const end = partial.slice(j);
-            const merged = start.concat(first, end);
+            const merged = [...start, first, ...end];
             output.push(merged);
         }
     }

package/lib/errors/index.js

@@ -1,5 +1,4 @@
 "use strict";
-// tslint:disable no-console
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.warn = exports.error = exports.exit = exports.config = exports.Logger = exports.CLIError = exports.ModuleLoadError = exports.ExitError = exports.handle = void 0;
 var handle_1 = require("./handle");

package/lib/errors/logger.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Logger = void 0;
+const fs = require("fs-extra");
 const path = require("path");
+const stripAnsi = require("strip-ansi");
 const timestamp = () => new Date().toISOString();
 let timer;
 const wait = (ms) => new Promise(resolve => {
@@ -15,18 +17,15 @@ function chomp(s) {
     return s;
 }
 class Logger {
-    // eslint-disable-next-line no-useless-constructor
     constructor(file) {
         this.file = file;
         this.flushing = Promise.resolve();
         this.buffer = [];
     }
     log(msg) {
-        const stripAnsi = require('strip-ansi');
         msg = stripAnsi(chomp(msg));
         const lines = msg.split('\n').map(l => `${timestamp()} ${l}`.trimEnd());
         this.buffer.push(...lines);
-        // tslint:disable-next-line no-console
         this.flush(50).catch(console.error);
     }
     async flush(waitForMs = 0) {
@@ -36,7 +35,6 @@ class Logger {
                 return;
             const mylines = this.buffer;
             this.buffer = [];
-            const fs = require('fs-extra');
             await fs.mkdirp(path.dirname(this.file));
             await fs.appendFile(this.file, mylines.join('\n') + '\n');
         });