@oclif/core 3.0.0-beta.8 → 3.0.0

package/lib/help/formatter.d.ts

@@ -1,20 +1,22 @@
 import { Command } from '../command';
 import * as Interfaces from '../interfaces';
 export type HelpSectionKeyValueTable = {
-    name: string;
     description: string;
+    name: string;
 }[];
 export type HelpSection = {
+    body: [string, string | undefined][] | HelpSectionKeyValueTable | string | undefined;
     header: string;
-    body: string | HelpSectionKeyValueTable | [string, string | undefined][] | undefined;
 } | undefined;
 export type HelpSectionRenderer = (data: {
-    cmd: Command.Class | Command.Loadable | Command.Cached;
-    flags: Command.Flag.Any[];
     args: Command.Arg.Any[];
+    cmd: Command.Cached | Command.Class | Command.Loadable;
+    flags: Command.Flag.Any[];
 }, header: string) => HelpSection | HelpSection[] | string | undefined;
 export declare class HelpFormatter {
+    protected config: Interfaces.Config;
     indentSpacing: number;
+    protected opts: Interfaces.HelpOptions;
     /**
      * Takes a string and replaces `<%= prop =>` with the value of prop, where prop is anything on
      * `config=Interfaces.Config` or `opts=Interface.HelpOptions`.
@@ -25,37 +27,6 @@ export declare class HelpFormatter {
      */
     render: (input: string) => string;
     constructor(config: Interfaces.Config, opts?: Partial<Interfaces.HelpOptions>);
-    protected config: Interfaces.Config;
-    protected opts: Interfaces.HelpOptions;
-    /**
-     * 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.
-     *
-     * A terminal will automatically wrap text, so this method is primarily used for indented
-     * text. For indented text, specify the indentation so it is taken into account during wrapping.
-     *
-     * Here is an example of wrapping with indentation.
-     * ```
-     * <------ terminal window width ------>
-     * <---------- no indentation --------->
-     * This is my text that will be wrapped
-     * once it passes maxWidth.
-     *
-     * <- indent -><------ text space ----->
-     *             This is my text that will
-     *             be wrapped once it passes
-     *             maxWidth.
-     *
-     * <-- indent not taken into account ->
-     *             This is my text that will
-     * be wrapped
-     *             once it passes maxWidth.
-     * ```
-     * @param body the text to wrap
-     * @param spacing the indentation size to subtract from the terminal width
-     * @returns the formatted wrapped text
-     */
-    wrap(body: string, spacing?: number): string;
     /**
      * Indent by `this.indentSpacing`. The text should be wrap based on terminal width before indented.
      *
@@ -89,8 +60,37 @@ export declare class HelpFormatter {
     renderList(input: (string | undefined)[][], opts: {
         indentation: number;
         multiline?: boolean;
-        stripAnsi?: boolean;
         spacer?: string;
+        stripAnsi?: boolean;
     }): string;
-    section(header: string, body: string | HelpSection | HelpSectionKeyValueTable | [string, string | undefined][]): string;
+    section(header: string, body: [string, string | undefined][] | HelpSection | HelpSectionKeyValueTable | string): string;
+    /**
+     * 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.
+     *
+     * A terminal will automatically wrap text, so this method is primarily used for indented
+     * text. For indented text, specify the indentation so it is taken into account during wrapping.
+     *
+     * Here is an example of wrapping with indentation.
+     * ```
+     * <------ terminal window width ------>
+     * <---------- no indentation --------->
+     * This is my text that will be wrapped
+     * once it passes maxWidth.
+     *
+     * <- indent -><------ text space ----->
+     *             This is my text that will
+     *             be wrapped once it passes
+     *             maxWidth.
+     *
+     * <-- indent not taken into account ->
+     *             This is my text that will
+     * be wrapped
+     *             once it passes maxWidth.
+     * ```
+     * @param body the text to wrap
+     * @param spacing the indentation size to subtract from the terminal width
+     * @returns the formatted wrapped text
+     */
+    wrap(body: string, spacing?: number): string;
 }

package/lib/help/formatter.js

@@ -1,52 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HelpFormatter = void 0;
-const Chalk = require("chalk");
-const indent = require("indent-string");
-const stripAnsi = require("strip-ansi");
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const indent_string_1 = tslib_1.__importDefault(require("indent-string"));
+const string_width_1 = tslib_1.__importDefault(require("string-width"));
+const strip_ansi_1 = tslib_1.__importDefault(require("strip-ansi"));
+const widest_line_1 = tslib_1.__importDefault(require("widest-line"));
+const wrap_ansi_1 = tslib_1.__importDefault(require("wrap-ansi"));
 const screen_1 = require("../screen");
 const util_1 = require("./util");
-const width = require('string-width');
-const widestLine = require('widest-line');
-const wrap = require('wrap-ansi');
-const { bold, } = Chalk;
 class HelpFormatter {
-    constructor(config, opts = {}) {
-        this.indentSpacing = 2;
-        this.config = config;
-        this.opts = { maxWidth: screen_1.stdtermwidth, ...opts };
-        this.render = (0, util_1.template)(this);
-    }
+    config;
+    indentSpacing = 2;
+    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.
-     *
-     * A terminal will automatically wrap text, so this method is primarily used for indented
-     * text. For indented text, specify the indentation so it is taken into account during wrapping.
-     *
-     * Here is an example of wrapping with indentation.
-     * ```
-     * <------ terminal window width ------>
-     * <---------- no indentation --------->
-     * This is my text that will be wrapped
-     * once it passes maxWidth.
+     * Takes a string and replaces `<%= prop =>` with the value of prop, where prop is anything on
+     * `config=Interfaces.Config` or `opts=Interface.HelpOptions`.
      *
-     * <- indent -><------ text space ----->
-     *             This is my text that will
-     *             be wrapped once it passes
-     *             maxWidth.
-     *
-     * <-- indent not taken into account ->
-     *             This is my text that will
-     * be wrapped
-     *             once it passes maxWidth.
+     * ```javascript
+     * `<%= config.bin =>` // will resolve to the bin defined in `pjson.oclif`.
      * ```
-     * @param body the text to wrap
-     * @param spacing the indentation size to subtract from the terminal width
-     * @returns the formatted wrapped text
      */
-    wrap(body, spacing = this.indentSpacing) {
-        return wrap(this.render(body), this.opts.maxWidth - spacing, { hard: true });
+    render;
+    constructor(config, opts = {}) {
+        this.config = config;
+        this.opts = { maxWidth: screen_1.stdtermwidth, ...opts };
+        this.render = (0, util_1.template)(this);
     }
     /**
      * Indent by `this.indentSpacing`. The text should be wrap based on terminal width before indented.
@@ -78,7 +58,7 @@ class HelpFormatter {
      * @return the formatted indented text
      */
     indent(body, spacing = this.indentSpacing) {
-        return indent(body, spacing);
+        return (0, indent_string_1.default)(body, spacing);
     }
     renderList(input, opts) {
         if (input.length === 0) {
@@ -91,12 +71,12 @@ class HelpFormatter {
                     continue;
                 if (left) {
                     if (opts.stripAnsi)
-                        left = stripAnsi(left);
+                        left = (0, strip_ansi_1.default)(left);
                     output += this.wrap(left.trim(), opts.indentation);
                 }
                 if (right) {
                     if (opts.stripAnsi)
-                        right = stripAnsi(right);
+                        right = (0, strip_ansi_1.default)(right);
                     output += '\n';
                     output += this.indent(this.wrap(right.trim(), opts.indentation + 2), 4);
                 }
@@ -106,7 +86,7 @@ class HelpFormatter {
         };
         if (opts.multiline)
             return renderMultiline();
-        const maxLength = widestLine(input.map(i => i[0]).join('\n'));
+        const maxLength = (0, widest_line_1.default)(input.map((i) => i[0]).join('\n'));
         let output = '';
         let spacer = opts.spacer || '\n';
         let cur = '';
@@ -118,16 +98,16 @@ class HelpFormatter {
             }
             cur = left || '';
             if (opts.stripAnsi)
-                cur = stripAnsi(cur);
+                cur = (0, strip_ansi_1.default)(cur);
             if (!right) {
                 cur = cur.trim();
                 continue;
             }
             if (opts.stripAnsi)
-                right = stripAnsi(right);
+                right = (0, strip_ansi_1.default)(right);
             right = this.wrap(right.trim(), opts.indentation + maxLength + 2);
-            const [first, ...lines] = right.split('\n').map(s => s.trim());
-            cur += ' '.repeat(maxLength - width(cur) + 2);
+            const [first, ...lines] = right.split('\n').map((s) => s.trim());
+            cur += ' '.repeat(maxLength - (0, string_width_1.default)(cur) + 2);
             cur += first;
             if (lines.length === 0) {
                 continue;
@@ -154,13 +134,13 @@ class HelpFormatter {
             newBody = this.render(body);
         }
         else if (Array.isArray(body)) {
-            newBody = body.map(entry => {
+            newBody = body.map((entry) => {
                 if ('name' in entry) {
                     const tableEntry = entry;
-                    return ([this.render(tableEntry.name), this.render(tableEntry.description)]);
+                    return [this.render(tableEntry.name), this.render(tableEntry.description)];
                 }
                 const [left, right] = entry;
-                return ([this.render(left), right && this.render(right)]);
+                return [this.render(left), right && this.render(right)];
             });
         }
         else if ('header' in body) {
@@ -168,14 +148,45 @@ class HelpFormatter {
         }
         else {
             newBody = body
-                .map((entry) => ([entry.name, entry.description]))
-                .map(([left, right]) => ([this.render(left), right && this.render(right)]));
+                .map((entry) => [entry.name, entry.description])
+                .map(([left, right]) => [this.render(left), right && this.render(right)]);
         }
         const output = [
-            bold(header),
-            this.indent(Array.isArray(newBody) ? this.renderList(newBody, { stripAnsi: this.opts.stripAnsi, indentation: 2 }) : newBody),
+            chalk_1.default.bold(header),
+            this.indent(Array.isArray(newBody) ? this.renderList(newBody, { indentation: 2, stripAnsi: this.opts.stripAnsi }) : newBody),
         ].join('\n');
-        return this.opts.stripAnsi ? stripAnsi(output) : output;
+        return this.opts.stripAnsi ? (0, strip_ansi_1.default)(output) : output;
+    }
+    /**
+     * 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.
+     *
+     * A terminal will automatically wrap text, so this method is primarily used for indented
+     * text. For indented text, specify the indentation so it is taken into account during wrapping.
+     *
+     * Here is an example of wrapping with indentation.
+     * ```
+     * <------ terminal window width ------>
+     * <---------- no indentation --------->
+     * This is my text that will be wrapped
+     * once it passes maxWidth.
+     *
+     * <- indent -><------ text space ----->
+     *             This is my text that will
+     *             be wrapped once it passes
+     *             maxWidth.
+     *
+     * <-- indent not taken into account ->
+     *             This is my text that will
+     * be wrapped
+     *             once it passes maxWidth.
+     * ```
+     * @param body the text to wrap
+     * @param spacing the indentation size to subtract from the terminal width
+     * @returns the formatted wrapped text
+     */
+    wrap(body, spacing = this.indentSpacing) {
+        return (0, wrap_ansi_1.default)(this.render(body), this.opts.maxWidth - spacing, { hard: true });
     }
 }
 exports.HelpFormatter = HelpFormatter;

package/lib/help/index.d.ts

@@ -1,41 +1,45 @@
+import { Command } from '../command';
 import * as Interfaces from '../interfaces';
-import CommandHelp from './command';
+import { CommandHelp } from './command';
 import { HelpFormatter } from './formatter';
-import { Command } from '../command';
 export { CommandHelp } from './command';
-export { standardizeIDFromArgv, loadHelpClass, getHelpFlagAdditions, normalizeArgv } from './util';
+export { getHelpFlagAdditions, normalizeArgv, standardizeIDFromArgv } from './util';
 export declare abstract class HelpBase extends HelpFormatter {
     constructor(config: Interfaces.Config, opts?: Partial<Interfaces.HelpOptions>);
-    /**
-     * Show help, used in multi-command CLIs
-     * @param args passed into your command, useful for determining which type of help to display
-     */
-    abstract showHelp(argv: string[]): Promise<void>;
     /**
      * Show help for an individual command
      * @param command
      * @param topics
      */
     abstract showCommandHelp(command: Command.Class, topics: Interfaces.Topic[]): Promise<void>;
+    /**
+     * Show help, used in multi-command CLIs
+     * @param args passed into your command, useful for determining which type of help to display
+     */
+    abstract showHelp(argv: string[]): Promise<void>;
 }
 export declare class Help extends HelpBase {
     protected CommandHelpClass: typeof CommandHelp;
-    private get _topics();
-    protected get sortedCommands(): Command.Loadable[];
-    protected get sortedTopics(): Interfaces.Topic[];
     constructor(config: Interfaces.Config, opts?: Partial<Interfaces.HelpOptions>);
-    showHelp(argv: string[]): Promise<void>;
-    showCommandHelp(command: Command.Class | Command.Loadable | Command.Cached): Promise<void>;
-    protected showRootHelp(): Promise<void>;
-    protected showTopicHelp(topic: Interfaces.Topic): Promise<void>;
+    private get _topics();
+    protected command(command: Command.Class): string;
+    protected description(c: Command.Cached | Command.Class | Command.Loadable): string;
+    protected formatCommand(command: Command.Cached | Command.Class | Command.Loadable): string;
+    protected formatCommands(commands: Array<Command.Cached | Command.Class | Command.Loadable>): string;
     protected formatRoot(): string;
-    protected formatCommand(command: Command.Class | Command.Loadable | Command.Cached): string;
-    protected getCommandHelpClass(command: Command.Class | Command.Loadable | Command.Cached): CommandHelp;
-    protected formatCommands(commands: Array<Command.Class | Command.Loadable | Command.Cached>): string;
-    protected summary(c: Command.Class | Command.Loadable | Command.Cached): string | undefined;
-    protected description(c: Command.Class | Command.Loadable | Command.Cached): string;
     protected formatTopic(topic: Interfaces.Topic): string;
     protected formatTopics(topics: Interfaces.Topic[]): string;
-    protected command(command: Command.Class): string;
+    protected getCommandHelpClass(command: Command.Cached | Command.Class | Command.Loadable): CommandHelp;
     protected log(...args: string[]): void;
+    showCommandHelp(command: Command.Cached | Command.Class | Command.Loadable): Promise<void>;
+    showHelp(argv: string[]): Promise<void>;
+    protected showRootHelp(): Promise<void>;
+    protected showTopicHelp(topic: Interfaces.Topic): Promise<void>;
+    protected summary(c: Command.Cached | Command.Class | Command.Loadable): string | undefined;
+    protected get sortedCommands(): Command.Loadable[];
+    protected get sortedTopics(): Interfaces.Topic[];
+}
+interface HelpBaseDerived {
+    new (config: Interfaces.Config, opts?: Partial<Interfaces.HelpOptions>): HelpBase;
 }
+export declare function loadHelpClass(config: Interfaces.Config): Promise<HelpBaseDerived>;