@oclif/core 0.5.32 → 0.5.36

package/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [0.5.36](https://github.com/oclif/core/compare/v0.5.35...v0.5.36) (2021-09-14)
+
+
+### Bug Fixes
+
+* move ctor for command help class to its own function ([#244](https://github.com/oclif/core/issues/244)) ([26f2445](https://github.com/oclif/core/commit/26f24457c71276c38f86821c2b1498ecb8e4e2a4))
+
+### [0.5.35](https://github.com/oclif/core/compare/v0.5.34...v0.5.35) (2021-09-08)
+
+
+### Bug Fixes
+
+* clear hook timeout ([#243](https://github.com/oclif/core/issues/243)) ([0c32c65](https://github.com/oclif/core/commit/0c32c65c5c30b02bc3ea6e36b0598adfc5b23ec1))
+
+### [0.5.34](https://github.com/oclif/core/compare/v0.5.33...v0.5.34) (2021-08-30)
+
+
+### Bug Fixes
+
+* add support all properties for a command class in manifest ([deb0765](https://github.com/oclif/core/commit/deb0765f81dbea54c831beba0b608b1a8cd0ecdb))
+
+### [0.5.33](https://github.com/oclif/core/compare/v0.5.32...v0.5.33) (2021-08-30)
+
+
+### Bug Fixes
+
+* improve Hooks interface ([#234](https://github.com/oclif/core/issues/234)) ([32d0d62](https://github.com/oclif/core/commit/32d0d62ed30c65cdbca7c6da630b5542b38ab3b1))
+
 ### [0.5.32](https://github.com/oclif/core/compare/v0.5.31...v0.5.32) (2021-08-23)
 
 

package/lib/config/config.d.ts

@@ -1,6 +1,6 @@
 import { Options, Plugin as IPlugin } from '../interfaces/plugin';
 import { Config as IConfig, ArchTypes, PlatformTypes, LoadOptions } from '../interfaces/config';
-import { Command, PJSON, Topic } from '../interfaces';
+import { Command, Hook, Hooks, PJSON, Topic } from '../interfaces';
 import * as Plugin from './plugin';
 export declare class Config implements IConfig {
     options: Options;
@@ -39,7 +39,7 @@ export declare class Config implements IConfig {
     loadCorePlugins(): Promise<void>;
     loadDevPlugins(): Promise<void>;
     loadUserPlugins(): Promise<void>;
-    runHook<T>(event: string, opts: T): Promise<any>;
+    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.Plugin): Promise<T>;
     scopedEnvVar(k: string): string | undefined;
     scopedEnvVarTrue(k: string): boolean;

package/lib/config/config.js

@@ -127,7 +127,7 @@ class Config {
             }
         }
     }
-    async runHook(event, opts) {
+    async runHook(event, opts, timeout) {
         debug('start %s hook', event);
         const search = (m) => {
             if (typeof m === 'function')
@@ -136,7 +136,20 @@ class Config {
                 return m.default;
             return Object.values(m).find((m) => typeof m === 'function');
         };
-        const results = [];
+        const withTimeout = async (ms, promise) => {
+            let id;
+            const timeout = new Promise((_, reject) => {
+                id = setTimeout(() => {
+                    reject(new Error(`Timed out after ${ms} ms.`));
+                }, ms);
+            });
+            return Promise.race([promise, timeout]).then(result => {
+                clearTimeout(id);
+                return result;
+            });
+        };
+        const successes = [];
+        const failures = [];
         for (const p of this.plugins) {
             const debug = require('debug')([this.bin, p.name, 'hooks', event].join(':'));
             const context = {
@@ -161,11 +174,14 @@ class Config {
                     /* eslint-disable no-await-in-loop */
                     const { isESM, module, filePath } = await module_loader_1.default.loadWithData(p, hook);
                     debug('start', isESM ? '(import)' : '(require)', filePath);
-                    const result = await search(module).call(context, Object.assign(Object.assign({}, opts), { config: this }));
-                    results.push(result);
+                    const result = timeout ?
+                        await withTimeout(timeout, search(module).call(context, Object.assign(Object.assign({}, opts), { config: this }))) :
+                        await search(module).call(context, Object.assign(Object.assign({}, opts), { config: this }));
+                    successes.push({ plugin: p, result });
                     debug('done');
                 }
                 catch (error) {
+                    failures.push({ plugin: p, error: error });
                     if (error && error.oclif && error.oclif.exit !== undefined)
                         throw error;
                     this.warn(error, `runHook ${event}`);
@@ -173,7 +189,7 @@ class Config {
             }
         }
         debug('%s hook done', event);
-        return results;
+        return { successes, failures };
     }
     async runCommand(id, argv = [], cachedCommand) {
         debug('runCommand %s %o', id, argv);
@@ -485,7 +501,7 @@ async function toCached(c, plugin) {
         hidden: a.hidden,
     }));
     const args = await Promise.all(argsPromise);
-    return {
+    const stdProperties = {
         id: c.id,
         summary: c.summary,
         description: c.description,
@@ -501,5 +517,14 @@ async function toCached(c, plugin) {
         flags,
         args,
     };
+    // do not include these properties in manifest
+    const ignoreCommandProperties = ['plugin', '_flags'];
+    const stdKeys = Object.keys(stdProperties);
+    const keysToAdd = Object.keys(c).filter(property => ![...stdKeys, ...ignoreCommandProperties].includes(property));
+    const additionalProperties = {};
+    keysToAdd.forEach(key => {
+        additionalProperties[key] = c[key];
+    });
+    return Object.assign(Object.assign({}, stdProperties), additionalProperties);
 }
 exports.toCached = toCached;

package/lib/help/command.d.ts

@@ -1,15 +1,6 @@
 import * as Interfaces from '../interfaces';
 import { Example } from '../interfaces/command';
-import { HelpFormatter } from './formatter';
-export declare type HelpSection = {
-    header: string;
-    body: string | [string, string | undefined][] | undefined;
-} | undefined;
-export declare type HelpSectionRenderer = (data: {
-    cmd: Interfaces.Command;
-    flags: Interfaces.Command.Flag[];
-    args: Interfaces.Command.Arg[];
-}, header: string) => HelpSection[] | string | undefined;
+import { HelpFormatter, HelpSectionRenderer } from './formatter';
 export declare class CommandHelp extends HelpFormatter {
     command: Interfaces.Command;
     config: Interfaces.Config;

package/lib/help/formatter.d.ts

@@ -1,4 +1,17 @@
 import * as Interfaces from '../interfaces';
+export declare type HelpSectionKeyValueTable = {
+    name: string;
+    description: string;
+}[];
+export declare type HelpSection = {
+    header: string;
+    body: string | HelpSectionKeyValueTable | [string, string | undefined][] | undefined;
+} | undefined;
+export declare type HelpSectionRenderer = (data: {
+    cmd: Interfaces.Command;
+    flags: Interfaces.Command.Flag[];
+    args: Interfaces.Command.Arg[];
+}, header: string) => HelpSection | HelpSection[] | string | undefined;
 export declare class HelpFormatter {
     indentSpacing: number;
     /**
@@ -78,5 +91,5 @@ export declare class HelpFormatter {
         stripAnsi?: boolean;
         spacer?: string;
     }): string;
-    section(header: string, body: string | [string, string | undefined][]): string;
+    section(header: string, body: string | HelpSection | HelpSectionKeyValueTable | [string, string | undefined][]): string;
 }

package/lib/help/formatter.js

@@ -148,10 +148,31 @@ class HelpFormatter {
     }
     section(header, body) {
         // Always render template strings with the provided render function before wrapping and indenting
-        body = Array.isArray(body) ? body.map(([left, right]) => ([this.render(left), right && this.render(right)])) : this.render(body);
+        let newBody;
+        if (typeof body === 'string') {
+            newBody = this.render(body);
+        }
+        else if (Array.isArray(body)) {
+            newBody = body.map(entry => {
+                if ('name' in entry) {
+                    const tableEntry = entry;
+                    return ([this.render(tableEntry.name), this.render(tableEntry.description)]);
+                }
+                const [left, right] = entry;
+                return ([this.render(left), right && this.render(right)]);
+            });
+        }
+        else if ('header' in body) {
+            return this.section(body.header, body.body);
+        }
+        else {
+            newBody = body
+                .map((entry) => ([entry.name, entry.description]))
+                .map(([left, right]) => ([this.render(left), right && this.render(right)]));
+        }
         const output = [
             bold(header),
-            this.indent(Array.isArray(body) ? this.renderList(body, { stripAnsi: this.opts.stripAnsi, indentation: 2 }) : body),
+            this.indent(Array.isArray(newBody) ? this.renderList(newBody, { stripAnsi: this.opts.stripAnsi, indentation: 2 }) : newBody),
         ].join('\n');
         return this.opts.stripAnsi ? stripAnsi(output) : output;
     }

package/lib/help/index.d.ts

@@ -30,6 +30,7 @@ export declare class Help extends HelpBase {
     protected showTopicHelp(topic: Interfaces.Topic): Promise<void>;
     protected formatRoot(): string;
     protected formatCommand(command: Interfaces.Command): string;
+    protected getCommandHelpClass(command: Interfaces.Command): CommandHelp;
     protected formatCommands(commands: Interfaces.Command[]): string;
     protected summary(c: Interfaces.Command): string | undefined;
     protected description(c: Interfaces.Command): string;

package/lib/help/index.js

@@ -73,6 +73,7 @@ class Help extends HelpBase {
         return topics;
     }
     async showHelp(argv) {
+        argv = argv.filter(arg => !getHelpFlagAdditions(this.config).includes(arg));
         if (this.config.topicSeparator !== ':')
             argv = util_2.standardizeIDFromArgv(argv, this.config);
         const subject = getHelpSubject(argv, this.config);
@@ -172,9 +173,12 @@ class Help extends HelpBase {
             command.id = command.id.replace(/:/g, this.config.topicSeparator);
             command.aliases = command.aliases && command.aliases.map(a => a.replace(/:/g, this.config.topicSeparator));
         }
-        const help = new this.CommandHelpClass(command, this.config, this.opts);
+        const help = this.getCommandHelpClass(command);
         return help.generate();
     }
+    getCommandHelpClass(command) {
+        return new this.CommandHelpClass(command, this.config, this.opts);
+    }
     formatCommands(commands) {
         if (commands.length === 0)
             return '';

package/lib/index.d.ts

@@ -4,10 +4,11 @@ import { Config, Plugin, tsPath, toCached } from './config';
 import * as Interfaces from './interfaces';
 import * as Errors from './errors';
 import * as Flags from './flags';
-import { HelpBase, Help, loadHelpClass } from './help';
+import { CommandHelp, HelpBase, Help, loadHelpClass } from './help';
 import { toStandardizedId, toConfiguredId } from './help/util';
 import * as Parser from './parser';
 import { Hook } from './interfaces/hooks';
 import { settings, Settings } from './settings';
+import { HelpSection, HelpSectionRenderer, HelpSectionKeyValueTable } from './help/formatter';
 declare const flush: any;
-export { Command, Config, Errors, Flags, loadHelpClass, Help, HelpBase, Hook, Interfaces, Parser, Plugin, run, toCached, tsPath, toStandardizedId, toConfiguredId, settings, Settings, flush, };
+export { Command, CommandHelp, Config, Errors, Flags, loadHelpClass, Help, HelpBase, HelpSection, HelpSectionRenderer, HelpSectionKeyValueTable, Hook, Interfaces, Parser, Plugin, run, toCached, tsPath, toStandardizedId, toConfiguredId, settings, Settings, flush, };

package/lib/index.js

@@ -18,6 +18,7 @@ exports.Errors = Errors;
 const Flags = require("./flags");
 exports.Flags = Flags;
 const help_1 = require("./help");
+exports.CommandHelp = help_1.CommandHelp;
 exports.HelpBase = help_1.HelpBase;
 exports.Help = help_1.Help;
 exports.loadHelpClass = help_1.loadHelpClass;

package/lib/interfaces/config.d.ts

@@ -1,5 +1,5 @@
 import { PJSON } from './pjson';
-import { Hooks } from './hooks';
+import { Hooks, Hook } from './hooks';
 import { Command } from './command';
 import { Plugin, Options } from './plugin';
 import { Topic } from './topic';
@@ -92,7 +92,7 @@ export interface Config {
     readonly commandIDs: string[];
     runCommand<T = unknown>(id: string, argv?: string[]): Promise<T>;
     runCommand<T = unknown>(id: string, argv?: string[], cachedCommand?: Command.Plugin): Promise<T>;
-    runHook<T extends Hooks, K extends Extract<keyof T, string>>(event: K, opts: T[K]): Promise<any>;
+    runHook<T extends keyof Hooks>(event: T, opts: Hooks[T]['options'], timeout?: number): Promise<Hook.Result<Hooks[T]['return']>>;
     findCommand(id: string, opts: {
         must: true;
     }): Command.Plugin;

package/lib/interfaces/hooks.d.ts

@@ -1,53 +1,78 @@
 import { Command } from './command';
 import { Config } from './config';
+import { Plugin } from './plugin';
+interface HookMeta {
+    options: Record<string, unknown>;
+    return: any;
+}
 export interface Hooks {
-    [event: string]: object;
+    [event: string]: HookMeta;
     init: {
-        id: string | undefined;
-        argv: string[];
+        options: {
+            id: string | undefined;
+            argv: string[];
+        };
+        return: void;
     };
     prerun: {
-        Command: Command.Class;
-        argv: string[];
+        options: {
+            Command: Command.Class;
+            argv: string[];
+        };
+        return: void;
     };
     postrun: {
-        Command: Command.Class;
-        result?: any;
-        argv: string[];
+        options: {
+            Command: Command.Class;
+            result?: any;
+            argv: string[];
+        };
+        return: void;
     };
     preupdate: {
-        channel: string;
+        options: {
+            channel: string;
+        };
+        return: void;
     };
     update: {
-        channel: string;
+        options: {
+            channel: string;
+        };
+        return: void;
     };
     'command_not_found': {
-        id: string;
-        argv?: string[];
+        options: {
+            id: string;
+            argv?: string[];
+        };
+        return: void;
     };
     'plugins:preinstall': {
-        plugin: {
-            name: string;
-            tag: string;
-            type: 'npm';
-        } | {
-            url: string;
-            type: 'repo';
+        options: {
+            plugin: {
+                name: string;
+                tag: string;
+                type: 'npm';
+            } | {
+                url: string;
+                type: 'repo';
+            };
         };
+        return: void;
     };
 }
-export declare type HookKeyOrOptions<K> = K extends (keyof Hooks) ? Hooks[K] : K;
-export declare type Hook<T> = (this: Hook.Context, options: HookKeyOrOptions<T> & {
+export declare type Hook<T extends keyof P, P extends Hooks = Hooks> = (this: Hook.Context, options: P[T]['options'] & {
     config: Config;
-}) => any;
+}) => Promise<P[T]['return']>;
 export declare namespace Hook {
-    type Init = Hook<Hooks['init']>;
-    type PluginsPreinstall = Hook<Hooks['plugins:preinstall']>;
-    type Prerun = Hook<Hooks['prerun']>;
-    type Postrun = Hook<Hooks['postrun']>;
-    type Preupdate = Hook<Hooks['preupdate']>;
-    type Update = Hook<Hooks['update']>;
-    type CommandNotFound = Hook<Hooks['command_not_found']>;
+    type Init = Hook<'init'>;
+    type PluginsPreinstall = Hook<'plugins:preinstall'>;
+    type Prerun = Hook<'prerun'>;
+    type Postrun = Hook<'postrun'>;
+    type Preupdate = Hook<'preupdate'>;
+    type Update = Hook<'update'>;
+    type CommandNotFound = Hook<'command_not_found'>;
     interface Context {
         config: Config;
         exit(code?: number): void;
@@ -59,4 +84,15 @@ export declare namespace Hook {
         log(message?: any, ...args: any[]): void;
         debug(...args: any[]): void;
     }
+    interface Result<T> {
+        successes: Array<{
+            result: T;
+            plugin: Plugin;
+        }>;
+        failures: Array<{
+            error: Error;
+            plugin: Plugin;
+        }>;
+    }
 }
+export {};

package/lib/interfaces/index.d.ts

@@ -3,7 +3,7 @@ export { Config, ArchTypes, PlatformTypes, LoadOptions } from './config';
 export { Command, Example } from './command';
 export { OclifError, PrettyPrintableError } from './errors';
 export { HelpOptions } from './help';
-export { Hook, HookKeyOrOptions, Hooks } from './hooks';
+export { Hook, Hooks } from './hooks';
 export { Manifest } from './manifest';
 export { ParserArg, Arg, ParseFn, ParserOutput, ParserInput, ArgToken, OptionalArg, FlagOutput, OutputArgs, OutputFlags, FlagUsageOptions, CLIParseErrorOptions, ArgInput, RequiredArg, Metadata, ParsingToken, FlagToken, List, ListItem, BooleanFlag, Flag, FlagBase, OptionFlag, Input, EnumFlagOptions, DefaultContext, Default, Definition, CompletableOptionFlag, Completion, CompletionContext, FlagInput, CompletableFlag, } from './parser';
 export { PJSON } from './pjson';

package/lib/main.js

@@ -49,7 +49,6 @@ async function run(argv = process.argv.slice(2), options) {
     }
     // display help version if applicable
     if (exports.helpAddition(argv, config)) {
-        argv = argv.filter(arg => !help_1.getHelpFlagAdditions(config).includes(arg));
         const Help = await help_1.loadHelpClass(config);
         const help = new Help(config, config.pjson.helpOptions);
         await help.showHelp(argv);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@oclif/core",
   "description": "base library for oclif CLIs",
-  "version": "0.5.32",
+  "version": "0.5.36",
   "author": "Jeff Dickey @jdxcode",
   "bugs": "https://github.com/oclif/core/issues",
   "dependencies": {