@simplrjs/markdown/dist/generators/table-generator.js

"use strict";
var __assign = (this && this.__assign) || Object.assign || function(t) {
    for (var s, i = 1, n = arguments.length; i < n; i++) {
        s = arguments[i];
        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
            t[p] = s[p];
    }
    return t;
};
Object.defineProperty(exports, "__esModule", { value: true });
var S = require("string");
var helpers_1 = require("../utils/helpers");
var TableGenerator;
(function (TableGenerator) {
    function RenderTable(headers, content, options) {
        var resolvedOptions = __assign({ escapePipeChar: "&#124;" }, options);
        var patternToEscape = /\|/g;
        // Escape
        if (resolvedOptions.escapePipeChar != null) {
            var escapePipeChar_1 = resolvedOptions.escapePipeChar;
            // Headers
            headers = headers.map(function (header) {
                if (typeof header === "string") {
                    return header.replace(patternToEscape, escapePipeChar_1);
                }
                else {
                    return __assign({}, header, { text: header.text.replace(patternToEscape, escapePipeChar_1) });
                }
            });
            // Content
            content = content.map(function (x) { return x.map(function (y) { return y.replace(patternToEscape, resolvedOptions.escapePipeChar); }); });
        }
        var columnsWidths = [];
        var removeColumnIfEmpty = options != null && options.removeColumnIfEmpty;
        var removeRowIfEmpty = options != null && options.removeRowIfEmpty;
        var filledRows = content.map(function (row) {
            if (row.length < headers.length) {
                return helpers_1.Helpers.FillArray(row, headers.length, "");
            }
            else {
                return row;
            }
        });
        // Removing empty rows if option `removeRowIfEmpty` enabled.
        if (removeRowIfEmpty) {
            filledRows = filledRows.filter(function (row) { return !row.every(function (cell) { return cell.length === 0; }); });
        }
        // Indexes of empty columns, that should be removed.
        var columnsToRemove = [];
        // Filling columns widths.
        headers.forEach(function (header, index) {
            // Getting rows of a single column
            var rows = filledRows.map(function (x) { return x[index]; });
            columnsWidths[index] = GetMaxColumnWidth(GetHeaderText(header), rows, removeColumnIfEmpty);
            if (removeColumnIfEmpty && columnsWidths[index] === 0) {
                columnsToRemove.push(index);
            }
        });
        // Removing unnecessary columns.
        var finalHeaders = headers.filter(function (x, index) { return columnsToRemove.indexOf(index) === -1; });
        var finalRows = filledRows.map(function (row) { return row.filter(function (x, index) { return columnsToRemove.indexOf(index) === -1; }); });
        var finalColumnsWidths = columnsWidths.filter(function (x, index) { return columnsToRemove.indexOf(index) === -1; });
        var lines = RenderTableHeader(finalHeaders, finalColumnsWidths).concat(RenderTableContents(finalRows, finalColumnsWidths));
        return lines;
    }
    TableGenerator.RenderTable = RenderTable;
    function RenderTableHeader(headers, columnsWidths) {
        // | Header | Header2 |
        var tableHeader = "";
        // | ------ | ------- |
        var headerSeparator = "";
        headers.forEach(function (header, headerIndex) {
            var columnWidth = columnsWidths[headerIndex];
            var columnAlign = GetHeaderAlign(header);
            var isLast = (headerIndex + 1 === headers.length);
            tableHeader += RenderCell(GetHeaderText(header), columnWidth, isLast);
            var columnAlignText;
            switch (columnAlign) {
                case "left": {
                    // :----
                    columnAlignText = S(":").padRight(columnWidth, "-").s;
                    break;
                }
                case "right": {
                    // ----:
                    columnAlignText = S(":").padLeft(columnWidth, "-").s;
                    break;
                }
                case "center":
                    // :---:
                    columnAlignText = S(":").padRight(columnWidth, "-").s;
                    columnAlignText = columnAlignText.slice(0, -1) + ":";
                    break;
                case "none":
                default: {
                    columnAlignText = S("-").repeat(columnWidth).s;
                }
            }
            headerSeparator += RenderCell(columnAlignText, columnWidth, isLast);
        });
        return [
            tableHeader,
            headerSeparator
        ];
    }
    TableGenerator.RenderTableHeader = RenderTableHeader;
    function RenderTableContents(content, columnsWidths) {
        return content.map(function (row) {
            var rowText = "";
            row.forEach(function (column, columnIndex) {
                var columnWidth = columnsWidths[columnIndex];
                var isLast = (columnIndex + 1 === row.length);
                rowText += RenderCell(column, columnWidth, isLast);
            });
            return rowText;
        });
    }
    TableGenerator.RenderTableContents = RenderTableContents;
    function RenderCell(text, width, close) {
        var sanitizedText = S(text).trim().s;
        var cell = "| " + S(sanitizedText).padRight(width).s + " ";
        if (close) {
            cell += "|";
        }
        return cell;
    }
    TableGenerator.RenderCell = RenderCell;
    function GetHeaderText(header) {
        var headerText;
        if (typeof header === "string") {
            headerText = header;
        }
        else {
            headerText = header.text;
        }
        return headerText;
    }
    TableGenerator.GetHeaderText = GetHeaderText;
    function GetHeaderAlign(header) {
        if (typeof header === "string") {
            return "none";
        }
        else {
            return header.align;
        }
    }
    TableGenerator.GetHeaderAlign = GetHeaderAlign;
    function GetMaxColumnWidth(headerText, rows, removeIfEmpty) {
        var maxWidth = 0;
        rows.forEach(function (x) {
            if (x != null && x.length > maxWidth) {
                maxWidth = x.length;
            }
        });
        if (maxWidth !== 0 || !removeIfEmpty) {
            if (headerText.length > maxWidth) {
                return headerText.length;
            }
        }
        return maxWidth;
    }
    TableGenerator.GetMaxColumnWidth = GetMaxColumnWidth;
})(TableGenerator = exports.TableGenerator || (exports.TableGenerator = {}));
//# sourceMappingURL=table-generator.js.map