svg-table 0.1.2 → 0.2.1

package/dist/TableStyler.js

@@ -1,97 +1,86 @@
 "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");
+const TableData_1 = require("./TableData");
+const data_frame_ts_1 = require("data-frame-ts");
+const result_fn_1 = require("result-fn");
+const 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 () {
+class StyledTable {
     /**
      * 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;
+     * @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
+     */
+    constructor(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 () {
+    data() {
         return this.dataFrame.copy();
-    };
-    StyledTable.prototype.tableData = function () {
+    }
+    tableData() {
         // 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);
-    };
+    tableFont() {
+        return Object.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);
-    };
+    tableBorder() {
+        return Object.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);
-    };
+    tableBackground() {
+        return Object.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);
-    };
+    tableDimensions() {
+        return Object.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);
-    };
+    tablePadding() {
+        return Object.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);
-    };
+    tableMargin() {
+        return Object.assign({}, this.margin);
+    }
     /**
      * Retrieves styling tags for a specific column.
      * @param columnIndex The index of the column
@@ -99,22 +88,22 @@ var StyledTable = /** @class */ (function () {
      * @returns A Result containing the tag if found, or an error message
      * @private
      */
-    StyledTable.prototype.columnTagsFor = function (columnIndex, tagStyleType) {
+    columnTagsFor(columnIndex, tagStyleType) {
         // find all the tags and type them to row-header tags
-        var tags = this.dataFrame
+        const tags = this.dataFrame
             .columnTagsFor(columnIndex)
-            .filter(function (tag) { return tag.matchesId(tagStyleType, data_frame_ts_1.ColumnCoordinate.of(columnIndex)); })
-            .map(function (tag) { return tag; });
+            .filter(tag => tag.matchesId(tagStyleType, data_frame_ts_1.ColumnCoordinate.of(columnIndex)))
+            .map(tag => 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));
+            return (0, result_fn_1.failureResult)(`(StyledTable::columnTagsFor) No matching column-style tags found for table; column_index: ${columnIndex}; tag_type: ${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; });
+            tags.sort((tagA, tagB) => 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
@@ -122,125 +111,121 @@ var StyledTable = /** @class */ (function () {
      * @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];
-        }
+    rowTagsFor(rowIndex, ...tagStyleType) {
         // find all the tags and type them to column-header tags
-        var tags = this.dataFrame
+        const 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; });
+            .filter(tag => tagStyleType.filter(styleType => tag.matchesId(styleType, data_frame_ts_1.RowCoordinate.of(rowIndex))).length > 0)
+            .map(tag => 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));
+            return (0, result_fn_1.failureResult)(`(StyledTable::rowTagsFor) No matching row-style tags found for table; row_index: ${rowIndex}; tag_type: ${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; });
+            tags.sort((tagA, tagB) => tagB.value.priority - tagA.value.priority);
         }
         return (0, result_fn_1.successResult)(tags[0]);
-    };
+    }
     /**
      * Checks if the table has a row header.
      * @returns `true` if the table has a row header, `false` otherwise
      */
-    StyledTable.prototype.hasRowHeader = function () {
+    hasRowHeader() {
         return TableData_1.TableData.hasRowHeader(this.dataFrame);
-    };
+    }
     /**
      * Checks if the table has a column header.
      * @returns `true` if the table has a row header, `false` otherwise
      */
-    StyledTable.prototype.hasColumnHeader = function () {
+    hasColumnHeader() {
         return TableData_1.TableData.hasColumnHeader(this.dataFrame);
-    };
+    }
     /**
      * Checks if the table has a footer header.
      * @returns `true` if the table has a row header, `false` otherwise
      */
-    StyledTable.prototype.hasFooter = function () {
+    hasFooter() {
         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 () {
+    rowHeaderStyle() {
         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; });
-    };
+            .map(tag => 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 () {
+    columnHeaderStyle() {
         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; });
-    };
+            .map(tag => tag.value);
+    }
     /**
      * Gets the style for the footer.
      * @returns A Result containing the footer style if found, or an error message
      */
-    StyledTable.prototype.footerStyle = function () {
+    footerStyle() {
         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; });
-    };
+            .map(tag => 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) {
+    rowStyleFor(rowIndex) {
         return this
             .rowTagsFor(rowIndex, stylings_1.TableStyleType.ROW)
-            .map(function (tag) { return tag.value; });
-    };
+            .map(tag => 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) {
+    columnStyleFor(columnIndex) {
         return this
             .columnTagsFor(columnIndex, stylings_1.TableStyleType.COLUMN)
-            .map(function (tag) { return tag.value; });
-    };
+            .map(tag => 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) {
+    cellStyleFor(rowIndex, columnIndex) {
         // find all the tags and type them to column-header tags
-        var tags = this.dataFrame
+        const 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; });
+            .filter(tag => tag.matchesId(stylings_1.TableStyleType.CELL, data_frame_ts_1.CellCoordinate.of(rowIndex, columnIndex)))
+            .map(tag => 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));
+            return (0, result_fn_1.failureResult)(`(StyledTable::cellStyleFor) No matching cell-style tags found for table; row_index: ${rowIndex}; column_index: ${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; });
+            tags.sort((tagA, tagB) => 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
@@ -259,21 +244,21 @@ var StyledTable = /** @class */ (function () {
      * @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) {
+    stylesForDataCoordinates(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)));
+            return (0, result_fn_1.failureResult)(`(StyledTable::dataCellStyles) Invalid row and/or column index for data; row_index${rowIndex}` +
+                `; column_index: ${columnIndex}` +
+                `; valid_row_index: [0, ${TableData_1.TableData.dataRowCount(this.dataFrame)})` +
+                `; valid_column_index: [0, ${TableData_1.TableData.dataColumnCount(this.dataFrame)})` +
+                `; has_column_header: ${TableData_1.TableData.hasColumnHeader(this.dataFrame)}` +
+                `; has_row_header: ${TableData_1.TableData.hasRowHeader(this.dataFrame)}` +
+                `; has_footer: ${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;
+        const columnHeaderOffset = TableData_1.TableData.hasColumnHeader(this.dataFrame) ? 1 : 0;
+        const 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
@@ -290,41 +275,41 @@ var StyledTable = /** @class */ (function () {
      * row or column indexes are out of range.
      * @see stylesForDataCoordinates
      */
-    StyledTable.prototype.stylesForTableCoordinates = function (rowIndex, columnIndex) {
+    stylesForTableCoordinates(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(), ")"));
+            return (0, result_fn_1.failureResult)(`(StyledTable::stylesFor) Invalid row and/or column index` +
+                `; row_index: ${rowIndex}` +
+                `; column_index: ${columnIndex}` +
+                `; valid_row_index: [0, ${this.dataFrame.rowCount()})` +
+                `; valid_column_index: [0, ${this.dataFrame.columnCount()})`);
         }
         //
         // determine what styles may be available
-        var availableStyling = [];
+        const availableStyling = [];
         if (rowIndex === 0) {
-            this.columnHeaderStyle().onSuccess(function (styling) { return availableStyling.push(styling); });
+            this.columnHeaderStyle().onSuccess(styling => availableStyling.push(styling));
         }
         if (columnIndex === 0) {
-            this.rowHeaderStyle().onSuccess(function (styling) { return availableStyling.push(styling); });
+            this.rowHeaderStyle().onSuccess(styling => availableStyling.push(styling));
         }
         if (rowIndex === this.dataFrame.rowCount() - 1) {
-            this.footerStyle().onSuccess(function (styling) { return availableStyling.push(styling); });
+            this.footerStyle().onSuccess(styling => availableStyling.push(styling));
         }
-        this.rowStyleFor(rowIndex).onSuccess(function (styling) { return availableStyling.push(styling); });
-        this.columnStyleFor(columnIndex).onSuccess(function (styling) { return availableStyling.push(styling); });
+        this.rowStyleFor(rowIndex).onSuccess(styling => availableStyling.push(styling));
+        this.columnStyleFor(columnIndex).onSuccess(styling => 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 }); });
+            .onSuccess(styling => availableStyling.push(styling))
+            .onFailure(() => 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 ({
+        const cellStyle = availableStyling
+            .sort((stylingA, stylingB) => stylingA.priority - stylingB.priority)
+            .reduce((style, curr) => ({
             font: (curr.style.hasOwnProperty('font') ?
                 // @ts-ignore
-                __assign(__assign({}, style.font), curr.style.font) : (style.hasOwnProperty('font') ? __assign({}, style.font) : stylings_1.defaultTableFont)),
+                Object.assign(Object.assign({}, style.font), curr.style.font) : (style.hasOwnProperty('font') ? Object.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)),
@@ -333,87 +318,86 @@ var StyledTable = /** @class */ (function () {
                 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)),
+                Object.assign(Object.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)),
+                Object.assign(Object.assign({}, style.dimension), curr.style.dimension) : (style.hasOwnProperty('dimension') ? Object.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)),
+                Object.assign(Object.assign({}, style.padding), curr.style.padding) : (style.hasOwnProperty('padding') ? Object.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);
+                Object.assign(Object.assign({}, style.border), curr.style.border) : (style.hasOwnProperty('border') ? Object.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 () {
+class TableStyler {
     /**
      * 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;
+     * @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
+     */
+    constructor(dataFrame_, font_ = stylings_1.defaultTableFont, border_ = stylings_1.defaultBorder, background_ = stylings_1.defaultTableBackground, dimension_ = { width: NaN, height: NaN }, padding_ = stylings_1.defaultTablePadding, margin_ = stylings_1.defaultTableMargin, errors_ = []) {
+        this.font = stylings_1.defaultTableFont;
+        this.border = stylings_1.defaultBorder;
+        this.background = stylings_1.defaultTableBackground;
+        this.dimension = { width: NaN, height: NaN };
+        this.padding = stylings_1.defaultTablePadding;
+        this.margin = stylings_1.defaultTableMargin;
+        this.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) {
+    static fromTableData(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) {
+    static fromDataFrame(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 () {
+    copy() {
         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;
+    update(properties) {
+        const { dataFrame = this.dataFrame, font = this.font, border = this.border, background = this.background, dimension = this.dimension, padding = this.padding, margin = this.margin, } = properties;
         return new TableStyler(dataFrame, font, border, background, dimension, padding, margin, this.errors);
-    };
+    }
     /**
      * Applies the specified font settings for the table and returns a new {@link TableStyler}
      * instance with the updated font configuration.
@@ -422,62 +406,50 @@ var TableStyler = /** @class */ (function () {
      * properties of the TableFont.
      * @return A new {@link TableStyler} instance with the updated font settings.
      */
-    TableStyler.prototype.withTableFont = function (font) {
-        var builder = this.copy();
-        builder.font = __assign(__assign({}, stylings_1.defaultTableFont), font);
-        return builder;
-    };
+    withTableFont(font) {
+        return this.update({ font: Object.assign(Object.assign({}, stylings_1.defaultTableFont), font) });
+    }
     /**
      * 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;
-    };
+    withTableBackground(background) {
+        return this.update({ background: Object.assign(Object.assign({}, this.background), background) });
+    }
     /**
      * 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;
-    };
+    withBorder(border) {
+        return this.update({ border: Object.assign(Object.assign({}, this.border), border) });
+    }
     /**
      * 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;
-    };
+    withDimensions(width, height) {
+        return this.update({ dimension: { width, height } });
+    }
     /**
      * 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;
-    };
+    withPadding(padding) {
+        return this.update({ padding: Object.assign(Object.assign({}, this.padding), padding) });
+    }
     /**
      * 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;
-    };
+    withMargin(margin) {
+        return this.update({ margin: Object.assign(Object.assign({}, this.margin), margin) });
+    }
     /**
      * Tags a row with a style.
      * @param rowIndex The index of the row to tag
@@ -486,14 +458,13 @@ var TableStyler = /** @class */ (function () {
      * @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;
+    tagRow(rowIndex, tagStyleType, style) {
         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 }); })
+            .map(df => this.update({ dataFrame: df }))
             // when failed to tag, add to the errors
-            .onFailure(function (error) { return _this.errors.push(error); });
-    };
+            .onFailure(error => this.errors.push(error));
+    }
     /**
      * Tags a column with a style.
      * @param columnIndex The index of the column to tag
@@ -502,24 +473,21 @@ var TableStyler = /** @class */ (function () {
      * @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;
+    tagColumn(columnIndex, tagStyleType, style) {
         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 }); })
+            .map(df => this.update({ dataFrame: df }))
             // when failed to tag, add to the errors
-            .onFailure(function (error) { return _this.errors.push(error); });
-    };
+            .onFailure(error => 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)
+     * @param [priority=Infinity] 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; }
+    withColumnHeaderStyle(columnHeaderStyle = stylings_1.defaultColumnHeaderStyle, 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;
@@ -528,7 +496,7 @@ var TableStyler = /** @class */ (function () {
         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
@@ -536,8 +504,7 @@ var TableStyler = /** @class */ (function () {
      * @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; }
+    withRowHeaderStyle(rowHeaderStyle, 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;
@@ -546,7 +513,7 @@ var TableStyler = /** @class */ (function () {
         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
@@ -554,18 +521,17 @@ var TableStyler = /** @class */ (function () {
      * @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; }
+    withFooterStyle(footerStyle, 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;
+        const 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
@@ -574,17 +540,16 @@ var TableStyler = /** @class */ (function () {
      * @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; }
+    withRowStyle(rowIndex, rowStyle, 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));
+            this.errors.push(`The row index, when setting a row-style, must be between 0 and ${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);
-    };
+    }
     /**
      * Applies specific styles to rows in a table based on the provided row indexes.
      *
@@ -596,24 +561,22 @@ var TableStyler = /** @class */ (function () {
      * @return A new TableStyler instance with the specified row styles applied.
      * @see withRowStyle
      */
-    TableStyler.prototype.withRowStyles = function (rowIndexes, rowStyle, priority) {
-        if (priority === void 0) { priority = 0; }
-        var indexes = rowIndexes.length > 0 ?
+    withRowStyles(rowIndexes, rowStyle, priority = 0) {
+        const indexes = rowIndexes.length > 0 ?
             rowIndexes :
-            new Array(this.dataFrame.rowCount()).fill(0).map(function (_, i) { return i; });
+            new Array(this.dataFrame.rowCount()).fill(0).map((_, i) => i);
         return TableStyler.withRowStyles(this, indexes, rowStyle, priority);
-    };
-    TableStyler.withRowStyles = function (tableStyler, rowIndexes, rowStyle, priority) {
-        if (priority === void 0) { priority = 0; }
+    }
+    static withRowStyles(tableStyler, rowIndexes, rowStyle, priority = 0) {
         if (rowIndexes.length > 0) {
-            var rowIndex = rowIndexes.shift();
+            const rowIndex = rowIndexes.shift();
             if (rowIndex != null) {
-                var styler = tableStyler.withRowStyle(rowIndex, rowStyle, priority);
+                const 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
@@ -622,17 +585,16 @@ var TableStyler = /** @class */ (function () {
      * @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; }
+    withColumnStyle(columnIndex, columnStyle, 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));
+            this.errors.push(`The column index, when setting a column-style, must be between 0 and ${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);
-    };
+    }
     /**
      * Applies specified styles to the columns of a table.
      *
@@ -643,24 +605,22 @@ var TableStyler = /** @class */ (function () {
      * @return Returns an instance of TableStyler with the updated column styles applied.
      * @see withColumnStyle
      */
-    TableStyler.prototype.withColumnStyles = function (columnIndexes, columnStyle, priority) {
-        if (priority === void 0) { priority = 0; }
-        var indexes = columnIndexes.length > 0 ?
+    withColumnStyles(columnIndexes, columnStyle, priority = 0) {
+        const indexes = columnIndexes.length > 0 ?
             columnIndexes :
-            new Array(this.dataFrame.columnCount()).fill(0).map(function (_, i) { return i; });
+            new Array(this.dataFrame.columnCount()).fill(0).map((_, i) => i);
         return TableStyler.withColumnStyles(this, indexes, columnStyle, priority);
-    };
-    TableStyler.withColumnStyles = function (tableStyler, columnIndexes, columnStyle, priority) {
-        if (priority === void 0) { priority = 0; }
+    }
+    static withColumnStyles(tableStyler, columnIndexes, columnStyle, priority = 0) {
         if (columnIndexes.length > 0) {
-            var columnIndex = columnIndexes.shift();
+            const columnIndex = columnIndexes.shift();
             if (columnIndex != null) {
-                var styler = tableStyler.withColumnStyle(columnIndex, columnStyle, priority);
+                const 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
@@ -670,25 +630,23 @@ var TableStyler = /** @class */ (function () {
      * @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; }
+    withCellStyle(rowIndex, columnIndex, cellStyle, 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), "))"));
+            this.errors.push(`The (row, column) indices, when setting a cell-style, must be in ` +
+                `([0, ${TableData_1.TableData.tableRowCount(this.dataFrame)}), [0, ${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 }); })
+            .map(df => this.update({ dataFrame: df }))
             // when failed to tag, add to the errors
-            .onFailure(function (error) { return _this.errors.push(error); })
+            .onFailure(error => this.errors.push(error))
             // when failed, return this (unmodified) builder
             .getOrElse(this);
-    };
+    }
     /**
      * Sets the style for a specific cell based on a predicate.
      * @param predicate A function that accepts the value, row-index, and column-index of the cell, and
@@ -699,26 +657,23 @@ var TableStyler = /** @class */ (function () {
      * @see withCellStyle
      * @see withCellStyles
      */
-    TableStyler.prototype.withCellStyleWhen = function (predicate, cellStyle, priority) {
-        var _this = this;
-        if (priority === void 0) { priority = 0; }
+    withCellStyleWhen(predicate, cellStyle, 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 }); })
+            .map(df => this.update({ dataFrame: df }))
             // when failed to tag, add to the errors
-            .onFailure(function (error) { return _this.errors.push(error); })
+            .onFailure(error => 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 () {
+    styleTable() {
         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