svg-table 0.0.1

package/dist/tableStyler.js

@@ -0,0 +1,665 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __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;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableStyler = exports.StyledTable = void 0;
+var tableData_1 = require("./tableData");
+var data_frame_ts_1 = require("data-frame-ts");
+var result_fn_1 = require("result-fn");
+var stylings_1 = require("./stylings");
+/**
+ * Represents a table with applied styles.
+ * Provides methods to access the styling information for different parts of the table.
+ */
+var StyledTable = /** @class */ (function () {
+    /**
+     * Creates a new StyledTable instance.
+     * @param dataFrame The data frame containing the table data
+     * @param font The font settings for the table
+     * @param border The border settings for the table
+     * @param background The background settings for the table
+     * @param dimension The dimension settings for the table
+     * @param padding The padding settings for the table
+     * @param margin The margin settings for the table
+     */
+    function StyledTable(dataFrame, font, border, background, dimension, padding, margin) {
+        this.dataFrame = dataFrame;
+        this.font = font;
+        this.border = border;
+        this.background = background;
+        this.dimension = dimension;
+        this.padding = padding;
+        this.margin = margin;
+    }
+    /**
+     * @return A copy of the {@link DataFrame} with all the styling and formatting tags
+     */
+    StyledTable.prototype.data = function () {
+        return this.dataFrame.copy();
+    };
+    StyledTable.prototype.tableData = function () {
+        // fromDataFrame makes a copy of the data frame
+        return tableData_1.TableData.fromDataFrame(this.dataFrame);
+    };
+    /**
+     * Returns the font settings for the table.
+     * @returns A copy of the table's font settings
+     */
+    StyledTable.prototype.tableFont = function () {
+        return __assign({}, this.font);
+    };
+    /**
+     * Returns the border settings for the table.
+     * @returns A copy of the table's border settings
+     */
+    StyledTable.prototype.tableBorder = function () {
+        return __assign({}, this.border);
+    };
+    /**
+     * Returns the background settings for the table.
+     * @returns A copy of the table's background settings
+     */
+    StyledTable.prototype.tableBackground = function () {
+        return __assign({}, this.background);
+    };
+    /**
+     * Returns the dimension settings for the table.
+     * @returns A copy of the table's dimension settings
+     */
+    StyledTable.prototype.tableDimensions = function () {
+        return __assign({}, this.dimension);
+    };
+    /**
+     * Returns the padding settings for the table.
+     * @returns A copy of the table's padding settings
+     */
+    StyledTable.prototype.tablePadding = function () {
+        return __assign({}, this.padding);
+    };
+    /**
+     * Returns the margin settings for the table.
+     * @returns A copy of the table's margin settings
+     */
+    StyledTable.prototype.tableMargin = function () {
+        return __assign({}, this.margin);
+    };
+    /**
+     * Retrieves styling tags for a specific column.
+     * @param columnIndex The index of the column
+     * @param tagStyleType The type of style tag to retrieve
+     * @returns A Result containing the tag if found, or an error message
+     * @private
+     */
+    StyledTable.prototype.columnTagsFor = function (columnIndex, tagStyleType) {
+        // find all the tags and type them to row-header tags
+        var tags = this.dataFrame
+            .columnTagsFor(columnIndex)
+            .filter(function (tag) { return tag.matchesId(tagStyleType, data_frame_ts_1.ColumnCoordinate.of(columnIndex)); })
+            .map(function (tag) { return tag; });
+        if (tags.length === 0) {
+            return (0, result_fn_1.failureResult)("(StyledTable::columnTagsFor) No matching column-style tags found for table; column_index: ".concat(columnIndex, "; tag_type: ").concat(tagStyleType));
+        }
+        // when there are more than one tag representing the row-header style, then sort based on priority and
+        // take the first one
+        if (tags.length > 1) {
+            tags.sort(function (tagA, tagB) { return tagB.value.priority - tagA.value.priority; });
+        }
+        return (0, result_fn_1.successResult)(tags[0]);
+    };
+    /**
+     * Retrieves styling tags for a specific row.
+     * @param rowIndex The index of the row
+     * @param tagStyleType The type of style tag to retrieve (can be more than one)
+     * @returns A Result containing the tag if found, or an error message
+     * @private
+     */
+    StyledTable.prototype.rowTagsFor = function (rowIndex) {
+        var tagStyleType = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            tagStyleType[_i - 1] = arguments[_i];
+        }
+        // find all the tags and type them to column-header tags
+        var tags = this.dataFrame
+            .rowTagsFor(rowIndex)
+            .filter(function (tag) { return tagStyleType.filter(function (styleType) { return tag.matchesId(styleType, data_frame_ts_1.RowCoordinate.of(rowIndex)); }).length > 0; })
+            .map(function (tag) { return tag; });
+        if (tags.length === 0) {
+            return (0, result_fn_1.failureResult)("(StyledTable::rowTagsFor) No matching row-style tags found for table; row_index: ".concat(rowIndex, "; tag_type: ").concat(tagStyleType));
+        }
+        // when there are more than one tag representing the column-header, the sort based on the priority and
+        // take the first one
+        if (tags.length > 1) {
+            tags.sort(function (tagA, tagB) { return tagB.value.priority - tagA.value.priority; });
+        }
+        return (0, result_fn_1.successResult)(tags[0]);
+    };
+    StyledTable.prototype.hasRowHeader = function () {
+        return tableData_1.TableData.hasRowHeader(this.dataFrame);
+    };
+    StyledTable.prototype.hasColumnHeader = function () {
+        return tableData_1.TableData.hasColumnHeader(this.dataFrame);
+    };
+    StyledTable.prototype.hasFooter = function () {
+        return tableData_1.TableData.hasFooter(this.dataFrame);
+    };
+    /**
+     * Gets the style for the row header.
+     * @returns A Result containing the row header style if found, or an error message
+     */
+    StyledTable.prototype.rowHeaderStyle = function () {
+        if (!tableData_1.TableData.hasRowHeader(this.dataFrame)) {
+            return (0, result_fn_1.failureResult)("(StyledTable::rowHeaderStyle) The table data does not have a row header");
+        }
+        return this
+            .columnTagsFor(0, stylings_1.TableStyleType.ROW_HEADER)
+            .map(function (tag) { return tag.value; });
+    };
+    /**
+     * Gets the style for the column header.
+     * @returns A Result containing the column header style if found, or an error message
+     */
+    StyledTable.prototype.columnHeaderStyle = function () {
+        if (!tableData_1.TableData.hasColumnHeader(this.dataFrame)) {
+            return (0, result_fn_1.failureResult)("(StyledTable::columnHeaderStyle) The table data does not have a column header");
+        }
+        return this
+            .rowTagsFor(0, stylings_1.TableStyleType.COLUMN_HEADER)
+            .map(function (tag) { return tag.value; });
+    };
+    StyledTable.prototype.footerStyle = function () {
+        if (!tableData_1.TableData.hasFooter(this.dataFrame)) {
+            return (0, result_fn_1.failureResult)("(StyledTable::footerStyle) The table data does not have a footer");
+        }
+        return this
+            .rowTagsFor(this.dataFrame.rowCount() - 1, stylings_1.TableStyleType.FOOTER)
+            .map(function (tag) { return tag.value; });
+    };
+    /**
+     * Gets the style for a specific row.
+     * @param rowIndex The index of the row
+     * @returns A Result containing the row style if found, or an error message
+     */
+    StyledTable.prototype.rowStyleFor = function (rowIndex) {
+        return this
+            .rowTagsFor(rowIndex, stylings_1.TableStyleType.ROW)
+            .map(function (tag) { return tag.value; });
+    };
+    /**
+     * Gets the style for a specific column.
+     * @param columnIndex The index of the column
+     * @returns A Result containing the column style if found, or an error message
+     */
+    StyledTable.prototype.columnStyleFor = function (columnIndex) {
+        return this
+            .columnTagsFor(columnIndex, stylings_1.TableStyleType.COLUMN)
+            .map(function (tag) { return tag.value; });
+    };
+    /**
+     * Gets the style for a specific cell.
+     * @param rowIndex The row index of the cell
+     * @param columnIndex The column index of the cell
+     * @returns A Result containing the cell style if found, or an error message
+     */
+    StyledTable.prototype.cellStyleFor = function (rowIndex, columnIndex) {
+        // find all the tags and type them to column-header tags
+        var tags = this.dataFrame
+            .cellTagsFor(rowIndex, columnIndex)
+            .filter(function (tag) { return tag.matchesId(stylings_1.TableStyleType.CELL, data_frame_ts_1.CellCoordinate.of(rowIndex, columnIndex)); })
+            .map(function (tag) { return tag; });
+        if (tags.length === 0) {
+            return (0, result_fn_1.failureResult)("(StyledTable::cellStyleFor) No matching cell-style tags found for table; row_index: ".concat(rowIndex, "; column_index: ").concat(columnIndex));
+        }
+        // when there are more than one tag representing the column-header, the sort based on the priority and
+        // take the first one
+        if (tags.length > 1) {
+            tags.sort(function (tagA, tagB) { return tagB.value.priority - tagA.value.priority; });
+        }
+        return (0, result_fn_1.successResult)(tags[0].value);
+    };
+    /**
+     * Unlike the methods that retrieve the particular styles, say for a cell, a column header,
+     * and so forth, this method returns a {@link CellStyle} calculated from all the styles
+     * that apply to the specified cell by using the style properties with the highest priority.
+     * <p>
+     * Retrieves the styles to be applied to a specific data cell in the table. This method
+     * accounts for column headers, row headers, and footers. For example, regardless of whether the
+     * table has a column header, a row index of 0 refers to the first row of data. And
+     * regardless of whether the table has a row header, a column index of 0 refers to the
+     * first column of data.
+     *
+     * @param rowIndex - The index of the row in the table data for which styles are required.
+     * Must be within the valid row index range.
+     * @param columnIndex - The index of the column in the table data for which styles are required.
+     * Must be within the valid column index range.
+     * @return A result object containing the cell style if the indices are valid, or an error
+     * message if they are not.
+     */
+    StyledTable.prototype.stylesForDataCoordinates = function (rowIndex, columnIndex) {
+        if (rowIndex < 0 || rowIndex >= tableData_1.TableData.dataRowCount(this.dataFrame) ||
+            columnIndex < 0 || columnIndex >= tableData_1.TableData.dataColumnCount(this.dataFrame)) {
+            return (0, result_fn_1.failureResult)("(StyledTable::dataCellStyles) Invalid row and/or column index for data; row_index".concat(rowIndex) +
+                "; column_index: ".concat(columnIndex) +
+                "; valid_row_index: [0, ".concat(tableData_1.TableData.dataRowCount(this.dataFrame), ")") +
+                "; valid_column_index: [0, ".concat(tableData_1.TableData.dataColumnCount(this.dataFrame), ")") +
+                "; has_column_header: ".concat(tableData_1.TableData.hasColumnHeader(this.dataFrame)) +
+                "; has_row_header: ".concat(tableData_1.TableData.hasRowHeader(this.dataFrame)) +
+                "; has_footer: ".concat(tableData_1.TableData.hasFooter(this.dataFrame)));
+        }
+        var columnHeaderOffset = tableData_1.TableData.hasColumnHeader(this.dataFrame) ? 1 : 0;
+        var rowHeaderOffset = tableData_1.TableData.hasRowHeader(this.dataFrame) ? 1 : 0;
+        return this.stylesForTableCoordinates(rowIndex + columnHeaderOffset, columnIndex + rowHeaderOffset);
+    };
+    /**
+     * Unlike the methods that retrieve the particular styles, say for a cell, a column header,
+     * and so forth, this method returns a {@link CellStyle} calculated from all the styles
+     * that apply to the specified cell by using the style properties with the highest priority.
+     * <p>
+     * Calculates the style for the cell based on the styles applied to the table and their
+     * relative priority. The row and column indexes refer to the entire table and do not account
+     * for column headers, row headers, or footers.
+     * @param rowIndex The index of the row in the entire table. For example, if the table has column
+     * headers, then a rowIndex of 0 would be that column header.
+     * @param columnIndex The index of the column in the entire table. For example, if the table has
+     * row headers, then a column index of 0 would be the row header
+     * @return A {@link Result} holding the {@link CellStyle}; or a failure {@link Result} if the
+     * row or column indexes are out of range.
+     * @see stylesForDataCoordinates
+     */
+    StyledTable.prototype.stylesForTableCoordinates = function (rowIndex, columnIndex) {
+        if (rowIndex < 0 || rowIndex >= this.dataFrame.rowCount() || columnIndex < 0 || columnIndex >= this.dataFrame.columnCount()) {
+            return (0, result_fn_1.failureResult)("(StyledTable::stylesFor) Invalid row and/or column index" +
+                "; row_index: ".concat(rowIndex) +
+                "; column_index: ".concat(columnIndex) +
+                "; valid_row_index: [0, ".concat(this.dataFrame.rowCount(), ")") +
+                "; valid_column_index: [0, ".concat(this.dataFrame.columnCount(), ")"));
+        }
+        //
+        // determine what styles may be available
+        var availableStyling = [];
+        if (rowIndex === 0) {
+            this.columnHeaderStyle().onSuccess(function (styling) { return availableStyling.push(styling); });
+        }
+        if (columnIndex === 0) {
+            this.rowHeaderStyle().onSuccess(function (styling) { return availableStyling.push(styling); });
+        }
+        if (rowIndex === this.dataFrame.rowCount() - 1) {
+            this.footerStyle().onSuccess(function (styling) { return availableStyling.push(styling); });
+        }
+        this.rowStyleFor(rowIndex).onSuccess(function (styling) { return availableStyling.push(styling); });
+        this.columnStyleFor(columnIndex).onSuccess(function (styling) { return availableStyling.push(styling); });
+        // the cell style is handled differently when it doesn't exist because we need a default set of
+        // values for the cell style in case not all properties are found in the available styles
+        this.cellStyleFor(rowIndex, columnIndex)
+            .onSuccess(function (styling) { return availableStyling.push(styling); })
+            .onFailure(function () { return availableStyling.push({ style: stylings_1.defaultCellStyle, priority: -1 }); });
+        //
+        // calculate the style for the cell based on the priorities and available styles
+        var cellStyle = availableStyling
+            .sort(function (stylingA, stylingB) { return stylingA.priority - stylingB.priority; })
+            .reduce(function (style, curr) { return ({
+            font: (curr.style.hasOwnProperty('font') ?
+                // @ts-ignore
+                __assign(__assign({}, style.font), curr.style.font) : (style.hasOwnProperty('font') ? __assign({}, style.font) : stylings_1.defaultTableFont)),
+            alignText: (curr.style.hasOwnProperty('alignText') ?
+                // @ts-ignore
+                curr.style.alignText : (style.hasOwnProperty('alignText') ? style.alignText : stylings_1.defaultColumnStyle.alignText)),
+            verticalAlignText: (curr.style.hasOwnProperty('verticalAlignText') ?
+                // @ts-ignore
+                curr.style.verticalAlignText : (style.hasOwnProperty('verticalAlignText') ? style.verticalAlignText : stylings_1.defaultColumnStyle.verticalAlignText)),
+            background: (curr.style.hasOwnProperty('background') ?
+                // @ts-ignore
+                __assign(__assign({}, style.background), curr.style.background) : (style.hasOwnProperty('background') ? style.background : stylings_1.defaultTableBackground)),
+            dimension: (curr.style.hasOwnProperty('dimension') ?
+                // @ts-ignore
+                __assign(__assign({}, style.dimension), curr.style.dimension) : (style.hasOwnProperty('dimension') ? __assign({}, style.dimension) : stylings_1.defaultDimension)),
+            padding: (curr.style.hasOwnProperty('padding') ?
+                // @ts-ignore
+                __assign(__assign({}, style.padding), curr.style.padding) : (style.hasOwnProperty('padding') ? __assign({}, style.padding) : stylings_1.defaultTablePadding)),
+            border: (curr.style.hasOwnProperty('border') ?
+                // @ts-ignore
+                __assign(__assign({}, style.border), curr.style.border) : (style.hasOwnProperty('border') ? __assign({}, style.border) : stylings_1.defaultBorder)),
+        }); }, stylings_1.defaultCellStyle);
+        return (0, result_fn_1.successResult)(cellStyle);
+    };
+    return StyledTable;
+}());
+exports.StyledTable = StyledTable;
+/**
+ * Builder class for creating styled tables.
+ * Provides methods to configure various styling aspects of a table.
+ */
+var TableStyler = /** @class */ (function () {
+    /**
+     * Private constructor to enforce factory method usage.
+     * @param dataFrame The data frame containing the table data
+     * @param font The font settings for the table
+     * @param border The border settings for the table
+     * @param background The background settings for the table
+     * @param dimension The dimension settings for the table
+     * @param padding The padding settings for the table
+     * @param margin The margin settings for the table
+     * @param errors Array to collect error messages during styling operations
+     */
+    function TableStyler(dataFrame, font, border, background, dimension, padding, margin, errors) {
+        if (font === void 0) { font = stylings_1.defaultTableFont; }
+        if (border === void 0) { border = stylings_1.defaultBorder; }
+        if (background === void 0) { background = stylings_1.defaultTableBackground; }
+        if (dimension === void 0) { dimension = { width: NaN, height: NaN }; }
+        if (padding === void 0) { padding = stylings_1.defaultTablePadding; }
+        if (margin === void 0) { margin = stylings_1.defaultTableMargin; }
+        if (errors === void 0) { errors = []; }
+        this.dataFrame = dataFrame;
+        this.font = font;
+        this.border = border;
+        this.background = background;
+        this.dimension = dimension;
+        this.padding = padding;
+        this.margin = margin;
+        this.errors = errors;
+    }
+    /**
+     * Creates a TableStyler from a TableData object.
+     * @param tableData The TableData object to style
+     * @returns A new TableStyler instance
+     */
+    TableStyler.fromTableData = function (tableData) {
+        return new TableStyler(tableData.unwrapDataFrame());
+    };
+    /**
+     * Creates a TableStyler from a DataFrame object.
+     * @param dataFrame The DataFrame object to style
+     * @returns A new TableStyler instance
+     */
+    TableStyler.fromDataFrame = function (dataFrame) {
+        return new TableStyler(dataFrame.copy());
+    };
+    /**
+     * Creates a copy of this TableStyler instance.
+     * @returns A new TableStyler instance with the same properties
+     */
+    TableStyler.prototype.copy = function () {
+        return new TableStyler(this.dataFrame, this.font, this.border, this.background, this.dimension, this.padding, this.margin, this.errors);
+    };
+    /**
+     * Creates a new TableStyler with updated properties.
+     * @param properties Partial properties to update
+     * @returns A new TableStyler instance with updated properties
+     */
+    TableStyler.prototype.update = function (properties) {
+        var _a = properties.dataFrame, dataFrame = _a === void 0 ? this.dataFrame : _a, _b = properties.font, font = _b === void 0 ? this.font : _b, _c = properties.border, border = _c === void 0 ? this.border : _c, _d = properties.background, background = _d === void 0 ? this.background : _d, _e = properties.dimension, dimension = _e === void 0 ? this.dimension : _e, _f = properties.padding, padding = _f === void 0 ? this.padding : _f, _g = properties.margin, margin = _g === void 0 ? this.margin : _g;
+        return new TableStyler(dataFrame, font, border, background, dimension, padding, margin, this.errors);
+    };
+    TableStyler.prototype.withTableFont = function (font) {
+        var builder = this.copy();
+        builder.font = __assign(__assign({}, stylings_1.defaultTableFont), font);
+        return builder;
+    };
+    /**
+     * Sets the background for the table.
+     * @param background The background settings to apply
+     * @returns A new TableStyler instance with the updated background
+     */
+    TableStyler.prototype.withTableBackground = function (background) {
+        var builder = this.copy();
+        builder.background = __assign(__assign({}, builder.background), background);
+        return builder;
+    };
+    /**
+     * Sets the border for the table.
+     * @param border The border settings to apply
+     * @returns A new TableStyler instance with the updated border
+     */
+    TableStyler.prototype.withBorder = function (border) {
+        var builder = this.copy();
+        builder.border = __assign(__assign({}, builder.border), border);
+        return builder;
+    };
+    /**
+     * Sets the dimensions for the table.
+     * @param width The width of the table
+     * @param height The height of the table
+     * @returns A new TableStyler instance with the updated dimensions
+     */
+    TableStyler.prototype.withDimensions = function (width, height) {
+        var builder = this.copy();
+        builder.dimension = { width: width, height: height };
+        return builder;
+    };
+    /**
+     * Sets the padding for the table.
+     * @param padding The padding settings to apply
+     * @returns A new TableStyler instance with the updated padding
+     */
+    TableStyler.prototype.withPadding = function (padding) {
+        var builder = this.copy();
+        builder.padding = __assign(__assign({}, builder.padding), padding);
+        return builder;
+    };
+    /**
+     * Sets the margin for the table.
+     * @param margin The margin settings to apply
+     * @returns A new TableStyler instance with the updated margin
+     */
+    TableStyler.prototype.withMargin = function (margin) {
+        var builder = this.copy();
+        builder.margin = __assign(__assign({}, builder.margin), margin);
+        return builder;
+    };
+    /**
+     * Tags a row with a style.
+     * @param rowIndex The index of the row to tag
+     * @param tagStyleType The type of style to apply
+     * @param style The style value to apply
+     * @returns A Result containing a new TableStyler with the tagged row, or an error message
+     * @private
+     */
+    TableStyler.prototype.tagRow = function (rowIndex, tagStyleType, style) {
+        var _this = this;
+        return this.dataFrame.tagRow(rowIndex, tagStyleType, style)
+            // when successfully tagged, make an updated copy of this builder with the new data-frame
+            .map(function (df) { return _this.update({ dataFrame: df }); })
+            // when failed to tag, add to the errors
+            .onFailure(function (error) { return _this.errors.push(error); });
+    };
+    /**
+     * Tags a column with a style.
+     * @param columnIndex The index of the column to tag
+     * @param tagStyleType The type of style to apply
+     * @param style The style value to apply
+     * @returns A Result containing a new TableStyler with the tagged column, or an error message
+     * @private
+     */
+    TableStyler.prototype.tagColumn = function (columnIndex, tagStyleType, style) {
+        var _this = this;
+        return this.dataFrame.tagColumn(columnIndex, tagStyleType, style)
+            // when successfully tagged, make an updated copy of this builder with the new data-frame
+            .map(function (df) { return _this.update({ dataFrame: df }); })
+            // when failed to tag, add to the errors
+            .onFailure(function (error) { return _this.errors.push(error); });
+    };
+    /**
+     * Sets the style for the column header row.
+     * @param columnHeaderStyle The style to apply to the column header. Style properties that are not specified
+     * will be set to their default values.
+     * @param priority The priority of this style (higher values take precedence)
+     * @returns A new TableStyler instance with the column header style applied
+     */
+    TableStyler.prototype.withColumnHeaderStyle = function (columnHeaderStyle, priority) {
+        if (columnHeaderStyle === void 0) { columnHeaderStyle = stylings_1.defaultColumnHeaderStyle; }
+        if (priority === void 0) { priority = Infinity; }
+        if (!tableData_1.TableData.hasColumnHeader(this.dataFrame)) {
+            this.errors.push("The column header style can only be supplied when the table data has a column header");
+            return this;
+        }
+        // tag the row as a column header style, and if it fails, then return this (unmodified) builder
+        return this
+            .tagRow(0, stylings_1.TableStyleType.COLUMN_HEADER, (0, stylings_1.stylingFor)(columnHeaderStyle, stylings_1.defaultColumnHeaderStyle, priority))
+            .getOrElse(this);
+    };
+    /**
+     * Sets the style for the row header column.
+     * @param rowHeaderStyle The style to apply to the row header. Style properties that are not specified
+     * will be set to their default values.
+     * @param priority The priority of this style (higher values take precedence)
+     * @returns A new TableStyler instance with the row header style applied
+     */
+    TableStyler.prototype.withRowHeaderStyle = function (rowHeaderStyle, priority) {
+        if (priority === void 0) { priority = Infinity; }
+        if (!tableData_1.TableData.hasRowHeader(this.dataFrame)) {
+            this.errors.push("The row header style can only be supplied when the table data has row headers");
+            return this;
+        }
+        // tag the column with the row header style, and if it fails, then return this (unmodified) builder
+        return this
+            .tagColumn(0, stylings_1.TableStyleType.ROW_HEADER, (0, stylings_1.stylingFor)(rowHeaderStyle, stylings_1.defaultRowHeaderStyle, priority))
+            .getOrElse(this);
+    };
+    /**
+     * Sets the style for the footer row.
+     * @param footerStyle The style to apply to the footer. Style properties that are not specified
+     * will be set to their default values.
+     * @param priority The priority of this style (higher values take precedence)
+     * @returns A new TableStyler instance with the footer style applied
+     */
+    TableStyler.prototype.withFooterStyle = function (footerStyle, priority) {
+        if (priority === void 0) { priority = Infinity; }
+        if (!tableData_1.TableData.hasFooter(this.dataFrame)) {
+            this.errors.push("The footer style can only be supplied when the table data has a footer");
+            return this;
+        }
+        // tag the row the footer style, and if it fails, then return this (unmodified) builder
+        var footerIndex = tableData_1.TableData.tableRowCount(this.dataFrame) - 1;
+        return this
+            .tagRow(footerIndex, stylings_1.TableStyleType.FOOTER, (0, stylings_1.stylingFor)(footerStyle, stylings_1.defaultFooterStyle, priority))
+            .getOrElse(this);
+    };
+    /**
+     * Sets the style for a specific row.
+     * @param rowIndex The index of the row to style
+     * @param rowStyle The style to apply to the row. Style properties that are not specified
+     * will be set to their default values.
+     * @param priority The priority of this style (higher values take precedence)
+     * @returns A new TableStyler instance with the row style applied
+     */
+    TableStyler.prototype.withRowStyle = function (rowIndex, rowStyle, priority) {
+        if (priority === void 0) { priority = 0; }
+        if (rowIndex < 0 || rowIndex >= tableData_1.TableData.tableRowCount(this.dataFrame)) {
+            this.errors.push("The row index, when setting a row-style, must be between 0 and ".concat(tableData_1.TableData.tableRowCount(this.dataFrame) - 1));
+            return this;
+        }
+        // tag the row with a style, and if it fails, then return this (unmodified) builder
+        return this
+            .tagRow(rowIndex, stylings_1.TableStyleType.ROW, (0, stylings_1.stylingFor)(rowStyle, stylings_1.defaultRowStyle, priority))
+            .getOrElse(this);
+    };
+    TableStyler.prototype.withRowStyles = function (rowIndexes, rowStyle, priority) {
+        if (priority === void 0) { priority = 0; }
+        var indexes = rowIndexes.length > 0 ? rowIndexes : new Array(this.dataFrame.rowCount()).fill(0).map(function (_, i) { return i; });
+        return TableStyler.withRowStyles(this, indexes, rowStyle, priority);
+    };
+    TableStyler.withRowStyles = function (tableStyler, rowIndexes, rowStyle, priority) {
+        if (priority === void 0) { priority = 0; }
+        if (rowIndexes.length > 0) {
+            var rowIndex = rowIndexes.shift();
+            if (rowIndex != null) {
+                var styler = tableStyler.withRowStyle(rowIndex, rowStyle, priority);
+                return TableStyler.withRowStyles(styler, rowIndexes, rowStyle, priority);
+            }
+        }
+        return tableStyler;
+    };
+    /**
+     * Sets the style for a specific column.
+     * @param columnIndex The index of the column to style
+     * @param columnStyle The style to apply to the column. Style properties that are not specified
+     * will be set to their default values.
+     * @param priority The priority of this style (higher values take precedence)
+     * @returns A new TableStyler instance with the column style applied
+     */
+    TableStyler.prototype.withColumnStyle = function (columnIndex, columnStyle, priority) {
+        if (priority === void 0) { priority = 0; }
+        if (columnIndex < 0 || columnIndex >= tableData_1.TableData.tableColumnCount(this.dataFrame)) {
+            this.errors.push("The column index, when setting a column-style, must be between 0 and ".concat(tableData_1.TableData.tableColumnCount(this.dataFrame) - 1));
+            return this;
+        }
+        // tag the row with a style, and if it fails, then return this (unmodified) builder
+        return this
+            .tagColumn(columnIndex, stylings_1.TableStyleType.COLUMN, (0, stylings_1.stylingFor)(columnStyle, stylings_1.defaultColumnStyle, priority))
+            .getOrElse(this);
+    };
+    TableStyler.prototype.withColumnStyles = function (columnIndexes, columnStyle, priority) {
+        if (priority === void 0) { priority = 0; }
+        var indexes = columnIndexes.length > 0 ? columnIndexes : new Array(this.dataFrame.columnCount()).fill(0).map(function (_, i) { return i; });
+        return TableStyler.withColumnStyles(this, indexes, columnStyle, priority);
+    };
+    TableStyler.withColumnStyles = function (tableStyler, columnIndexes, columnStyle, priority) {
+        if (priority === void 0) { priority = 0; }
+        if (columnIndexes.length > 0) {
+            var columnIndex = columnIndexes.shift();
+            if (columnIndex != null) {
+                var styler = tableStyler.withColumnStyle(columnIndex, columnStyle, priority);
+                return TableStyler.withColumnStyles(styler, columnIndexes, columnStyle, priority);
+            }
+        }
+        return tableStyler;
+    };
+    /**
+     * Sets the style for a specific cell.
+     * @param rowIndex The row index of the cell to style
+     * @param columnIndex The column index of the cell to style
+     * @param cellStyle The style to apply to the cell. Style properties that are not specified
+     * will be set to their default values.
+     * @param priority The priority of this style (higher values take precedence)
+     * @returns A new TableStyler instance with the cell style applied
+     */
+    TableStyler.prototype.withCellStyle = function (rowIndex, columnIndex, cellStyle, priority) {
+        var _this = this;
+        if (priority === void 0) { priority = 0; }
+        if (rowIndex < 0 || rowIndex >= tableData_1.TableData.tableRowCount(this.dataFrame) ||
+            columnIndex < 0 || columnIndex >= tableData_1.TableData.tableColumnCount(this.dataFrame)) {
+            this.errors.push("The (row, column) indices, when setting a cell-style, must be in " +
+                "([0, ".concat(tableData_1.TableData.tableRowCount(this.dataFrame), "), [0, ").concat(tableData_1.TableData.tableColumnCount(this.dataFrame), "))"));
+            return this;
+        }
+        // tag the cell with the cell-style
+        return this.dataFrame
+            .tagCell(rowIndex, columnIndex, stylings_1.TableStyleType.CELL, (0, stylings_1.stylingFor)(cellStyle, stylings_1.defaultCellStyle, priority))
+            // when successfully tagged, make an updated copy of this builder with the new data-frame
+            .map(function (df) { return _this.update({ dataFrame: df }); })
+            // when failed to tag, add to the errors
+            .onFailure(function (error) { return _this.errors.push(error); })
+            // when failed, return this (unmodified) builder
+            .getOrElse(this);
+    };
+    TableStyler.prototype.withCellStyleWhen = function (predicate, cellStyle, priority) {
+        var _this = this;
+        if (priority === void 0) { priority = 0; }
+        return this.dataFrame
+            .tagCellWhen(predicate, stylings_1.TableStyleType.CELL, (0, stylings_1.stylingFor)(cellStyle, stylings_1.defaultCellStyle, priority))
+            // when successfully tagged, make an updated copy of this builder with the new data-frame
+            .map(function (df) { return _this.update({ dataFrame: df }); })
+            // when failed to tag, add to the errors
+            .onFailure(function (error) { return _this.errors.push(error); })
+            // when failed, return this (unmodified) builder
+            .getOrElse(this);
+    };
+    /**
+     * Finalizes the styling process and creates a StyledTable instance.
+     * @returns A StyledTable instance with all the applied styles
+     */
+    TableStyler.prototype.styleTable = function () {
+        return new StyledTable(this.dataFrame, this.font, this.border, this.background, this.dimension, this.padding, this.margin);
+    };
+    return TableStyler;
+}());
+exports.TableStyler = TableStyler;
+//# sourceMappingURL=tableStyler.js.map