table 6.0.8 → 6.3.0

package/dist/src/makeStreamConfig.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_clonedeep_1 = __importDefault(require("lodash.clonedeep"));
+const getBorderCharacters_1 = __importDefault(require("./getBorderCharacters"));
+const validateConfig_1 = __importDefault(require("./validateConfig"));
+/**
+ * Merges user provided border characters with the default border ("honeywell") characters.
+ *
+ */
+const makeBorder = (border) => {
+    return {
+        ...getBorderCharacters_1.default('honeywell'),
+        ...border,
+    };
+};
+/**
+ * Creates a configuration for every column using default
+ * values for the missing configuration properties.
+ */
+const makeColumns = (columnCount, columns = {}, columnDefault) => {
+    return Array.from({ length: columnCount }).map((_, index) => {
+        return {
+            alignment: 'left',
+            paddingLeft: 1,
+            paddingRight: 1,
+            truncate: Number.POSITIVE_INFINITY,
+            wrapWord: false,
+            ...columnDefault,
+            ...columns[index],
+        };
+    });
+};
+/**
+ * Makes a new configuration object out of the userConfig object
+ * using default values for the missing configuration properties.
+ */
+exports.default = (userConfig) => {
+    var _a;
+    validateConfig_1.default('streamConfig.json', userConfig);
+    const config = lodash_clonedeep_1.default(userConfig);
+    if (!config.columnDefault || !config.columnDefault.width) {
+        throw new Error('Must provide config.columnDefault.width when creating a stream.');
+    }
+    if (!config.columnCount) {
+        throw new Error('Must provide config.columnCount.');
+    }
+    return {
+        ...config,
+        border: makeBorder(config.border),
+        columnCount: config.columnCount,
+        columns: makeColumns(config.columnCount, config.columns, config.columnDefault),
+        drawVerticalLine: (_a = config.drawVerticalLine) !== null && _a !== void 0 ? _a : (() => {
+            return true;
+        }),
+    };
+};
+//# sourceMappingURL=makeStreamConfig.js.map

package/dist/src/mapDataUsingRowHeightIndex.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_flatten_1 = __importDefault(require("lodash.flatten"));
+const wrapCell_1 = __importDefault(require("./wrapCell"));
+exports.default = (unmappedRows, rowHeightIndex, config) => {
+    const tableWidth = unmappedRows[0].length;
+    const mappedRows = unmappedRows.map((row, index0) => {
+        const rowHeight = Array.from({ length: rowHeightIndex[index0] }, () => {
+            return new Array(tableWidth).fill('');
+        });
+        // rowHeight
+        //     [{row index within rowSaw; index2}]
+        //     [{cell index within a virtual row; index1}]
+        row.forEach((cell, index1) => {
+            const cellLines = wrapCell_1.default(cell, config.columns[index1].width, config.columns[index1].wrapWord);
+            cellLines.forEach((cellLine, index2) => {
+                rowHeight[index2][index1] = cellLine;
+            });
+        });
+        return rowHeight;
+    });
+    return lodash_flatten_1.default(mappedRows);
+};
+//# sourceMappingURL=mapDataUsingRowHeightIndex.js.map

package/dist/src/padTableData.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = (rows, config) => {
+    return rows.map((cells) => {
+        return cells.map((value, index1) => {
+            const column = config.columns[index1];
+            return ' '.repeat(column.paddingLeft) + value + ' '.repeat(column.paddingRight);
+        });
+    });
+};
+//# sourceMappingURL=padTableData.js.map

package/dist/src/stringifyTableData.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = (rows) => {
+    return rows.map((cells) => {
+        return cells.map(String);
+    });
+};
+//# sourceMappingURL=stringifyTableData.js.map

package/dist/src/table.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const alignTableData_1 = __importDefault(require("./alignTableData"));
+const calculateCellWidthIndex_1 = __importDefault(require("./calculateCellWidthIndex"));
+const calculateRowHeightIndex_1 = __importDefault(require("./calculateRowHeightIndex"));
+const drawTable_1 = __importDefault(require("./drawTable"));
+const makeConfig_1 = __importDefault(require("./makeConfig"));
+const mapDataUsingRowHeightIndex_1 = __importDefault(require("./mapDataUsingRowHeightIndex"));
+const padTableData_1 = __importDefault(require("./padTableData"));
+const stringifyTableData_1 = __importDefault(require("./stringifyTableData"));
+const truncateTableData_1 = __importDefault(require("./truncateTableData"));
+const validateTableData_1 = __importDefault(require("./validateTableData"));
+exports.default = (data, userConfig = {}) => {
+    validateTableData_1.default(data);
+    let rows = stringifyTableData_1.default(data);
+    const config = makeConfig_1.default(rows, userConfig);
+    rows = truncateTableData_1.default(rows, config);
+    const rowHeightIndex = calculateRowHeightIndex_1.default(rows, config);
+    rows = mapDataUsingRowHeightIndex_1.default(rows, rowHeightIndex, config);
+    rows = alignTableData_1.default(rows, config);
+    rows = padTableData_1.default(rows, config);
+    const cellWidthIndex = calculateCellWidthIndex_1.default(rows[0]);
+    return drawTable_1.default(rows, cellWidthIndex, rowHeightIndex, config);
+};
+//# sourceMappingURL=table.js.map

package/dist/src/truncateTableData.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_truncate_1 = __importDefault(require("lodash.truncate"));
+/**
+ * @todo Make it work with ASCII content.
+ */
+exports.default = (rows, config) => {
+    return rows.map((cells) => {
+        return cells.map((content, index) => {
+            return lodash_truncate_1.default(content, {
+                length: config.columns[index].truncate,
+                omission: '…',
+            });
+        });
+    });
+};
+//# sourceMappingURL=truncateTableData.js.map

package/dist/src/types/api.d.ts

@@ -0,0 +1,99 @@
+export declare type DrawLinePredicate = (index: number, size: number) => boolean;
+export declare type DrawVerticalLine = DrawLinePredicate;
+export declare type DrawHorizontalLine = DrawLinePredicate;
+export declare type BorderUserConfig = {
+    readonly topLeft?: string;
+    readonly topRight?: string;
+    readonly topBody?: string;
+    readonly topJoin?: string;
+    readonly bottomLeft?: string;
+    readonly bottomRight?: string;
+    readonly bottomBody?: string;
+    readonly bottomJoin?: string;
+    readonly bodyRight?: string;
+    readonly bodyLeft?: string;
+    readonly bodyJoin?: string;
+    readonly joinLeft?: string;
+    readonly joinRight?: string;
+    readonly joinBody?: string;
+    readonly joinJoin?: string;
+};
+export declare type ColumnUserConfig = {
+    /**
+     * Cell content horizontal alignment (default: left)
+     */
+    readonly alignment?: 'center' | 'left' | 'right';
+    /**
+     * Column width (default: auto calculation based on the cell content)
+     */
+    readonly width?: number;
+    /**
+     * Number of characters are which the content will be truncated (default: Infinity)
+     */
+    readonly truncate?: number;
+    /**
+     * Cell content padding width left (default: 1)
+     */
+    readonly paddingLeft?: number;
+    /**
+     * Cell content padding width right (default: 1)
+     */
+    readonly paddingRight?: number;
+    /**
+     * If true, the text is broken at the nearest space or one of the special characters: "\|/_.,;-"
+     */
+    readonly wrapWord?: boolean;
+};
+export declare type BaseUserConfig = {
+    /**
+     * Custom border
+     */
+    readonly border?: BorderUserConfig;
+    /**
+     * Default values for all columns. Column specific settings overwrite the default values.
+     */
+    readonly columnDefault?: ColumnUserConfig;
+    /**
+     * Column specific configuration.
+     */
+    readonly columns?: Indexable<ColumnUserConfig>;
+    /**
+     * Used to tell whether to draw a vertical line.
+     * This callback is called for each non-content line of the table.
+     * The default behavior is to always return true.
+     */
+    readonly drawVerticalLine?: DrawVerticalLine;
+};
+export declare type TableUserConfig = BaseUserConfig & {
+    /**
+     * Used to tell whether to draw a horizontal line.
+     * This callback is called for each non-content line of the table.
+     * The default behavior is to always return true.
+     */
+    readonly drawHorizontalLine?: DrawHorizontalLine;
+    /**
+     * Horizontal lines inside the table are not drawn.
+     */
+    readonly singleLine?: boolean;
+};
+export declare type StreamUserConfig = BaseUserConfig & {
+    /**
+     * The number of columns
+     */
+    readonly columnCount: number;
+    /**
+     * Default values for all columns. Column specific settings overwrite the default values.
+     */
+    readonly columnDefault: ColumnUserConfig & {
+        /**
+         * The default width for each column
+         */
+        readonly width: number;
+    };
+};
+export declare type WritableStream = {
+    readonly write: (rows: string[]) => void;
+};
+export declare type Indexable<T> = {
+    readonly [index: number]: T;
+};

package/dist/src/types/api.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=api.js.map

package/dist/src/types/internal.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=internal.js.map

package/dist/src/validateConfig.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-expect-error
+// eslint-disable-next-line import/no-unresolved
+const validators_1 = __importDefault(require("./validators"));
+exports.default = (schemaId, config) => {
+    const validate = validators_1.default[schemaId];
+    if (!validate(config)) {
+        const errors = validate.errors.map((error) => {
+            return {
+                message: error.message,
+                params: error.params,
+                schemaPath: error.schemaPath,
+            };
+        });
+        /* eslint-disable no-console */
+        console.log('config', config);
+        console.log('errors', errors);
+        /* eslint-enable no-console */
+        throw new Error('Invalid config.');
+    }
+};
+//# sourceMappingURL=validateConfig.js.map

package/dist/src/validateTableData.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = (rows) => {
+    if (!Array.isArray(rows)) {
+        throw new TypeError('Table data must be an array.');
+    }
+    if (rows.length === 0) {
+        throw new Error('Table must define at least one row.');
+    }
+    if (rows[0].length === 0) {
+        throw new Error('Table must define at least one column.');
+    }
+    const columnNumber = rows[0].length;
+    for (const row of rows) {
+        if (!Array.isArray(row)) {
+            throw new TypeError('Table row data must be an array.');
+        }
+        if (row.length !== columnNumber) {
+            throw new Error('Table must have a consistent number of cells.');
+        }
+        for (const cell of row) {
+            // eslint-disable-next-line no-control-regex
+            if (/[\u0001-\u0006\u0008\u0009\u000B-\u001A]/.test(cell)) {
+                throw new Error('Table data must not contain control characters.');
+            }
+        }
+    }
+};
+//# sourceMappingURL=validateTableData.js.map

package/dist/{validators.js → src/validators.js}

@@ -14,6 +14,9 @@ const schema13 = {
         "columnDefault": {
             "$ref": "shared.json#/definitions/column"
         },
+        "drawVerticalLine": {
+            "typeof": "function"
+        },
         "drawHorizontalLine": {
             "typeof": "function"
         },
@@ -801,7 +804,7 @@ function validate43(data, {
     let errors = 0;
     if (data && typeof data == "object" && !Array.isArray(data)) {
         for (const key0 in data) {
-            if (!(((((key0 === "border") || (key0 === "columns")) || (key0 === "columnDefault")) || (key0 === "drawHorizontalLine")) || (key0 === "singleLine"))) {
+            if (!((((((key0 === "border") || (key0 === "columns")) || (key0 === "columnDefault")) || (key0 === "drawVerticalLine")) || (key0 === "drawHorizontalLine")) || (key0 === "singleLine"))) {
                 const err0 = {
                     instancePath,
                     schemaPath: "#/additionalProperties",
@@ -852,9 +855,26 @@ function validate43(data, {
                 errors = vErrors.length;
             }
         }
+        if (data.drawVerticalLine !== undefined) {
+            if (typeof data.drawVerticalLine != "function") {
+                const err1 = {
+                    instancePath: instancePath + "/drawVerticalLine",
+                    schemaPath: "#/properties/drawVerticalLine/typeof",
+                    keyword: "typeof",
+                    params: {},
+                    message: "should pass \"typeof\" keyword validation"
+                };
+                if (vErrors === null) {
+                    vErrors = [err1];
+                } else {
+                    vErrors.push(err1);
+                }
+                errors++;
+            }
+        }
         if (data.drawHorizontalLine !== undefined) {
             if (typeof data.drawHorizontalLine != "function") {
-                const err1 = {
+                const err2 = {
                     instancePath: instancePath + "/drawHorizontalLine",
                     schemaPath: "#/properties/drawHorizontalLine/typeof",
                     keyword: "typeof",
@@ -862,16 +882,16 @@ function validate43(data, {
                     message: "should pass \"typeof\" keyword validation"
                 };
                 if (vErrors === null) {
-                    vErrors = [err1];
+                    vErrors = [err2];
                 } else {
-                    vErrors.push(err1);
+                    vErrors.push(err2);
                 }
                 errors++;
             }
         }
         if (data.singleLine !== undefined) {
             if (typeof data.singleLine != "boolean") {
-                const err2 = {
+                const err3 = {
                     instancePath: instancePath + "/singleLine",
                     schemaPath: "#/properties/singleLine/typeof",
                     keyword: "typeof",
@@ -879,15 +899,15 @@ function validate43(data, {
                     message: "should pass \"typeof\" keyword validation"
                 };
                 if (vErrors === null) {
-                    vErrors = [err2];
+                    vErrors = [err3];
                 } else {
-                    vErrors.push(err2);
+                    vErrors.push(err3);
                 }
                 errors++;
             }
         }
     } else {
-        const err3 = {
+        const err4 = {
             instancePath,
             schemaPath: "#/type",
             keyword: "type",
@@ -897,9 +917,9 @@ function validate43(data, {
             message: "must be object"
         };
         if (vErrors === null) {
-            vErrors = [err3];
+            vErrors = [err4];
         } else {
-            vErrors.push(err3);
+            vErrors.push(err4);
         }
         errors++;
     }
@@ -923,6 +943,9 @@ const schema20 = {
         },
         "columnCount": {
             "type": "number"
+        },
+        "drawVerticalLine": {
+            "typeof": "function"
         }
     },
     "additionalProperties": false
@@ -1400,7 +1423,7 @@ function validate69(data, {
     let errors = 0;
     if (data && typeof data == "object" && !Array.isArray(data)) {
         for (const key0 in data) {
-            if (!((((key0 === "border") || (key0 === "columns")) || (key0 === "columnDefault")) || (key0 === "columnCount"))) {
+            if (!(((((key0 === "border") || (key0 === "columns")) || (key0 === "columnDefault")) || (key0 === "columnCount")) || (key0 === "drawVerticalLine"))) {
                 const err0 = {
                     instancePath,
                     schemaPath: "#/additionalProperties",
@@ -1471,8 +1494,25 @@ function validate69(data, {
                 errors++;
             }
         }
+        if (data.drawVerticalLine !== undefined) {
+            if (typeof data.drawVerticalLine != "function") {
+                const err2 = {
+                    instancePath: instancePath + "/drawVerticalLine",
+                    schemaPath: "#/properties/drawVerticalLine/typeof",
+                    keyword: "typeof",
+                    params: {},
+                    message: "should pass \"typeof\" keyword validation"
+                };
+                if (vErrors === null) {
+                    vErrors = [err2];
+                } else {
+                    vErrors.push(err2);
+                }
+                errors++;
+            }
+        }
     } else {
-        const err2 = {
+        const err3 = {
             instancePath,
             schemaPath: "#/type",
             keyword: "type",
@@ -1482,9 +1522,9 @@ function validate69(data, {
             message: "must be object"
         };
         if (vErrors === null) {
-            vErrors = [err2];
+            vErrors = [err3];
         } else {
-            vErrors.push(err2);
+            vErrors.push(err3);
         }
         errors++;
     }

package/dist/src/wrapCell.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const wrapString_1 = __importDefault(require("./wrapString"));
+const wrapWord_1 = __importDefault(require("./wrapWord"));
+/**
+ * Wrap a single cell value into a list of lines
+ *
+ * Always wraps on newlines, for the remainder uses either word or string wrapping
+ * depending on user configuration.
+ *
+ */
+exports.default = (cellValue, columnWidth, useWrapWord) => {
+    // First split on literal newlines
+    const cellLines = cellValue.split('\n');
+    // Then iterate over the list and word-wrap every remaining line if necessary.
+    for (let lineNr = 0; lineNr < cellLines.length;) {
+        let lineChunks;
+        if (useWrapWord) {
+            lineChunks = wrapWord_1.default(cellLines[lineNr], columnWidth);
+        }
+        else {
+            lineChunks = wrapString_1.default(cellLines[lineNr], columnWidth);
+        }
+        // Replace our original array element with whatever the wrapping returned
+        cellLines.splice(lineNr, 1, ...lineChunks);
+        lineNr += lineChunks.length;
+    }
+    return cellLines;
+};
+//# sourceMappingURL=wrapCell.js.map

package/dist/src/wrapString.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const slice_ansi_1 = __importDefault(require("slice-ansi"));
+const string_width_1 = __importDefault(require("string-width"));
+/**
+ * Creates an array of strings split into groups the length of size.
+ * This function works with strings that contain ASCII characters.
+ *
+ * wrapText is different from would-be "chunk" implementation
+ * in that whitespace characters that occur on a chunk size limit are trimmed.
+ *
+ */
+exports.default = (subject, size) => {
+    let subjectSlice = subject;
+    const chunks = [];
+    do {
+        chunks.push(slice_ansi_1.default(subjectSlice, 0, size));
+        subjectSlice = slice_ansi_1.default(subjectSlice, size).trim();
+    } while (string_width_1.default(subjectSlice));
+    return chunks;
+};
+//# sourceMappingURL=wrapString.js.map

package/dist/src/wrapWord.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const slice_ansi_1 = __importDefault(require("slice-ansi"));
+const string_width_1 = __importDefault(require("string-width"));
+exports.default = (input, size) => {
+    let subject = input;
+    const chunks = [];
+    // https://regex101.com/r/gY5kZ1/1
+    const re = new RegExp('(^.{1,' + String(size) + '}(\\s+|$))|(^.{1,' + String(size - 1) + '}(\\\\|/|_|\\.|,|;|-))');
+    do {
+        let chunk;
+        chunk = re.exec(subject);
+        if (chunk) {
+            chunk = chunk[0];
+            subject = slice_ansi_1.default(subject, string_width_1.default(chunk));
+            chunk = chunk.trim();
+        }
+        else {
+            chunk = slice_ansi_1.default(subject, 0, size);
+            subject = slice_ansi_1.default(subject, size);
+        }
+        chunks.push(chunk);
+    } while (string_width_1.default(subject));
+    return chunks;
+};
+//# sourceMappingURL=wrapWord.js.map