@zoodogood/utils 1.0.6-change.724 → 1.0.7-change.854

package/lib/primitives/TextTableBuilder.d.ts

@@ -26,6 +26,10 @@ interface ITableCell {
     options: ICellOptions;
 }
 type TCellSetSymbolCallback = (context: ITextTableGeneratorContext, index: number) => string;
+interface ICellBuilderOptions {
+    minWidth?: number;
+    maxWidth?: number;
+}
 interface ITableOptions {
     borderLeft: null | TCellSetSymbolCallback;
     borderRight: null | TCellSetSymbolCallback;
@@ -52,11 +56,11 @@ declare class TextTableBuilder {
     rows: TTableRow[];
     protected options: ITableOptions;
     setBorderOptions(callback?: TCellSetSymbolCallback, directions?: BorderDirectionEnum[]): this;
-    addRowWithElements(elements: ITableCell["value"][], optionsForEveryElement?: Partial<ICellOptions>): this;
-    addMultilineRowWithElements(elements: ITableCell["value"][], optionsForEveryElement?: Partial<ICellOptions>): this;
+    addRowWithElements(elements: ITableCell["value"][], optionsForEveryElement?: Partial<ICellOptions>, useOnAddingOptions?: ICellBuilderOptions): this;
+    addMultilineRowWithElements(elements: ITableCell["value"][], optionsForEveryElement?: Partial<ICellOptions>, useOnAddingOptions?: ICellBuilderOptions): this;
     addEmptyRow(): this;
     addRowSeparator(setSymbol?: TCellSetSymbolCallback): this;
-    addCellAtRow(rowIndex: number, cellValue: ITableCell["value"], cellOptions: ICellOptions): this;
+    addCellAtRow(rowIndex: number, cellValue: ITableCell["value"], cellOptions: ICellOptions, useOnAddingOptions: ICellBuilderOptions): this;
     private pushCellToArray;
     private pushRowToTable;
     generateTextContent(): string;

package/lib/primitives/TextTableBuilder.js

@@ -7,6 +7,58 @@ function getRowType(row) {
 function isCell(target) {
     return "value" in target && "options" in target;
 }
+function emptyCell(value = "") {
+    return {
+        value,
+        options: DEFAULT_CELL_OPTIONS,
+    };
+}
+function addPaddingByCellAlign(original, totalForAdd, align) {
+    const addidableGapLeft = align === CellAlignEnum.Right
+        ? totalForAdd
+        : align === CellAlignEnum.Center
+            ? Math.floor(totalForAdd / 2)
+            : 0;
+    const addidableGapRight = align === CellAlignEnum.Left
+        ? totalForAdd
+        : align === CellAlignEnum.Center
+            ? Math.ceil(totalForAdd / 2)
+            : 0;
+    return `${" ".repeat(addidableGapLeft)}${original}${" ".repeat(addidableGapRight)}`;
+}
+function changeContentSetCellMinWidth(cell, minWidth) {
+    const currentMin = calculateCellMinWidth(cell);
+    if (minWidth <= currentMin) {
+        return cell;
+    }
+    const { value, options: { align }, } = cell;
+    const lack = minWidth - currentMin;
+    cell.value = addPaddingByCellAlign(value, lack, align);
+    return cell;
+}
+function changeContentSetCellMaxWidth(cell, maxWidth) {
+    const current = calculateCellMinWidth(cell);
+    if (maxWidth >= current) {
+        return cell;
+    }
+    let overage = current - maxWidth;
+    const gapDirection = cell.options.align === CellAlignEnum.Left ? "gapRight" : "gapLeft";
+    if (cell.options[gapDirection] > 1) {
+        cell.options[gapDirection]--;
+        overage--;
+        if (overage === 0) {
+            return;
+        }
+    }
+    const suffix = "..";
+    const sliced = cell.value.slice(0, -(overage + suffix.length));
+    cell.value = sliced + suffix;
+    return cell;
+}
+function calculateCellMinWidth(cell) {
+    const { gapLeft, gapRight } = cell.options;
+    return cell.value.length + gapLeft + gapRight;
+}
 class TextTableGenerator {
     constructor(rows, options) {
         this.data = [];
@@ -42,9 +94,12 @@ class TextTableGenerator {
             .filter((row) => getRowType(row) === SpecialRowTypeEnum.Default)
             .map((row) => row.length));
         for (let index = 0; index < largestCellsCount; index++) {
-            const column = rows.map((row) => getRowType(row) === SpecialRowTypeEnum.Default
-                ? row.at(index)
-                : { row });
+            const column = rows.map((row) => {
+                var _a;
+                return getRowType(row) === SpecialRowTypeEnum.Default
+                    ? (_a = row.at(index)) !== null && _a !== void 0 ? _a : emptyCell()
+                    : { row };
+            });
             columns.push(column);
         }
         return columns;
@@ -53,9 +108,7 @@ class TextTableGenerator {
         const metadata = this.context.metadata;
         const columns = this.getColumns();
         const columnsMetadata = columns.map((column) => ({
-            largestLength: Math.max(...column.map((element) => isCell(element)
-                ? this.calculateCellMinWidth(element)
-                : 0)),
+            largestLength: Math.max(...column.map((element) => isCell(element) ? calculateCellMinWidth(element) : 0)),
         }));
         metadata.columns = columnsMetadata;
         metadata.tableWidth = this.calculateTableWidth();
@@ -105,18 +158,10 @@ class TextTableGenerator {
     drawCell(cell, expectedWidth) {
         const { gapLeft, gapRight, align } = cell.options;
         const { value } = cell;
-        const minContentLength = this.calculateCellMinWidth(cell);
-        const addidableGapLeft = align === CellAlignEnum.Right
-            ? expectedWidth - minContentLength
-            : align === CellAlignEnum.Center
-                ? Math.floor((expectedWidth - minContentLength) / 2)
-                : 0;
-        const addidableGapRight = align === CellAlignEnum.Left
-            ? expectedWidth - minContentLength
-            : align === CellAlignEnum.Center
-                ? Math.ceil((expectedWidth - minContentLength) / 2)
-                : 0;
-        return `${" ".repeat(gapLeft + addidableGapLeft)}${value}${" ".repeat(gapRight + addidableGapRight)}`;
+        const minContentLength = calculateCellMinWidth(cell);
+        const lack = expectedWidth - minContentLength;
+        const contentWithPadding = addPaddingByCellAlign(value, lack, align);
+        return `${" ".repeat(gapLeft)}${contentWithPadding}${" ".repeat(gapRight)}`;
     }
     drawLine(setSymbol) {
         let content = "";
@@ -144,9 +189,6 @@ class TextTableGenerator {
         const borders = +!!this.options.borderLeft + +!!this.options.borderRight;
         return cells + separators + borders;
     }
-    calculateCellMinWidth(cell) {
-        return cell.value.length + cell.options.gapLeft + cell.options.gapRight;
-    }
 }
 var CellAlignEnum;
 (function (CellAlignEnum) {
@@ -181,7 +223,7 @@ var SpecialRowTypeEnum;
 class TextTableBuilder {
     constructor() {
         this.rows = [];
-        this.options = DEFAULT_TABLE_OPTIONS;
+        this.options = Object.assign({}, DEFAULT_TABLE_OPTIONS);
     }
     setBorderOptions(callback = () => "|", directions = [
         BorderDirectionEnum.BorderLeft,
@@ -205,19 +247,19 @@ class TextTableBuilder {
         }
         return this;
     }
-    addRowWithElements(elements, optionsForEveryElement) {
+    addRowWithElements(elements, optionsForEveryElement, useOnAddingOptions) {
         const row = [];
         for (const value of elements) {
-            this.pushCellToArray(row, value, optionsForEveryElement);
+            this.pushCellToArray(row, value, optionsForEveryElement, useOnAddingOptions);
         }
         this.pushRowToTable(row);
         return this;
     }
-    addMultilineRowWithElements(elements, optionsForEveryElement) {
+    addMultilineRowWithElements(elements, optionsForEveryElement, useOnAddingOptions) {
         const separatedElements = elements.map((value) => value.split("\n"));
         const largestHeight = Math.max(...separatedElements.map((sub) => sub.length));
         for (let index = 0; index < largestHeight; index++) {
-            this.addRowWithElements(separatedElements.map((sub) => { var _a; return (_a = sub.at(index)) !== null && _a !== void 0 ? _a : ""; }), optionsForEveryElement);
+            this.addRowWithElements(separatedElements.map((sub) => { var _a; return (_a = sub.at(index)) !== null && _a !== void 0 ? _a : ""; }), optionsForEveryElement, useOnAddingOptions);
         }
         return this;
     }
@@ -233,20 +275,24 @@ class TextTableBuilder {
         this.pushRowToTable(row);
         return this;
     }
-    addCellAtRow(rowIndex, cellValue, cellOptions) {
+    addCellAtRow(rowIndex, cellValue, cellOptions, useOnAddingOptions) {
         const row = this.rows.at(rowIndex);
         if (!row) {
-            throw new RangeError("");
+            throw new RangeError();
         }
         if (getRowType(row) !== SpecialRowTypeEnum.Default) {
             throw new Error("Is not default row: without cells");
         }
-        this.pushCellToArray(row, cellValue, cellOptions);
+        this.pushCellToArray(row, cellValue, cellOptions, useOnAddingOptions);
         return this;
     }
-    pushCellToArray(array, cellValue, cellOptions = {}) {
+    pushCellToArray(array, cellValue, cellOptions = {}, pushOptions) {
         const options = Object.assign({}, DEFAULT_CELL_OPTIONS, cellOptions);
-        array.push({ value: cellValue, options });
+        const cell = { value: cellValue, options };
+        const { minWidth, maxWidth } = pushOptions !== null && pushOptions !== void 0 ? pushOptions : {};
+        minWidth && changeContentSetCellMinWidth(cell, minWidth);
+        maxWidth && changeContentSetCellMaxWidth(cell, maxWidth);
+        array.push(cell);
         return this;
     }
     pushRowToTable(row) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@zoodogood/utils",
   "type": "module",
-  "version": "1.0.6-change.724",
+  "version": "1.0.7-change.854",
   "description": "",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",