@oclif/table 0.2.3 → 0.3.0

package/lib/table.d.ts

@@ -27,8 +27,8 @@ export declare function Skeleton(props: React.PropsWithChildren & {
     readonly height?: number;
 }): React.JSX.Element;
 /**
- * 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.
+ * Prints a table based on the provided options. If the data length exceeds 10,000 entries,
+ * the table is rendered in a non-styled format to avoid memory issues.
  *
  * @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.

package/lib/table.js

@@ -2,12 +2,13 @@
 import cliTruncate from 'cli-truncate';
 import { Box, Text, render } from 'ink';
 import { EventEmitter } from 'node:events';
+import { env } from 'node:process';
 import { sha1 } from 'object-hash';
 import React from 'react';
 import stripAnsi from 'strip-ansi';
 import wrapAnsi from 'wrap-ansi';
 import { BORDER_SKELETONS } from './skeletons.js';
-import { allKeysInCollection, determineWidthOfWrappedText, getColumns, getHeadings, intersperse, maybeStripAnsi, sortData, } from './utils.js';
+import { allKeysInCollection, determineWidthOfWrappedText, getColumns, getHeadings, intersperse, maybeStripAnsi, shouldUsePlainTable, sortData, } from './utils.js';
 /**
  * Determines the configured width based on the provided width value.
  * If no width is provided, it returns the width of the current terminal.
@@ -325,63 +326,66 @@ class Output {
     constructor() {
         this.stream = createStdout();
     }
-    maybePrintLastFrame() {
+    printLastFrame() {
         process.stdout.write(`${this.stream.lastFrame()}\n`);
     }
 }
-function chunk(array, size) {
-    return array.reduce((acc, _, i) => {
-        if (i % size === 0)
-            acc.push(array.slice(i, i + size));
-        return acc;
-    }, []);
-}
-function renderTableInChunks(props) {
-    const { columns, config, dataComponent, footerComponent, headerComponent, headerFooterComponent, headingComponent, headings, processedData, separatorComponent, title, titleOptions, } = setup(props);
-    const headerOutput = new Output();
-    const headerInstance = render(React.createElement(Box, { flexDirection: "column", width: determineWidthToUse(columns, config.maxWidth) },
-        title && React.createElement(Text, { ...titleOptions }, title),
-        headerComponent({ columns, data: {}, key: 'header' }),
-        headingComponent({ columns, data: headings, key: 'heading' }),
-        headerFooterComponent({ columns, data: {}, key: 'footer' })), { stdout: headerOutput.stream });
-    headerInstance.unmount();
-    headerOutput.maybePrintLastFrame();
-    const chunks = chunk(processedData, Math.max(1, Math.floor(process.stdout.rows / 2)));
-    for (const chunk of chunks) {
-        const chunkOutput = new Output();
-        const instance = render(React.createElement(Box, { flexDirection: "column", width: determineWidthToUse(columns, config.maxWidth) }, chunk.map((row, index) => {
-            // Calculate the hash of the row based on its value and position
-            const key = `row-${sha1(row)}-${index}`;
-            // Construct a row.
-            return (React.createElement(Box, { key: key, flexDirection: "column" },
-                separatorComponent({ columns, data: {}, key: `separator-${key}` }),
-                dataComponent({ columns, data: row, key: `data-${key}` })));
-        })), { stdout: chunkOutput.stream });
-        instance.unmount();
-        chunkOutput.maybePrintLastFrame();
+function renderPlainTable(props) {
+    const { columns, headings, processedData, title } = setup(props);
+    if (title)
+        console.log(title);
+    const headerString = columns.reduce((acc, column) => {
+        const { horizontalAlignment, overflow, padding, width } = column;
+        const { marginLeft, marginRight, text } = formatTextWithMargins({
+            horizontalAlignment,
+            overflow,
+            padding,
+            value: column.column,
+            width,
+        });
+        const columnHeader = headings[text] ?? text;
+        return `${acc}${' '.repeat(marginLeft)}${columnHeader}${' '.repeat(marginRight)}`;
+    }, '');
+    console.log(headerString);
+    console.log('-'.repeat(headerString.length));
+    for (const row of processedData) {
+        const stringToPrint = columns.reduce((acc, column) => {
+            const { horizontalAlignment, overflow, padding, width } = column;
+            const value = row[column.column];
+            if (value === undefined || value === null) {
+                return `${acc}${' '.repeat(width)}`;
+            }
+            const { marginLeft, marginRight, text } = formatTextWithMargins({
+                horizontalAlignment,
+                overflow,
+                padding,
+                value,
+                width,
+            });
+            return `${acc}${' '.repeat(marginLeft)}${text}${' '.repeat(marginRight)}`;
+        }, '');
+        console.log(stringToPrint);
     }
-    const footerOutput = new Output();
-    const footerInstance = render(React.createElement(Box, { flexDirection: "column", width: determineWidthToUse(columns, config.maxWidth) }, footerComponent({ columns, data: {}, key: 'footer' })), { stdout: footerOutput.stream });
-    footerInstance.unmount();
-    footerOutput.maybePrintLastFrame();
+    console.log();
 }
 /**
- * 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.
+ * Prints a table based on the provided options. If the data length exceeds 10,000 entries,
+ * the table is rendered in a non-styled format to avoid memory issues.
  *
  * @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) {
-        renderTableInChunks(options);
+    const limit = Number.parseInt(env.OCLIF_TABLE_LIMIT ?? env.SF_TABLE_LIMIT ?? '10000', 10) ?? 10_000;
+    if (options.data.length >= limit || shouldUsePlainTable()) {
+        renderPlainTable(options);
         return;
     }
     const output = new Output();
     const instance = render(React.createElement(Table, { ...options }), { stdout: output.stream });
     instance.unmount();
-    output.maybePrintLastFrame();
+    output.printLastFrame();
 }
 /**
  * Generates a table as a string based on the provided options.
@@ -422,5 +426,5 @@ export function printTables(tables, options) {
     }));
     const instance = render(React.createElement(Container, { ...options }, processed.map((table) => (React.createElement(Table, { key: sha1(table), ...table })))), { stdout: output.stream });
     instance.unmount();
-    output.maybePrintLastFrame();
+    output.printLastFrame();
 }

package/lib/utils.d.ts

@@ -14,3 +14,13 @@ export declare function determineWidthOfWrappedText(text: string): number;
 export declare function getColumns<T extends Record<string, unknown>>(config: Config<T>, headings: Partial<T>): Column<T>[];
 export declare function getHeadings<T extends Record<string, unknown>>(config: Config<T>): Partial<T>;
 export declare function maybeStripAnsi<T extends Record<string, unknown>[]>(data: T, noStyle: boolean): T;
+/**
+ * Determines whether the plain text table should be used.
+ *
+ * If the OCLIF_TABLE_SKIP_CI_CHECK environment variable is set to a truthy value, the CI check will be skipped.
+ *
+ * If the CI environment variable is set, the plain text table will be used.
+ *
+ * @returns {boolean} True if the plain text table should be used, false otherwise.
+ */
+export declare function shouldUsePlainTable(): boolean;

package/lib/utils.js

@@ -1,5 +1,6 @@
 import { camelCase, capitalCase, constantCase, kebabCase, pascalCase, sentenceCase, snakeCase } from 'change-case';
 import { orderBy } from 'natural-orderby';
+import { env } from 'node:process';
 import stripAnsi from 'strip-ansi';
 /**
  * Intersperses a list of elements with another element.
@@ -144,3 +145,24 @@ export function maybeStripAnsi(data, noStyle) {
     }
     return newData;
 }
+function isTruthy(value) {
+    return value !== '0' && value !== 'false';
+}
+/**
+ * Determines whether the plain text table should be used.
+ *
+ * If the OCLIF_TABLE_SKIP_CI_CHECK environment variable is set to a truthy value, the CI check will be skipped.
+ *
+ * If the CI environment variable is set, the plain text table will be used.
+ *
+ * @returns {boolean} True if the plain text table should be used, false otherwise.
+ */
+export function shouldUsePlainTable() {
+    if (env.OCLIF_TABLE_SKIP_CI_CHECK && isTruthy(env.OCLIF_TABLE_SKIP_CI_CHECK))
+        return false;
+    // Inspired by https://github.com/sindresorhus/is-in-ci
+    if (isTruthy(env.CI) &&
+        ('CI' in env || 'CONTINUOUS_INTEGRATION' in env || Object.keys(env).some((key) => key.startsWith('CI_'))))
+        return true;
+    return false;
+}

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@oclif/table",
   "description": "Display table in terminal",
-  "version": "0.2.3",
+  "version": "0.3.0",
   "author": "Salesforce",
   "bugs": "https://github.com/oclif/table/issues",
   "dependencies": {
     "@oclif/core": "^4",
-    "@types/react": "^18.3.11",
+    "@types/react": "^18.3.12",
     "change-case": "^5.4.4",
     "cli-truncate": "^4.0.0",
     "ink": "^5.0.1",
@@ -34,7 +34,7 @@
     "eslint-config-prettier": "^9.1.0",
     "eslint-config-xo": "^0.45.0",
     "eslint-config-xo-react": "^0.27.0",
-    "eslint-plugin-react": "^7.37.1",
+    "eslint-plugin-react": "^7.37.2",
     "eslint-plugin-react-hooks": "^4.6.2",
     "husky": "^9.1.6",
     "ink-testing-library": "^4.0.0",