@oclif/table 0.1.23 → 0.2.0

package/lib/index.d.ts

@@ -1,2 +1,2 @@
-export { printTable, printTables } from './table.js';
+export { makeTable, printTable, printTables } from './table.js';
 export type { TableOptions } from './types.js';

package/lib/index.js

@@ -1 +1 @@
-export { printTable, printTables } from './table.js';
+export { makeTable, printTable, printTables } from './table.js';

package/lib/table.d.ts

@@ -27,10 +27,30 @@ export declare function Skeleton(props: React.PropsWithChildren & {
     readonly height?: number;
 }): React.JSX.Element;
 /**
- * Renders a table with the given data.
- * @param options see {@link TableOptions}
+ * Prints a table based on the provided options. If the data length exceeds 50,000 entries,
+ * the table is rendered in chunks to handle large datasets efficiently.
+ *
+ * @template T - A generic type that extends a record with string keys and unknown values.
+ * @param {TableOptions<T>} options - The options for rendering the table, including data and other configurations.
+ * @returns {void}
  */
 export declare function printTable<T extends Record<string, unknown>>(options: TableOptions<T>): void;
+/**
+ * Generates a table as a string based on the provided options.
+ *
+ * @template T - A generic type extending a record with string keys and unknown values.
+ * @param {TableOptions<T>} options - The options to configure the table.
+ * @returns {string} The rendered table as a string.
+ */
+export declare function makeTable<T extends Record<string, unknown>>(options: TableOptions<T>): string;
+/**
+ * Prints multiple tables to the console.
+ *
+ * @template T - An array of records where each record represents a table.
+ * @param {Object.<keyof T, TableOptions<T[keyof T]>>} tables - An object containing table options for each table.
+ * @param {Omit<ContainerProps, 'children'>} [options] - Optional container properties excluding 'children'.
+ * @throws {Error} Throws an error if the total number of rows across all tables exceeds 30,000.
+ */
 export declare function printTables<T extends Record<string, unknown>[]>(tables: {
     [P in keyof T]: TableOptions<T[P]>;
 }, options?: Omit<ContainerProps, 'children'>): void;

package/lib/table.js

@@ -1,7 +1,7 @@
 /* eslint-disable react/prop-types */
 import cliTruncate from 'cli-truncate';
 import { Box, Text, render } from 'ink';
-import { WriteStream } from 'node:tty';
+import { EventEmitter } from 'node:events';
 import { sha1 } from 'object-hash';
 import React from 'react';
 import stripAnsi from 'strip-ansi';
@@ -279,49 +279,43 @@ export function Skeleton(props) {
     return React.createElement(Box, { flexDirection: "column" }, texts);
 }
 /**
- * A custom WriteStream that captures the frames written to stdout.
+ * Return a custom WriteStream that captures the frames written to stdout.
  * This allows us to avoid an issue where Ink rerenders the component twice
  * because it uses ansiEscapes.clearTerminal, which doesn't seem to have
  * the desired effect in powershell.
+ *
+ * Implementation inspired by https://github.com/vadimdemedes/ink/blob/master/test/helpers/create-stdout.ts
  */
-class Stream extends WriteStream {
+const createStdout = () => {
+    // eslint-disable-next-line unicorn/prefer-event-target
+    const stdout = new EventEmitter();
     // Override the rows so that ink doesn't clear the entire terminal when
     // unmounting the component and the height of the output is greater than
     // the height of the terminal
     // https://github.com/vadimdemedes/ink/blob/v5.0.1/src/ink.tsx#L174
     // This might be a bad idea but it works.
-    rows = 10_000;
-    frames = [];
-    lastFrame() {
-        return this.frames
-            .filter((f) => {
-            const stripped = stripAnsi(f);
-            return stripped !== '' && stripped !== '\n';
-        })
-            .at(-1);
-    }
-    write(data) {
-        this.frames.push(data);
+    stdout.rows = 10_000;
+    stdout.columns = process.stdout.columns ?? 80;
+    const frames = [];
+    stdout.write = (data) => {
+        frames.push(data);
         return true;
-    }
-}
+    };
+    stdout.lastFrame = () => frames
+        .filter((f) => {
+        const stripped = stripAnsi(f);
+        return stripped !== '' && stripped !== '\n';
+    })
+        .at(-1);
+    return stdout;
+};
 class Output {
     stream;
     constructor() {
-        // Use process.stdout if NODE_ENV is `test` OR if tests are being run by wireit on windows (windows + tests run by wireit
-        // are problematic for an unknown reason)
-        this.stream =
-            (process.platform === 'win32' && process.env.npm_lifecycle_script === 'wireit') || process.env.NODE_ENV === 'test'
-                ? process.stdout
-                : new Stream(process.env.OCLIF_TABLE_FD ? Number(process.env.OCLIF_TABLE_FD) : 0);
+        this.stream = createStdout();
     }
     maybePrintLastFrame() {
-        if (this.stream instanceof Stream) {
-            process.stdout.write(`${this.stream.lastFrame()}`);
-        }
-        else {
-            process.stdout.write('\n');
-        }
+        process.stdout.write(`${this.stream.lastFrame()}\n`);
     }
 }
 function chunk(array, size) {
@@ -361,8 +355,12 @@ function renderTableInChunks(props) {
     footerOutput.maybePrintLastFrame();
 }
 /**
- * Renders a table with the given data.
- * @param options see {@link TableOptions}
+ * Prints a table based on the provided options. If the data length exceeds 50,000 entries,
+ * the table is rendered in chunks to handle large datasets efficiently.
+ *
+ * @template T - A generic type that extends a record with string keys and unknown values.
+ * @param {TableOptions<T>} options - The options for rendering the table, including data and other configurations.
+ * @returns {void}
  */
 export function printTable(options) {
     if (options.data.length > 50_000) {
@@ -374,9 +372,30 @@ export function printTable(options) {
     instance.unmount();
     output.maybePrintLastFrame();
 }
+/**
+ * Generates a table as a string based on the provided options.
+ *
+ * @template T - A generic type extending a record with string keys and unknown values.
+ * @param {TableOptions<T>} options - The options to configure the table.
+ * @returns {string} The rendered table as a string.
+ */
+export function makeTable(options) {
+    const output = new Output();
+    const instance = render(React.createElement(Table, { ...options }), { stdout: output.stream });
+    instance.unmount();
+    return output.stream.lastFrame() ?? '';
+}
 function Container(props) {
     return (React.createElement(Box, { flexWrap: "wrap", flexDirection: props.direction ?? 'row', ...props }, props.children));
 }
+/**
+ * Prints multiple tables to the console.
+ *
+ * @template T - An array of records where each record represents a table.
+ * @param {Object.<keyof T, TableOptions<T[keyof T]>>} tables - An object containing table options for each table.
+ * @param {Omit<ContainerProps, 'children'>} [options] - Optional container properties excluding 'children'.
+ * @throws {Error} Throws an error if the total number of rows across all tables exceeds 30,000.
+ */
 export function printTables(tables, options) {
     if (tables.reduce((acc, table) => acc + table.data.length, 0) > 30_000) {
         throw new Error('The data is too large to print multiple tables. Please use `printTable` instead.');

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@oclif/table",
   "description": "Display table in terminal",
-  "version": "0.1.23",
+  "version": "0.2.0",
   "author": "Salesforce",
   "bugs": "https://github.com/oclif/table/issues",
   "dependencies": {