@travisennis/acai 0.0.5 → 0.0.7

package/dist/terminal/table/layout-manager.js

@@ -0,0 +1,257 @@
+import { Cell, ColSpanCell, RowSpanCell } from "./cell.js";
+import debug from "./debug.js";
+function next(alloc, col) {
+    if (alloc[col] > 0) {
+        return next(alloc, col + 1);
+    }
+    return col;
+}
+export function layoutTable(table) {
+    const alloc = {};
+    table.forEach((row, rowIndex) => {
+        let col = 0;
+        row.forEach((cell) => {
+            cell.y = rowIndex;
+            // Avoid erroneous call to next() on first row
+            cell.x = rowIndex ? next(alloc, col) : col;
+            const rowSpan = cell.rowSpan || 1;
+            const colSpan = cell.colSpan || 1;
+            if (rowSpan > 1) {
+                for (let cs = 0; cs < colSpan; cs++) {
+                    alloc[cell.x + cs] = rowSpan;
+                }
+            }
+            col = cell.x + colSpan;
+        });
+        Object.keys(alloc).forEach((idx) => {
+            alloc[idx]--;
+            if (alloc[idx] < 1)
+                delete alloc[idx];
+        });
+    });
+}
+export function maxWidth(table) {
+    let mw = 0;
+    table.forEach((row) => {
+        row.forEach((cell) => {
+            if (cell.x !== null) {
+                mw = Math.max(mw, cell.x + (cell.colSpan || 1));
+            }
+        });
+    });
+    return mw;
+}
+export function maxHeight(table) {
+    return table.length;
+}
+export function cellsConflict(cell1, cell2) {
+    const yMin1 = cell1.y;
+    const yMax1 = cell1.y - 1 + (cell1.rowSpan || 1);
+    const yMin2 = cell2.y;
+    const yMax2 = cell2.y - 1 + (cell2.rowSpan || 1);
+    const yConflict = !(yMin1 > yMax2 || yMin2 > yMax1);
+    const xMin1 = cell1.x;
+    const xMax1 = cell1.x - 1 + (cell1.colSpan || 1);
+    const xMin2 = cell2.x;
+    const xMax2 = cell2.x - 1 + (cell2.colSpan || 1);
+    const xConflict = !(xMin1 > xMax2 || xMin2 > xMax1);
+    return yConflict && xConflict;
+}
+export function conflictExists(rows, x, y) {
+    const iMax = Math.min(rows.length - 1, y);
+    const cell = { x: x, y: y };
+    for (let i = 0; i <= iMax; i++) {
+        const row = rows[i];
+        for (let j = 0; j < row.length; j++) {
+            const currentCell = row[j];
+            if (currentCell.x !== null && currentCell.y !== null) {
+                if (cellsConflict(cell, {
+                    x: currentCell.x,
+                    y: currentCell.y,
+                    rowSpan: currentCell.rowSpan,
+                    colSpan: currentCell.colSpan,
+                })) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+export function allBlank(rows, y, xMin, xMax) {
+    for (let x = xMin; x < xMax; x++) {
+        if (conflictExists(rows, x, y)) {
+            return false;
+        }
+    }
+    return true;
+}
+export function addRowSpanCells(table) {
+    table.forEach((row, rowIndex) => {
+        row.forEach((cell) => {
+            for (let i = 1; i < cell.rowSpan; i++) {
+                const rowSpanCell = new RowSpanCell(cell);
+                if (cell.x !== null && cell.y !== null) {
+                    rowSpanCell.x = cell.x;
+                    rowSpanCell.y = cell.y + i;
+                    rowSpanCell.colSpan = cell.colSpan;
+                    insertCell(rowSpanCell, table[rowIndex + i]);
+                }
+            }
+        });
+    });
+}
+export function addColSpanCells(cellRows) {
+    for (let rowIndex = cellRows.length - 1; rowIndex >= 0; rowIndex--) {
+        const cellColumns = cellRows[rowIndex];
+        for (let columnIndex = 0; columnIndex < cellColumns.length; columnIndex++) {
+            const cell = cellColumns[columnIndex];
+            for (let k = 1; k < cell.colSpan; k++) {
+                const colSpanCell = new ColSpanCell();
+                if (cell.x !== null && cell.y !== null) {
+                    colSpanCell.x = cell.x + k;
+                    colSpanCell.y = cell.y;
+                    cellColumns.splice(columnIndex + 1, 0, colSpanCell);
+                }
+            }
+        }
+    }
+}
+export function insertCell(cell, row) {
+    let x = 0;
+    const cellX = cell.x;
+    while (x < row.length) {
+        const rowX = row[x].x;
+        if (rowX === null || cellX === null || rowX >= cellX) {
+            break;
+        }
+        x++;
+    }
+    row.splice(x, 0, cell);
+}
+export function fillInTable(table) {
+    const hMax = maxHeight(table);
+    const wMax = maxWidth(table);
+    debug.debug(`Max rows: ${hMax}; Max cols: ${wMax}`);
+    for (let y = 0; y < hMax; y++) {
+        for (let x = 0; x < wMax; x++) {
+            if (!conflictExists(table, x, y)) {
+                const opts = { x: x, y: y, colSpan: 1, rowSpan: 1 };
+                x++;
+                while (x < wMax && !conflictExists(table, x, y)) {
+                    opts.colSpan++;
+                    x++;
+                }
+                let y2 = y + 1;
+                while (y2 < hMax &&
+                    allBlank(table, y2, opts.x, opts.x + opts.colSpan)) {
+                    opts.rowSpan++;
+                    y2++;
+                }
+                const cell = new Cell({ ...opts, content: "" });
+                cell.x = opts.x;
+                cell.y = opts.y;
+                debug.warn(`Missing cell at ${cell.y}-${cell.x}.`);
+                insertCell(cell, table[y]);
+            }
+        }
+    }
+}
+export function generateCells(rows) {
+    return rows.map((row) => {
+        let processedRow = row;
+        if (!Array.isArray(processedRow)) {
+            const key = Object.keys(processedRow)[0];
+            const rowValue = processedRow[key];
+            if (Array.isArray(rowValue)) {
+                const newRow = rowValue.slice();
+                newRow.unshift(key);
+                processedRow = newRow;
+            }
+            else {
+                processedRow = [key, rowValue];
+            }
+        }
+        return processedRow
+            .filter((cell) => cell !== null && cell !== undefined)
+            .map((cell) => {
+            return new Cell(cell);
+        });
+    });
+}
+export function makeTableLayout(rows) {
+    const cellRows = generateCells(rows);
+    layoutTable(cellRows);
+    fillInTable(cellRows);
+    addRowSpanCells(cellRows);
+    addColSpanCells(cellRows);
+    return cellRows;
+}
+export function makeComputeWidths(colSpan, desiredWidth, x, forcedMin) {
+    return (vals, table) => {
+        const result = [];
+        const spanners = [];
+        const auto = {};
+        table.forEach((row) => {
+            row.forEach((cell) => {
+                if ((cell[colSpan] || 1) > 1) {
+                    spanners.push(cell);
+                }
+                else {
+                    const key = cell[x];
+                    if (key !== null) {
+                        result[key] = Math.max(result[key] || 0, cell[desiredWidth] || 0, forcedMin);
+                    }
+                }
+            });
+        });
+        vals.forEach((val, index) => {
+            if (typeof val === "number") {
+                result[index] = val;
+            }
+        });
+        // spanners.forEach(function(cell){
+        for (let k = spanners.length - 1; k >= 0; k--) {
+            const cell = spanners[k];
+            const span = cell[colSpan];
+            const col = cell[x];
+            if (col === null)
+                continue;
+            let existingWidth = result[col];
+            let editableCols = typeof vals[col] === "number" ? 0 : 1;
+            if (typeof existingWidth === "number") {
+                for (let i = 1; i < span; i++) {
+                    existingWidth += 1 + result[col + i];
+                    if (typeof vals[col + i] !== "number") {
+                        editableCols++;
+                    }
+                }
+            }
+            else {
+                existingWidth =
+                    desiredWidth === "desiredWidth" ? cell.desiredWidth - 1 : 1;
+                if (!auto[col] || auto[col] < existingWidth) {
+                    auto[col] = existingWidth;
+                }
+            }
+            if (cell[desiredWidth] > existingWidth) {
+                let i = 0;
+                while (editableCols > 0 && cell[desiredWidth] > existingWidth) {
+                    if (typeof vals[col + i] !== "number") {
+                        const dif = Math.round((cell[desiredWidth] - existingWidth) / editableCols);
+                        existingWidth += dif;
+                        result[col + i] += dif;
+                        editableCols--;
+                    }
+                    i++;
+                }
+            }
+        }
+        Object.assign(vals, result, auto);
+        for (let j = 0; j < vals.length; j++) {
+            vals[j] = Math.max(forcedMin, vals[j] || 0);
+        }
+    };
+}
+export const computeWidths = makeComputeWidths("colSpan", "desiredWidth", "x", 1);
+export const computeHeights = makeComputeWidths("rowSpan", "desiredHeight", "y", 1);

package/dist/terminal/table/table.d.ts

@@ -0,0 +1,9 @@
+import { type TableConstructorOptions, type TableInstanceOptions } from "./utils.ts";
+export declare class Table extends Array<unknown> {
+    options: TableInstanceOptions;
+    constructor(opts?: TableConstructorOptions);
+    toString(): string;
+    get width(): number;
+    static reset(): void;
+}
+//# sourceMappingURL=table.d.ts.map

package/dist/terminal/table/table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../../source/terminal/table/table.ts"],"names":[],"mappings":"AAOA,OAAO,EAGL,KAAK,uBAAuB,EAC5B,KAAK,oBAAoB,EAC1B,MAAM,YAAY,CAAC;AAEpB,qBAAa,KAAM,SAAQ,KAAK,CAAC,OAAO,CAAC;IACvC,OAAO,EAAE,oBAAoB,CAAC;gBAElB,IAAI,CAAC,EAAE,uBAAuB;IAmCjC,QAAQ,IAAI,MAAM;IAuD3B,IAAI,KAAK,IAAI,MAAM,CAGlB;IAED,MAAM,CAAC,KAAK,IAAI,IAAI;CAGrB"}

package/dist/terminal/table/table.js

@@ -0,0 +1,97 @@
+import debug from "./debug.js";
+import { computeHeights, computeWidths, makeTableLayout, } from "./layout-manager.js";
+import { mergeOptions, } from "./utils.js";
+export class Table extends Array {
+    options;
+    constructor(opts) {
+        super();
+        const options = mergeOptions(opts);
+        this.options = options;
+        Object.defineProperty(this, "options", {
+            value: options,
+            enumerable: Boolean(options.debug),
+        });
+        if (options.debug) {
+            switch (typeof options.debug) {
+                case "boolean":
+                    debug.setDebugLevel(debug.WARN);
+                    break;
+                case "number":
+                    debug.setDebugLevel(options.debug);
+                    break;
+                case "string":
+                    debug.setDebugLevel(Number.parseInt(options.debug, 10));
+                    break;
+                default:
+                    debug.setDebugLevel(debug.WARN);
+                    debug.warn(`Debug option is expected to be boolean, number, or string. Received a ${typeof options.debug}`);
+            }
+            Object.defineProperty(this, "messages", {
+                get() {
+                    return debug.debugMessages();
+                },
+            });
+        }
+    }
+    toString() {
+        let array = this;
+        const headersPresent = this.options.head?.length;
+        if (headersPresent) {
+            array = [this.options.head];
+            if (this.length) {
+                array.push(...this);
+            }
+        }
+        else {
+            this.options.style.head = [];
+        }
+        const cells = makeTableLayout(array);
+        cells.forEach((row) => {
+            row.forEach((cell) => {
+                cell.mergeTableOptions(this.options, cells);
+            }, this);
+        }, this);
+        computeWidths(this.options.colWidths, cells);
+        computeHeights(this.options.rowHeights, cells);
+        cells.forEach((row) => {
+            row.forEach((cell) => {
+                cell.init(this.options);
+            }, this);
+        }, this);
+        const result = [];
+        for (let rowIndex = 0; rowIndex < cells.length; rowIndex++) {
+            const row = cells[rowIndex];
+            const heightOfRow = this.options.rowHeights[rowIndex];
+            if (rowIndex === 0 ||
+                !this.options.style.compact ||
+                (rowIndex === 1 && headersPresent)) {
+                doDraw(row, "top", result);
+            }
+            for (let lineNum = 0; lineNum < (heightOfRow || 0); lineNum++) {
+                doDraw(row, lineNum, result);
+            }
+            if (rowIndex + 1 === cells.length) {
+                doDraw(row, "bottom", result);
+            }
+        }
+        return result.join("\n");
+    }
+    get width() {
+        const str = this.toString().split("\n");
+        return str[0].length;
+    }
+    static reset() {
+        debug.reset();
+    }
+}
+function doDraw(row, lineNum, result) {
+    const line = [];
+    row.forEach((cell) => {
+        if (cell && typeof cell.draw === "function") {
+            line.push(cell.draw(lineNum));
+        }
+    });
+    const str = line.join("");
+    if (str.length)
+        result.push(str);
+}

package/dist/terminal/table/utils.d.ts

@@ -0,0 +1,63 @@
+type CharName = "top" | "topMid" | "topLeft" | "topRight" | "bottom" | "bottomMid" | "bottomLeft" | "bottomRight" | "left" | "leftMid" | "mid" | "midMid" | "right" | "rightMid" | "middle";
+type HorizontalAlignment = "left" | "center" | "right";
+type VerticalAlignment = "top" | "center" | "bottom";
+interface TableOptions {
+    truncate: string;
+    colWidths: Array<number | null>;
+    rowHeights: Array<number | null>;
+    colAligns: HorizontalAlignment[];
+    rowAligns: VerticalAlignment[];
+    head: Cell[];
+    wordWrap: boolean;
+    wrapOnWordBoundary: boolean;
+    textWrap?: boolean;
+}
+interface TableInstanceOptions extends TableOptions {
+    chars: Record<CharName, string>;
+    style: {
+        "padding-left": number;
+        "padding-right": number;
+        head: string[];
+        border: string[];
+        compact: boolean;
+    };
+    debug?: boolean | number | string;
+}
+interface TableConstructorOptions extends Partial<TableOptions> {
+    chars?: Partial<Record<CharName, string>>;
+    style?: Partial<TableInstanceOptions["style"]>;
+}
+type CellValue = boolean | number | bigint | string | null | undefined;
+interface CellOptions {
+    content: CellValue;
+    chars?: Partial<Record<CharName, string>>;
+    truncate?: string;
+    colSpan?: number;
+    rowSpan?: number;
+    hAlign?: HorizontalAlignment;
+    vAlign?: VerticalAlignment;
+    wordWrap?: boolean;
+    wrapOnWordBoundary?: boolean;
+    href?: string;
+    style?: {
+        "padding-left"?: number;
+        "padding-right"?: number;
+        head?: string[];
+        border?: string[];
+    };
+}
+type Cell = CellValue | CellOptions;
+export declare function strlen(str: string): number;
+export declare function repeat(str: string, times: number): string;
+export declare function pad(str: string, len: number, padChar: string, dir: HorizontalAlignment): string;
+export declare function truncate(str: string, desiredLength: number, truncateChar?: string): string;
+export declare function defaultOptions(): TableInstanceOptions;
+export declare function mergeOptions(options?: Partial<TableConstructorOptions>, defaults?: TableInstanceOptions): TableInstanceOptions;
+export declare function multiLineWordWrap(maxLength: number, input: string, wrapOnWordBoundary?: boolean): string[];
+export declare function colorizeLines(input: string[]): string[];
+/**
+ * Credit: Matheus Sampaio https://github.com/matheussampaio
+ */
+export declare function hyperlink(url: string, text: string): string;
+export type { CharName, HorizontalAlignment, VerticalAlignment, TableInstanceOptions, TableConstructorOptions, CellOptions, Cell, };
+//# sourceMappingURL=utils.d.ts.map

package/dist/terminal/table/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../source/terminal/table/utils.ts"],"names":[],"mappings":"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"}