@oclif/core 3.0.0-beta.9 → 3.0.0

package/lib/{ux → cli-ux}/styled/object.js

@@ -1,25 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const chalk = require("chalk");
-const util = require("util");
-// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const node_util_1 = require("node:util");
 function styledObject(obj, keys) {
     const output = [];
-    const keyLengths = Object.keys(obj).map(key => key.toString().length);
+    const keyLengths = Object.keys(obj).map((key) => key.toString().length);
     const maxKeyLength = Math.max(...keyLengths) + 2;
     function pp(obj) {
         if (typeof obj === 'string' || typeof obj === 'number')
             return obj;
         if (typeof obj === 'object') {
             return Object.keys(obj)
-                .map(k => k + ': ' + util.inspect(obj[k]))
+                .map((k) => k + ': ' + (0, node_util_1.inspect)(obj[k]))
                 .join(', ');
         }
-        return util.inspect(obj);
+        return (0, node_util_1.inspect)(obj);
     }
-    const logKeyValue = (key, value) => {
-        return `${chalk.blue(key)}:` + ' '.repeat(maxKeyLength - key.length - 1) + pp(value);
-    };
+    const logKeyValue = (key, value) => `${chalk_1.default.blue(key)}:` + ' '.repeat(maxKeyLength - key.length - 1) + pp(value);
     for (const key of keys || Object.keys(obj).sort()) {
         const value = obj[key];
         if (Array.isArray(value)) {

package/lib/{ux → cli-ux}/styled/table.d.ts

@@ -3,13 +3,13 @@ export declare function table<T extends Record<string, unknown>>(data: T[], colu
 export declare namespace table {
     export const Flags: {
         columns: Interfaces.OptionFlag<string | undefined>;
-        sort: Interfaces.OptionFlag<string | undefined>;
+        csv: Interfaces.BooleanFlag<boolean>;
+        extended: Interfaces.BooleanFlag<boolean>;
         filter: Interfaces.OptionFlag<string | undefined>;
-        csv: Interfaces.Flag<boolean>;
+        'no-header': Interfaces.BooleanFlag<boolean>;
+        'no-truncate': Interfaces.BooleanFlag<boolean>;
         output: Interfaces.OptionFlag<string | undefined>;
-        extended: Interfaces.Flag<boolean>;
-        'no-truncate': Interfaces.Flag<boolean>;
-        'no-header': Interfaces.Flag<boolean>;
+        sort: Interfaces.OptionFlag<string | undefined>;
     };
     type IFlags = typeof Flags;
     type ExcludeFlags<T, Z> = Pick<T, Exclude<keyof T, Z>>;
@@ -22,24 +22,24 @@ export declare namespace table {
         only: K | K[];
     }): IncludeFlags<IFlags, K>;
     export interface Column<T extends Record<string, unknown>> {
-        header: string;
         extended: boolean;
-        minWidth: number;
         get(row: T): any;
+        header: string;
+        minWidth: number;
     }
     export type Columns<T extends Record<string, unknown>> = {
         [key: string]: Partial<Column<T>>;
     };
     export interface Options {
         [key: string]: any;
-        sort?: string;
-        filter?: string;
         columns?: string;
         extended?: boolean;
+        filter?: string;
+        'no-header'?: boolean;
         'no-truncate'?: boolean;
         output?: string;
-        'no-header'?: boolean;
         printLine?(s: any): any;
+        sort?: string;
     }
     export {};
 }

package/lib/{ux → cli-ux}/styled/table.js

@@ -1,17 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.table = void 0;
-const F = require("../../flags");
-const screen_1 = require("../../screen");
-const chalk = require("chalk");
-const util_1 = require("../../util");
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const js_yaml_1 = require("js-yaml");
-const util_2 = require("util");
+const natural_orderby_1 = require("natural-orderby");
+const node_util_1 = require("node:util");
+const slice_ansi_1 = tslib_1.__importDefault(require("slice-ansi"));
+const string_width_1 = tslib_1.__importDefault(require("string-width"));
+const F = tslib_1.__importStar(require("../../flags"));
+const screen_1 = require("../../screen");
+const util_1 = require("../../util/util");
 const stream_1 = require("../stream");
-const sw = require('string-width');
-const { orderBy } = require('natural-orderby');
-const sliceAnsi = require('slice-ansi');
 class Table {
+    data;
+    columns;
+    options;
     constructor(data, columns, options = {}) {
         this.data = data;
         // assign columns
@@ -20,8 +24,8 @@ class Table {
             const extended = col.extended ?? false;
             // turn null and undefined into empty strings by default
             const get = col.get ?? ((row) => row[key] ?? '');
-            const header = typeof col.header === 'string' ? col.header : (0, util_1.capitalize)(key.replace(/_/g, ' '));
-            const minWidth = Math.max(col.minWidth ?? 0, sw(header) + 1);
+            const header = typeof col.header === 'string' ? col.header : (0, util_1.capitalize)(key.replaceAll('_', ' '));
+            const minWidth = Math.max(col.minWidth ?? 0, (0, string_width_1.default)(header) + 1);
             return {
                 extended,
                 get,
@@ -31,137 +35,59 @@ class Table {
             };
         });
         // assign options
-        const { columns: cols, filter, csv, output, extended, sort, title, printLine } = options;
+        const { columns: cols, csv, extended, filter, output, printLine, sort, title } = options;
         this.options = {
             columns: cols,
-            output: csv ? 'csv' : output,
             extended,
             filter,
             'no-header': options['no-header'] ?? false,
             'no-truncate': options['no-truncate'] ?? false,
+            output: csv ? 'csv' : output,
             printLine: printLine ?? ((s) => stream_1.stdout.write(s + '\n')),
             rowStart: ' ',
             sort,
             title,
         };
     }
-    display() {
-        // build table rows from input array data
-        let rows = this.data.map(d => {
-            const row = {};
-            for (const col of this.columns) {
-                let val = col.get(d);
-                if (typeof val !== 'string')
-                    val = (0, util_2.inspect)(val, { breakLength: Number.POSITIVE_INFINITY });
-                row[col.key] = val;
-            }
-            return row;
-        });
-        // filter rows
-        if (this.options.filter) {
-            /* eslint-disable-next-line prefer-const */
-            let [header, regex] = this.options.filter.split('=');
-            const isNot = header[0] === '-';
-            if (isNot)
-                header = header.slice(1);
-            const col = this.findColumnFromHeader(header);
-            if (!col || !regex)
-                throw new Error('Filter flag has an invalid value');
-            rows = rows.filter((d) => {
-                const re = new RegExp(regex);
-                const val = d[col.key];
-                const match = val.match(re);
-                return isNot ? !match : match;
-            });
-        }
-        // sort rows
-        if (this.options.sort) {
-            const sorters = this.options.sort.split(',');
-            const sortHeaders = sorters.map(k => k[0] === '-' ? k.slice(1) : k);
-            const sortKeys = this.filterColumnsFromHeaders(sortHeaders).map(c => {
-                return ((v) => v[c.key]);
-            });
-            const sortKeysOrder = sorters.map(k => k[0] === '-' ? 'desc' : 'asc');
-            rows = orderBy(rows, sortKeys, sortKeysOrder);
-        }
-        // and filter columns
-        if (this.options.columns) {
-            const filters = this.options.columns.split(',');
-            this.columns = this.filterColumnsFromHeaders(filters);
-        }
-        else if (!this.options.extended) {
-            // show extented columns/properties
-            this.columns = this.columns.filter(c => !c.extended);
-        }
-        this.data = rows;
-        switch (this.options.output) {
-            case 'csv':
-                this.outputCSV();
-                break;
-            case 'json':
-                this.outputJSON();
-                break;
-            case 'yaml':
-                this.outputYAML();
-                break;
-            default:
-                this.outputTable();
-        }
-    }
-    findColumnFromHeader(header) {
-        return this.columns.find(c => c.header.toLowerCase() === header.toLowerCase());
-    }
     filterColumnsFromHeaders(filters) {
         // unique
-        filters = [...(new Set(filters))];
+        filters = [...new Set(filters)];
         const cols = [];
         for (const f of filters) {
-            const c = this.columns.find(c => c.header.toLowerCase() === f.toLowerCase());
+            const c = this.columns.find((c) => c.header.toLowerCase() === f.toLowerCase());
             if (c)
                 cols.push(c);
         }
         return cols;
     }
+    findColumnFromHeader(header) {
+        return this.columns.find((c) => c.header.toLowerCase() === header.toLowerCase());
+    }
     getCSVRow(d) {
-        const values = this.columns.map(col => d[col.key] || '');
+        const values = this.columns.map((col) => d[col.key] || '');
         const lineToBeEscaped = values.find((e) => e.includes('"') || e.includes('\n') || e.includes('\r\n') || e.includes('\r') || e.includes(','));
-        return values.map(e => lineToBeEscaped ? `"${e.replace('"', '""')}"` : e);
-    }
-    resolveColumnsToObjectArray() {
-        const { data, columns } = this;
-        return data.map((d) => {
-            // eslint-disable-next-line unicorn/prefer-object-from-entries
-            return columns.reduce((obj, col) => {
-                return {
-                    ...obj,
-                    [col.key]: d[col.key] ?? '',
-                };
-            }, {});
-        });
-    }
-    outputJSON() {
-        this.options.printLine(JSON.stringify(this.resolveColumnsToObjectArray(), undefined, 2));
-    }
-    outputYAML() {
-        this.options.printLine((0, js_yaml_1.safeDump)(this.resolveColumnsToObjectArray()));
+        return values.map((e) => (lineToBeEscaped ? `"${e.replace('"', '""')}"` : e));
     }
     outputCSV() {
-        const { data, columns, options } = this;
+        const { columns, data, options } = this;
         if (!options['no-header']) {
-            options.printLine(columns.map(c => c.header).join(','));
+            options.printLine(columns.map((c) => c.header).join(','));
         }
         for (const d of data) {
             const row = this.getCSVRow(d);
             options.printLine(row.join(','));
         }
     }
+    outputJSON() {
+        this.options.printLine(JSON.stringify(this.resolveColumnsToObjectArray(), undefined, 2));
+    }
     outputTable() {
         const { data, options } = this;
         // column truncation
         //
         // find max width for each column
-        const columns = this.columns.map(c => {
-            const maxWidth = Math.max(sw('.'.padEnd(c.minWidth - 1)), sw(c.header), getWidestColumnWith(data, c.key)) + 1;
+        const columns = this.columns.map((c) => {
+            const maxWidth = Math.max((0, string_width_1.default)('.'.padEnd(c.minWidth - 1)), (0, string_width_1.default)(c.header), getWidestColumnWith(data, c.key)) + 1;
             return {
                 ...c,
                 maxWidth,
@@ -176,7 +102,7 @@ class Table {
             if (options['no-truncate'] || (!stream_1.stdout.isTTY && !process.env.CLI_UX_SKIP_TTY_CHECK))
                 return;
             // don't shorten if there is enough screen width
-            const dataMaxWidth = (0, util_1.sumBy)(columns, c => c.width);
+            const dataMaxWidth = (0, util_1.sumBy)(columns, (c) => c.width);
             const overWidth = dataMaxWidth - maxWidth;
             if (overWidth <= 0)
                 return;
@@ -187,16 +113,18 @@ class Table {
             // if sum(minWidth's) is greater than term width
             // nothing can be done so
             // display all as minWidth
-            const dataMinWidth = (0, util_1.sumBy)(columns, c => c.minWidth);
+            const dataMinWidth = (0, util_1.sumBy)(columns, (c) => c.minWidth);
             if (dataMinWidth >= maxWidth)
                 return;
             // some wiggle room left, add it back to "needy" columns
             let wiggleRoom = maxWidth - dataMinWidth;
-            const needyCols = columns.map(c => ({ key: c.key, needs: c.maxWidth - c.width })).sort((a, b) => a.needs - b.needs);
+            const needyCols = columns
+                .map((c) => ({ key: c.key, needs: c.maxWidth - c.width }))
+                .sort((a, b) => a.needs - b.needs);
             for (const { key, needs } of needyCols) {
                 if (!needs)
                     continue;
-                const col = columns.find(c => key === c.key);
+                const col = columns.find((c) => key === c.key);
                 if (!col)
                     continue;
                 if (wiggleRoom > needs) {
@@ -224,14 +152,14 @@ class Table {
                 const header = col.header;
                 headers += header.padEnd(col.width);
             }
-            options.printLine(chalk.bold(headers));
+            options.printLine(chalk_1.default.bold(headers));
             // print header dividers
             let dividers = options.rowStart;
             for (const col of columns) {
                 const divider = ''.padEnd(col.width - 1, '─') + ' ';
                 dividers += divider.padEnd(col.width);
             }
-            options.printLine(chalk.bold(dividers));
+            options.printLine(chalk_1.default.bold(dividers));
         }
         // print rows
         for (const row of data) {
@@ -255,16 +183,16 @@ class Table {
                     const width = col.width;
                     let d = row[col.key];
                     d = d.split('\n')[i] || '';
-                    const visualWidth = sw(d);
-                    const colorWidth = (d.length - visualWidth);
+                    const visualWidth = (0, string_width_1.default)(d);
+                    const colorWidth = d.length - visualWidth;
                     let cell = d.padEnd(width + colorWidth);
-                    if ((cell.length - colorWidth) > width || visualWidth === width) {
+                    if (cell.length - colorWidth > width || visualWidth === width) {
                         // truncate the cell, preserving ANSI escape sequences, and keeping
                         // into account the width of fullwidth unicode characters
-                        cell = sliceAnsi(cell, 0, width - 2) + '… ';
+                        cell = (0, slice_ansi_1.default)(cell, 0, width - 2) + '… ';
                         // pad with spaces; this is necessary in case the original string
                         // contained fullwidth characters which cannot be split
-                        cell += ' '.repeat(width - sw(cell));
+                        cell += ' '.repeat(width - (0, string_width_1.default)(cell));
                     }
                     l += cell;
                 }
@@ -272,6 +200,77 @@ class Table {
             }
         }
     }
+    outputYAML() {
+        this.options.printLine((0, js_yaml_1.safeDump)(this.resolveColumnsToObjectArray()));
+    }
+    resolveColumnsToObjectArray() {
+        const { columns, data } = this;
+        return data.map((d) => Object.fromEntries(columns.map((col) => [col.key, d[col.key] ?? ''])));
+    }
+    display() {
+        // build table rows from input array data
+        let rows = this.data.map((d) => {
+            const row = {};
+            for (const col of this.columns) {
+                let val = col.get(d);
+                if (typeof val !== 'string')
+                    val = (0, node_util_1.inspect)(val, { breakLength: Number.POSITIVE_INFINITY });
+                row[col.key] = val;
+            }
+            return row;
+        });
+        // filter rows
+        if (this.options.filter) {
+            let [header, regex] = this.options.filter.split('=');
+            const isNot = header[0] === '-';
+            if (isNot)
+                header = header.slice(1);
+            const col = this.findColumnFromHeader(header);
+            if (!col || !regex)
+                throw new Error('Filter flag has an invalid value');
+            rows = rows.filter((d) => {
+                const re = new RegExp(regex);
+                const val = d[col.key];
+                const match = val.match(re);
+                return isNot ? !match : match;
+            });
+        }
+        // sort rows
+        if (this.options.sort) {
+            const sorters = this.options.sort.split(',');
+            const sortHeaders = sorters.map((k) => (k[0] === '-' ? k.slice(1) : k));
+            const sortKeys = this.filterColumnsFromHeaders(sortHeaders).map((c) => (v) => v[c.key]);
+            const sortKeysOrder = sorters.map((k) => (k[0] === '-' ? 'desc' : 'asc'));
+            rows = (0, natural_orderby_1.orderBy)(rows, sortKeys, sortKeysOrder);
+        }
+        // and filter columns
+        if (this.options.columns) {
+            const filters = this.options.columns.split(',');
+            this.columns = this.filterColumnsFromHeaders(filters);
+        }
+        else if (!this.options.extended) {
+            // show extented columns/properties
+            this.columns = this.columns.filter((c) => !c.extended);
+        }
+        this.data = rows;
+        switch (this.options.output) {
+            case 'csv': {
+                this.outputCSV();
+                break;
+            }
+            case 'json': {
+                this.outputJSON();
+                break;
+            }
+            case 'yaml': {
+                this.outputYAML();
+                break;
+            }
+            default: {
+                this.outputTable();
+            }
+        }
+    }
 }
 function table(data, columns, options = {}) {
     new Table(data, columns, options).display();
@@ -279,20 +278,19 @@ function table(data, columns, options = {}) {
 exports.table = table;
 (function (table) {
     table.Flags = {
-        columns: F.string({ exclusive: ['extended'], description: 'only show provided columns (comma-separated)' }),
-        sort: F.string({ description: 'property to sort by (prepend \'-\' for descending)' }),
+        columns: F.string({ description: 'only show provided columns (comma-separated)', exclusive: ['extended'] }),
+        csv: F.boolean({ description: 'output is csv format [alias: --output=csv]', exclusive: ['no-truncate'] }),
+        extended: F.boolean({ char: 'x', description: 'show extra columns', exclusive: ['columns'] }),
         filter: F.string({ description: 'filter property by partial string matching, ex: name=foo' }),
-        csv: F.boolean({ exclusive: ['no-truncate'], description: 'output is csv format [alias: --output=csv]' }),
+        'no-header': F.boolean({ description: 'hide table header from output', exclusive: ['csv'] }),
+        'no-truncate': F.boolean({ description: 'do not truncate output to fit screen', exclusive: ['csv'] }),
         output: F.string({
-            exclusive: ['no-truncate', 'csv'],
             description: 'output in a more machine friendly format',
+            exclusive: ['no-truncate', 'csv'],
             options: ['csv', 'json', 'yaml'],
         }),
-        extended: F.boolean({ exclusive: ['columns'], char: 'x', description: 'show extra columns' }),
-        'no-truncate': F.boolean({ exclusive: ['csv'], description: 'do not truncate output to fit screen' }),
-        'no-header': F.boolean({ exclusive: ['csv'], description: 'hide table header from output' }),
+        sort: F.string({ description: "property to sort by (prepend '-' for descending)" }),
     };
-    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
     function flags(opts) {
         if (opts) {
             const f = {};
@@ -300,6 +298,7 @@ exports.table = table;
             const e = (opts.except && typeof opts.except === 'string' ? [opts.except] : opts.except) || [];
             for (const key of o) {
                 if (!e.includes(key)) {
+                    ;
                     f[key] = table.Flags[key];
                 }
             }
@@ -308,13 +307,11 @@ exports.table = table;
         return table.Flags;
     }
     table.flags = flags;
-})(table = exports.table || (exports.table = {}));
-const getWidestColumnWith = (data, columnKey) => {
-    return data.reduce((previous, current) => {
-        const d = current[columnKey];
-        // convert multi-line cell to single longest line
-        // for width calculations
-        const manyLines = d.split('\n');
-        return Math.max(previous, manyLines.length > 1 ? Math.max(...manyLines.map((r) => sw(r))) : sw(d));
-    }, 0);
-};
+})(table || (exports.table = table = {}));
+const getWidestColumnWith = (data, columnKey) => data.reduce((previous, current) => {
+    const d = current[columnKey];
+    // convert multi-line cell to single longest line
+    // for width calculations
+    const manyLines = d.split('\n');
+    return Math.max(previous, manyLines.length > 1 ? Math.max(...manyLines.map((r) => (0, string_width_1.default)(r))) : (0, string_width_1.default)(d));
+}, 0);

package/lib/{ux → cli-ux}/styled/tree.js

@@ -3,8 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Tree = void 0;
 const treeify = require('object-treeify');
 class Tree {
-    constructor() {
-        this.nodes = {};
+    nodes = {};
+    display(logger = console.log) {
+        const addNodes = function (nodes) {
+            const tree = {};
+            for (const p of Object.keys(nodes)) {
+                tree[p] = addNodes(nodes[p].nodes);
+            }
+            return tree;
+        };
+        const tree = addNodes(this.nodes);
+        logger(treeify(tree));
     }
     insert(child, value = new Tree()) {
         this.nodes[child] = value;
@@ -20,17 +29,6 @@ class Tree {
                 return c;
         }
     }
-    display(logger = console.log) {
-        const addNodes = function (nodes) {
-            const tree = {};
-            for (const p of Object.keys(nodes)) {
-                tree[p] = addNodes(nodes[p].nodes);
-            }
-            return tree;
-        };
-        const tree = addNodes(this.nodes);
-        logger(treeify(tree));
-    }
 }
 exports.Tree = Tree;
 function tree() {

package/lib/cli-ux/wait.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = (ms = 1000) => new Promise((resolve) => {
+    setTimeout(resolve, ms);
+});