@zoodogood/utils 1.0.5-change.421 → 1.0.6-change.695

package/lib/primitives/TextTableBuilder.d.ts

@@ -0,0 +1,66 @@
+interface ITextTableGeneratorContext {
+    content: string;
+    metadata: IContextMetadata;
+    currentRow: number;
+}
+interface IContextMetadata {
+    columns?: {
+        largestLength: number;
+    }[];
+    tableWidth?: number;
+    separatorsIndexesInRow?: number[];
+}
+declare enum CellAlignEnum {
+    Left = 0,
+    Right = 1,
+    Center = 2
+}
+interface ICellOptions {
+    gapLeft: number;
+    gapRight: number;
+    align: CellAlignEnum;
+    removeNextSeparator?: boolean;
+}
+interface ITableCell {
+    value: string;
+    options: ICellOptions;
+}
+type TCellSetSymbolCallback = (context: ITextTableGeneratorContext, index: number) => string;
+interface ITableOptions {
+    borderLeft: null | TCellSetSymbolCallback;
+    borderRight: null | TCellSetSymbolCallback;
+    borderTop: null | TCellSetSymbolCallback;
+    borderBottom: null | TCellSetSymbolCallback;
+    separator: string;
+}
+declare enum BorderDirectionEnum {
+    BorderLeft = 0,
+    BorderRight = 1,
+    BorderTop = 2,
+    BorderBottom = 3
+}
+declare enum SpecialRowTypeEnum {
+    Default = 0,
+    Display = 1
+}
+interface ITableSpecialDisplayRow {
+    type: SpecialRowTypeEnum.Display;
+    display: TCellSetSymbolCallback;
+}
+type TTableRow = ITableCell[] | ITableSpecialDisplayRow;
+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;
+    addEmptyRow(): this;
+    addRowSeparator(setSymbol?: TCellSetSymbolCallback): this;
+    addCellAtRow(rowIndex: number, cellValue: ITableCell["value"], cellOptions: ICellOptions): this;
+    pushCellToArray<T = ITableCell>(array: (T | ITableCell)[], cellValue: ITableCell["value"], cellOptions?: Partial<ICellOptions>): this;
+    pushRowToTable(row: TTableRow): this;
+    generateTextContent(): string;
+}
+export { TextTableBuilder };
+export { SpecialRowTypeEnum, CellAlignEnum, BorderDirectionEnum };
+export type { ICellOptions, IContextMetadata, ITableCell, ITableOptions, ITextTableGeneratorContext, TTableRow, };

package/lib/primitives/TextTableBuilder.js

@@ -0,0 +1,269 @@
+function getRowType(row) {
+    if ("type" in row === false) {
+        return SpecialRowTypeEnum.Default;
+    }
+    return row.type;
+}
+function isCell(target) {
+    return "value" in target && "options" in target;
+}
+class TextTableGenerator {
+    constructor(rows, options) {
+        this.data = [];
+        this.context = {
+            content: "",
+            metadata: {},
+            currentRow: 0,
+        };
+        this.data = rows;
+        this.options = options;
+        this.parseMetadata();
+    }
+    generateTextContent() {
+        const context = this.context;
+        if (this.options.borderTop !== null) {
+            context.content += this.drawBlockBorder(BorderDirectionEnum.BorderTop);
+            context.content += "\n";
+        }
+        for (const row of this.data) {
+            context.currentRow = this.data.indexOf(row);
+            context.content += this.drawRow(row);
+            context.content += "\n";
+        }
+        if (this.options.borderBottom !== null) {
+            context.content += this.drawBlockBorder(BorderDirectionEnum.BorderBottom);
+        }
+        return context.content;
+    }
+    getColumns() {
+        const columns = [];
+        const rows = this.data;
+        const largestCellsCount = Math.max(...rows
+            .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 });
+            columns.push(column);
+        }
+        return columns;
+    }
+    parseMetadata() {
+        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)),
+        }));
+        metadata.columns = columnsMetadata;
+        metadata.tableWidth = this.calculateTableWidth();
+        metadata.separatorsIndexesInRow = (() => {
+            const indexes = [];
+            let current = 0;
+            if (!!this.options.borderLeft) {
+                indexes.push(current);
+            }
+            for (const { largestLength } of columnsMetadata) {
+                current += largestLength + 1;
+                indexes.push(current);
+            }
+            if (!this.options.borderRight) {
+                indexes.pop();
+            }
+            return indexes;
+        })();
+    }
+    drawRow(row) {
+        var _a, _b, _c, _d, _e, _f;
+        let content = "";
+        const context = this.context;
+        const metadata = context.metadata;
+        if (getRowType(row) === SpecialRowTypeEnum.Default) {
+            row = row;
+            content += (_c = (_b = (_a = this.options).borderLeft) === null || _b === void 0 ? void 0 : _b.call(_a, context, context.currentRow)) !== null && _c !== void 0 ? _c : "";
+            for (const cellIndex in row) {
+                const cell = row.at(+cellIndex);
+                const expectedWidth = metadata.columns.at(+cellIndex).largestLength;
+                content += this.drawCell(cell, expectedWidth);
+                if (+cellIndex !== row.length - 1) {
+                    content += !cell.options.removeNextSeparator
+                        ? this.options.separator
+                        : " ";
+                }
+            }
+            content += (_f = (_e = (_d = this.options).borderRight) === null || _e === void 0 ? void 0 : _e.call(_d, context, context.currentRow)) !== null && _f !== void 0 ? _f : "";
+            return content;
+        }
+        if (getRowType(row) === SpecialRowTypeEnum.Display) {
+            row = row;
+            content += this.drawLine(row.display);
+        }
+        return content;
+    }
+    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)}`;
+    }
+    drawLine(setSymbol) {
+        let content = "";
+        const context = this.context;
+        const length = this.calculateTableWidth();
+        for (const index in [...new Array(length)]) {
+            const symbol = setSymbol(context, +index);
+            content += symbol;
+        }
+        return content;
+    }
+    drawBlockBorder(borderDirection) {
+        const callback = borderDirection === BorderDirectionEnum.BorderTop
+            ? this.options.borderTop
+            : this.options.borderBottom;
+        return this.drawLine(callback);
+    }
+    calculateTableWidth() {
+        const { columns } = this.context.metadata;
+        if (!columns) {
+            throw new Error("No columns field; Tip: Use <this>.parseMetadata() previous");
+        }
+        const cells = columns.reduce((acc, current) => current.largestLength + acc, 0);
+        const separators = columns.length - 1;
+        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) {
+    CellAlignEnum[CellAlignEnum["Left"] = 0] = "Left";
+    CellAlignEnum[CellAlignEnum["Right"] = 1] = "Right";
+    CellAlignEnum[CellAlignEnum["Center"] = 2] = "Center";
+})(CellAlignEnum || (CellAlignEnum = {}));
+const DEFAULT_CELL_OPTIONS = {
+    gapLeft: 2,
+    gapRight: 2,
+    align: CellAlignEnum.Left,
+};
+var BorderDirectionEnum;
+(function (BorderDirectionEnum) {
+    BorderDirectionEnum[BorderDirectionEnum["BorderLeft"] = 0] = "BorderLeft";
+    BorderDirectionEnum[BorderDirectionEnum["BorderRight"] = 1] = "BorderRight";
+    BorderDirectionEnum[BorderDirectionEnum["BorderTop"] = 2] = "BorderTop";
+    BorderDirectionEnum[BorderDirectionEnum["BorderBottom"] = 3] = "BorderBottom";
+})(BorderDirectionEnum || (BorderDirectionEnum = {}));
+const DEFAULT_TABLE_OPTIONS = {
+    borderLeft: null,
+    borderRight: null,
+    borderTop: null,
+    borderBottom: null,
+    separator: "|",
+};
+var SpecialRowTypeEnum;
+(function (SpecialRowTypeEnum) {
+    SpecialRowTypeEnum[SpecialRowTypeEnum["Default"] = 0] = "Default";
+    SpecialRowTypeEnum[SpecialRowTypeEnum["Display"] = 1] = "Display";
+})(SpecialRowTypeEnum || (SpecialRowTypeEnum = {}));
+class TextTableBuilder {
+    constructor() {
+        this.rows = [];
+        this.options = DEFAULT_TABLE_OPTIONS;
+    }
+    setBorderOptions(callback = () => "|", directions = [
+        BorderDirectionEnum.BorderLeft,
+        BorderDirectionEnum.BorderRight,
+    ]) {
+        for (const direction of directions) {
+            switch (direction) {
+                case BorderDirectionEnum.BorderLeft:
+                    this.options.borderLeft = callback;
+                    break;
+                case BorderDirectionEnum.BorderRight:
+                    this.options.borderRight = callback;
+                    break;
+                case BorderDirectionEnum.BorderTop:
+                    this.options.borderTop = callback;
+                    break;
+                case BorderDirectionEnum.BorderBottom:
+                    this.options.borderBottom = callback;
+                    break;
+            }
+        }
+        return this;
+    }
+    addRowWithElements(elements, optionsForEveryElement) {
+        const row = [];
+        for (const value of elements) {
+            this.pushCellToArray(row, value, optionsForEveryElement);
+        }
+        this.pushRowToTable(row);
+        return this;
+    }
+    addMultilineRowWithElements(elements, optionsForEveryElement) {
+        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);
+        }
+        return this;
+    }
+    addEmptyRow() {
+        this.pushRowToTable([]);
+        return this;
+    }
+    addRowSeparator(setSymbol = () => "-") {
+        const row = {
+            display: setSymbol,
+            type: SpecialRowTypeEnum.Display,
+        };
+        this.pushRowToTable(row);
+        return this;
+    }
+    addCellAtRow(rowIndex, cellValue, cellOptions) {
+        const row = this.rows.at(rowIndex);
+        if (!row) {
+            throw new RangeError("");
+        }
+        if (getRowType(row) !== SpecialRowTypeEnum.Default) {
+            throw new Error("Is not default row: without cells");
+        }
+        this.pushCellToArray(row, cellValue, cellOptions);
+        return this;
+    }
+    pushCellToArray(array, cellValue, cellOptions = {}) {
+        const options = Object.assign({}, DEFAULT_CELL_OPTIONS, cellOptions);
+        array.push({ value: cellValue, options });
+        return this;
+    }
+    pushRowToTable(row) {
+        this.rows.push(row);
+        return this;
+    }
+    generateTextContent() {
+        return new TextTableGenerator(this.rows, this.options).generateTextContent();
+    }
+}
+export { TextTableBuilder };
+export { SpecialRowTypeEnum, CellAlignEnum, BorderDirectionEnum };
+const builder = new TextTableBuilder()
+    .setBorderOptions()
+    .addRowWithElements(["1", "212", "3"], { align: CellAlignEnum.Left })
+    .addRowWithElements(["1", "2", "3"], { align: CellAlignEnum.Right })
+    .addRowSeparator()
+    .addRowWithElements(["777", "555", "1999"], { align: CellAlignEnum.Center });
+// the example has been simplified
+console.log(builder.generateTextContent());

package/lib/primitives/mod.d.ts

@@ -1,3 +1,4 @@
+export * from './TextTableBuilder.js';
 interface IEndingOptions {
     unite?: (quantity: number, word: string) => string;
 }

package/lib/primitives/mod.js

@@ -1,3 +1,4 @@
+export * from './TextTableBuilder.js';
 function ending(quantity = 0, base, multiple, alone, double, options = {}) {
     if (isNaN(quantity))
         return NaN;

package/package.json

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