123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338
import { encode } from 'https://deno.land/std@v0.61.0/encoding/utf8.ts';import { border } from './border.ts';import { Cell, ICell } from './cell.ts';import { CELL_PADDING, MAX_CELL_WIDTH, MIN_CELL_WIDTH } from './const.ts';import { IRow, Row } from './row.ts';import { consumeWords, longest, stripeColors } from './utils.ts';
export interface ITableOptions {    indent?: number;    border?: boolean;    maxCellWidth?: number | number[];    minCellWidth?: number | number[];    padding?: number | number[];}
export type ITable = IRow[] | Table;
export interface ICalc {    padding: number[],    width: number[],    columns: number}
export class Table extends Array<IRow> {
    protected options: ITableOptions = {};
    public static from( rows: ITable ): Table {        const table = new Table( ...rows.map( cells => [ ...cells ] ) );        if ( rows instanceof Table ) {            table.options = Object.create( rows.options );        }        return table;    }
    public static render( rows: ITable ): void {        Table.from( rows ).render();    }
    public render(): void {        Deno.stdout.writeSync( encode( this.toString() ) );    }
    /**     * Calc:     */
    protected calc(): ICalc {
        const padding: number[] = [];        const width: number[] = [];
        const columns: number = Math.max( ...this.map( row => Object.keys( row ).length ) );
        for ( let colIndex: number = 0; colIndex < columns; colIndex++ ) {

            let minCellWidth: number = Array.isArray( this.options.minCellWidth ) ? this.options.minCellWidth[ colIndex ] :                ( typeof this.options.minCellWidth === 'undefined' ? MIN_CELL_WIDTH : this.options.minCellWidth );
            let maxCellWidth: number = Array.isArray( this.options.maxCellWidth ) ? this.options.maxCellWidth[ colIndex ] :                ( typeof this.options.maxCellWidth === 'undefined' ? MAX_CELL_WIDTH : this.options.maxCellWidth );
            padding[ colIndex ] = Array.isArray( this.options.padding ) ? this.options.padding[ colIndex ] :                ( typeof this.options.padding === 'undefined' ? CELL_PADDING : this.options.padding );
            let cellWidth: number = longest( colIndex, this, maxCellWidth );            // let cellWidth: number = longest( colIndex, this );            width[ colIndex ] = Math.min( maxCellWidth, Math.max( minCellWidth, cellWidth ) );        }
        return { padding, width, columns };    }
    protected getRows(): Row<Cell>[] {
        return this.map( ( iRow: IRow ) => {
            const row: Row = Row.from( iRow );
            if ( this.options.border ) {                row.border( this.options.border, false );            }
            row.forEach( ( iCell: ICell, i: number ) => {                const cell = Cell.from( iCell );                if ( row.getBorder() ) {                    cell.border( row.getBorder() as boolean, false );                }                row[ i ] = cell;            } );
            return row as Row<Cell>;        } );    }
    /**     * Render:     */
    public toString(): string {
        const calc: ICalc = this.calc();        const rows: Row<Cell>[] = this.getRows();
        return this.renderRows( calc, rows );    }
    protected renderRows( opts: ICalc, rows: Row<Cell>[], _rowGroupIndex: number = 0 ) {
        let result: string = '';
        result += this.renderRow( rows[ _rowGroupIndex ], rows[ _rowGroupIndex - 1 ], rows[ _rowGroupIndex + 1 ], opts, _rowGroupIndex );
        if ( _rowGroupIndex < this.length - 1 ) {            result += this.renderRows( opts, rows, ++_rowGroupIndex );        }
        return result;    }
    protected renderRow( row: Row<Cell>, prevRow: Row<Cell> | undefined, nextRow: Row<Cell> | undefined, opts: ICalc, _rowGroupIndex: number = 0, _rowIndex: number = 0 ): string {
        let result: string = '';
        if ( row.getBorder() && _rowGroupIndex === 0 && _rowIndex === 0 ) {            result += this.renderBorderTopRow( row, prevRow, nextRow, opts );        }
        const { cells, isMultilineRow } = this.renderCells( row, opts );
        result += cells;
        if ( isMultilineRow ) {            result += this.renderRow( row, prevRow, nextRow, opts, _rowGroupIndex, ++_rowIndex );        } else if ( _rowGroupIndex < this.length - 1 ) {            if ( row.getBorder() ) {                result += this.renderBorderMidRow( row, prevRow, nextRow, opts );            }        } else if ( _rowGroupIndex === this.length - 1 ) {            if ( row.getBorder() ) {                result += this.renderBorderBottomRow( row, prevRow, nextRow, opts );            }        } else {            throw new Error( `Invalid row index: ${ _rowGroupIndex }` );        }
        return result;    }
    protected renderCells( row: Row<Cell>, opts: ICalc ) {
        let cells: string = ' '.repeat( this.options.indent || 0 );        let isMultilineRow: boolean = false;
        const rowCount = row.length;        let prev: Cell | undefined;
        for ( let i = 0; i < rowCount; i++ ) {
            const cell: Cell = row[ i ];
            if ( i === 0 ) {                if ( cell.getBorder() ) {                    cells += border.left;                } else {                    // cells += ' ';                }            }
            const { current, next } = this.renderCell( cell, opts.width[ i ] );
            // it's required to call explicilty .length because next is a String class and not a string type.            next.length && ( isMultilineRow = true );            row[ i ] = next;
            if ( i > 0 ) {                if ( cell.getBorder() && ( !prev || prev.getBorder() ) ) {                    cells += border.middle;                } else {                    // cells += ' ';                }            }
            if ( cell.getBorder() ) {                cells += ' '.repeat( opts.padding[ i ] );            }
            cells += current;
            if ( cell.getBorder() || i < rowCount - 1 ) {                cells += ' '.repeat( opts.padding[ i ] );            }
            if ( i === rowCount - 1 ) {                if ( cell.getBorder() ) {                    cells += border.right;                } else {                    // cells += ' ';                }            }
            prev = cell;        }

        cells += '\n';
        return { cells, isMultilineRow };    }
    protected renderCell( cell: Cell, maxLength: number ): { current: string, next: Cell } {
        const length: number = Math.min( maxLength, stripeColors( cell.toString() ).length );        let words: string = consumeWords( length, cell.toString() );
        // break word if word is longer than max length        const breakWord = stripeColors( words ).length > length;        if ( breakWord ) {            words = words.slice( 0, length );        }
        // get next content and remove leading space if breakWord is not true        const next = cell.slice( words.length + ( breakWord ? 0 : 1 ) );        const fillLength = maxLength - stripeColors( words ).length;        const current = words + ' '.repeat( fillLength );
        return {            current,            next: cell.clone( next )        };    }
    /**     * Border:     */
    protected renderBorderTopRow( row: Row<Cell>, prevRow: Row<Cell> | undefined, nextRow: Row<Cell> | undefined, opts: ICalc ): string {
        let cells = [];
        for ( let i = 0; i < opts.columns; i++ ) {            const cell: Cell = row[ i ];            cells.push( ( cell.getBorder() ? border.top : ' ' ).repeat( opts.padding[ i ] + opts.width[ i ] + opts.padding[ i ] ) );        }
        return ' '.repeat( this.options.indent || 0 ) + border.topLeft + cells.join( border.topMid ) + ( border.topRight ) + '\n';    }
    protected renderBorderMidRow( row: Row<Cell>, prevRow: Row<Cell> | undefined, nextRow: Row<Cell> | undefined, opts: ICalc ): string {
        let cells = [];
        for ( let i = 0; i < opts.columns; i++ ) {            const cell: Cell = row[ i ];            const nextCell = nextRow && nextRow[ i ];            cells.push( ( cell.getBorder() && nextCell?.getBorder() !== false ? border.mid : ' ' ).repeat( opts.padding[ i ] + opts.width[ i ] + opts.padding[ i ] ) );        }
        return ' '.repeat( this.options.indent || 0 ) + border.leftMid + cells.join( border.midMid ) + ( border.rightMid ) + '\n';    }
    protected renderBorderBottomRow( row: Row<Cell>, prevRow: Row<Cell> | undefined, nextRow: Row<Cell> | undefined, opts: ICalc ): string {
        let cells = [];
        for ( let i = 0; i < opts.columns; i++ ) {            const cell: Cell = row[ i ];            cells.push( ( cell.getBorder() ? border.bottom : ' ' ).repeat( opts.padding[ i ] + opts.width[ i ] + opts.padding[ i ] ) );        }
        return ' '.repeat( this.options.indent || 0 ) + border.bottomLeft + cells.join( border.bottomMid ) + ( border.bottomRight ) + '\n';    }
    /**     * Setter:     */
    public indent( width: number, override: boolean = true ): this {        if ( override || typeof this.options.indent === 'undefined' ) {            this.options.indent = width;        }        return this;    }
    public maxCellWidth( width: number | number[], override: boolean = true ): this {        if ( override || typeof this.options.maxCellWidth === 'undefined' ) {            this.options.maxCellWidth = width;        }        return this;    }
    public minCellWidth( width: number | number[], override: boolean = true ): this {        if ( override || typeof this.options.minCellWidth === 'undefined' ) {            this.options.minCellWidth = width;        }        return this;    }
    public padding( padding: number | number[], override: boolean = true ): this {        if ( override || typeof this.options.padding === 'undefined' ) {            this.options.padding = padding;        }        return this;    }
    public border( enable: boolean, override: boolean = true ): this {        if ( override || typeof this.options.border === 'undefined' ) {            this.options.border = enable;        }        return this;    }
    /**     * Getter:     */
    public getIndent( defaultValue?: number ): number | undefined {        return this.options.indent ?? defaultValue;    }
    public getMaxCellWidth( defaultValue?: number | number[] ): number | number[] | undefined {        return this.options.maxCellWidth ?? defaultValue;    }
    public getMinCellWidth( defaultValue?: number | number[] ): number | number[] | undefined {        return this.options.minCellWidth ?? defaultValue;    }
    public getPadding( defaultValue?: number | number[] ): number | number[] | undefined {        return this.options.padding ?? defaultValue;    }
    public getBorder( defaultValue?: boolean ): boolean | undefined {        return this.options.border ?? defaultValue;    }}