svg-table 0.1.2 → 0.2.1

package/dist/tableStyler.test.js

@@ -1,69 +1,47 @@
 "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);
-};
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-var TableData_1 = require("./TableData");
-var data_frame_ts_1 = require("data-frame-ts");
-var TableFormatter_1 = require("./TableFormatter");
-var stylings_1 = require("./stylings");
-var TableStyler_1 = require("./TableStyler");
-describe('styling data tables', function () {
+const TableData_1 = require("./TableData");
+const data_frame_ts_1 = require("data-frame-ts");
+const TableFormatter_1 = require("./TableFormatter");
+const stylings_1 = require("./stylings");
+const TableStyler_1 = require("./TableStyler");
+describe('styling data tables', () => {
     function dateTimeFor(day, hour) {
         return new Date(2021, 1, day, hour, 0, 0, 0);
     }
-    var data = data_frame_ts_1.DataFrame.from([
+    const data = data_frame_ts_1.DataFrame.from([
         [dateTimeFor(1, 1), 12345, 'gnm-f234', 123.45, 4],
         [dateTimeFor(2, 2), 23456, 'gnm-g234', 23.45, 5],
         [dateTimeFor(3, 3), 34567, 'gnm-h234', 3.65, 40],
         [dateTimeFor(4, 4), 45678, 'gnm-i234', 314.15, 9],
         [dateTimeFor(5, 5), 56789, 'gnm-j234', 618.3, 10],
     ]).getOrThrow();
-    var columnHeader = ['Date-Time', 'Customer ID', 'Product ID', 'Purchase Price', 'Amount'];
-    var rowHeader = [1, 2, 3, 4, 5];
-    var footer = ['A', 'B', 'C', 'D', 'E'];
-    describe('adding basic table styles', function () {
-        var formattedTableData = TableData_1.TableData.fromDataFrame(data)
+    const columnHeader = ['Date-Time', 'Customer ID', 'Product ID', 'Purchase Price', 'Amount'];
+    const rowHeader = [1, 2, 3, 4, 5];
+    const footer = ['A', 'B', 'C', 'D', 'E'];
+    describe('adding basic table styles', () => {
+        const formattedTableData = TableData_1.TableData.fromDataFrame(data)
             .withColumnHeader(columnHeader)
-            .flatMap(function (td) { return td.withRowHeader(rowHeader); })
-            .flatMap(function (td) { return td.withFooter(footer); })
-            .flatMap(function (td) { return TableFormatter_1.TableFormatter.fromTableData(td)
+            .flatMap(td => td.withRowHeader(rowHeader))
+            .flatMap(td => td.withFooter(footer))
+            .flatMap(td => TableFormatter_1.TableFormatter.fromTableData(td)
             // add the default formatter for the column header, at the highest priority so that
             // it is the one that applies to the row representing the column header
             .addRowFormatter(0, TableFormatter_1.defaultFormatter, 100)
             // formatter for the footer
-            .flatMap(function (tf) { return tf.addRowFormatter(5, TableFormatter_1.defaultFormatter, 100); })
-            .flatMap(function (tf) { return tf.addColumnFormatter(0, TableFormatter_1.defaultFormatter, 100); })
+            .flatMap(tf => tf.addRowFormatter(5, TableFormatter_1.defaultFormatter, 100))
+            .flatMap(tf => tf.addColumnFormatter(0, TableFormatter_1.defaultFormatter, 100))
             // add the column formatters for each column at the default (lowest) priority
-            .flatMap(function (tf) { return tf.addColumnFormatter(1, function (value) { return value.toLocaleDateString(); }); })
-            .flatMap(function (tf) { return tf.addColumnFormatter(2, function (value) { return (0, TableFormatter_1.defaultFormatter)(value); }); })
-            .flatMap(function (tf) { return tf.addColumnFormatter(4, function (value) { return "$ ".concat(value.toFixed(2)); }); })
-            .flatMap(function (tf) { return tf.addColumnFormatter(5, function (value) { return "".concat(value.toFixed(0)); }); })
-            .flatMap(function (tf) { return tf.addCellFormatter(3, 3, function (value) { return value.toUpperCase(); }, 1); })
+            .flatMap(tf => tf.addColumnFormatter(1, value => value.toLocaleDateString()))
+            .flatMap(tf => tf.addColumnFormatter(2, value => (0, TableFormatter_1.defaultFormatter)(value)))
+            .flatMap(tf => tf.addColumnFormatter(4, value => `$ ${value.toFixed(2)}`))
+            .flatMap(tf => tf.addColumnFormatter(5, value => `${value.toFixed(0)}`))
+            .flatMap(tf => tf.addCellFormatter(3, 3, value => value.toUpperCase(), 1))
             // format the table into a new TableData object
-            .flatMap(function (tf) { return tf.formatTable(); }); })
+            .flatMap(tf => tf.formatTable()))
             .getOrThrow();
-        describe('set and retrieve global table styles', function () {
-            var styledTable = TableStyler_1.TableStyler.fromTableData(formattedTableData)
+        describe('set and retrieve global table styles', () => {
+            const styledTable = TableStyler_1.TableStyler.fromTableData(formattedTableData)
                 .withTableBackground({ color: 'grey', opacity: 0.15 })
                 .withTableFont({ color: 'blue', size: 13.5 })
                 .withBorder({ top: { opacity: 0 } })
@@ -71,368 +49,232 @@ describe('styling data tables', function () {
                 .withPadding({ top: 10 })
                 .withMargin({ left: 10, right: 10 })
                 .styleTable();
-            test('should be able to retrieve the background', function () {
+            test('should be able to retrieve the background', () => {
                 expect(styledTable.tableBackground()).toEqual({ color: 'grey', opacity: 0.15 });
             });
-            test('should be able to retrieve the font', function () {
-                expect(styledTable.tableFont()).toEqual(__assign(__assign({}, stylings_1.defaultTableFont), { color: 'blue', size: 13.5 }));
+            test('should be able to retrieve the font', () => {
+                expect(styledTable.tableFont()).toEqual(Object.assign(Object.assign({}, stylings_1.defaultTableFont), { color: 'blue', size: 13.5 }));
             });
-            test('should be able to retrieve the border', function () {
-                expect(styledTable.tableBorder()).toEqual(__assign(__assign({}, stylings_1.defaultBorder), { top: { opacity: 0 } }));
+            test('should be able to retrieve the border', () => {
+                expect(styledTable.tableBorder()).toEqual(Object.assign(Object.assign({}, stylings_1.defaultBorder), { top: { opacity: 0 } }));
             });
-            test('should be able to retrieve the dimensions', function () {
+            test('should be able to retrieve the dimensions', () => {
                 expect(styledTable.tableDimensions()).toEqual({ width: 1300, height: 500 });
             });
-            test('should be able to retrieve the padding', function () {
-                expect(styledTable.tablePadding()).toEqual(__assign(__assign({}, stylings_1.defaultTablePadding), { top: 10 }));
+            test('should be able to retrieve the padding', () => {
+                expect(styledTable.tablePadding()).toEqual(Object.assign(Object.assign({}, stylings_1.defaultTablePadding), { top: 10 }));
             });
-            test('should be able to retrieve the margin', function () {
-                expect(styledTable.tableMargin()).toEqual(__assign(__assign({}, stylings_1.defaultTableMargin), { left: 10, right: 10 }));
+            test('should be able to retrieve the margin', () => {
+                expect(styledTable.tableMargin()).toEqual(Object.assign(Object.assign({}, stylings_1.defaultTableMargin), { left: 10, right: 10 }));
             });
-            test('should be able to get a copy of the data-frame from the styler', function () {
-                var dataFrame = styledTable.data();
+            test('should be able to get a copy of the data-frame from the styler', () => {
+                const dataFrame = styledTable.data();
                 expect(dataFrame.equals(formattedTableData.unwrapDataFrame())).toBeTruthy();
             });
-            test('should be able to report whether styled table has a row header', function () {
+            test('should be able to report whether styled table has a row header', () => {
                 expect(styledTable.hasRowHeader()).toBeTruthy();
             });
-            test('should be able to report whether styled table has a column header', function () {
+            test('should be able to report whether styled table has a column header', () => {
                 expect(styledTable.hasColumnHeader()).toBeTruthy();
             });
-            test('should be able to report whether styled table has a footer', function () {
+            test('should be able to report whether styled table has a footer', () => {
                 expect(styledTable.hasFooter()).toBeTruthy();
             });
         });
-        test('should be able to set and retrieve style for the column header', function () {
-            var styledTable = TableStyler_1.TableStyler.fromTableData(formattedTableData)
-                .withColumnHeaderStyle({ font: __assign(__assign({}, stylings_1.defaultTableFont), { size: 16, weight: 800 }) })
+        test('should be able to set and retrieve style for the column header', () => {
+            const styledTable = TableStyler_1.TableStyler.fromTableData(formattedTableData)
+                .withColumnHeaderStyle({ font: Object.assign(Object.assign({}, stylings_1.defaultTableFont), { size: 16, weight: 800 }) })
                 .styleTable();
             expect(styledTable.columnHeaderStyle().getOrThrow()).toEqual({
-                style: __assign(__assign({}, stylings_1.defaultColumnHeaderStyle), { font: __assign(__assign({}, stylings_1.defaultTableFont), { size: 16, weight: 800 }) }),
+                style: Object.assign(Object.assign({}, stylings_1.defaultColumnHeaderStyle), { font: Object.assign(Object.assign({}, stylings_1.defaultTableFont), { size: 16, weight: 800 }) }),
                 priority: Infinity
             });
         });
-        test('should be able to set and retrieve style for the row header', function () {
-            var styledTable = TableStyler_1.TableStyler.fromTableData(formattedTableData)
-                .withRowHeaderStyle({ font: __assign(__assign({}, stylings_1.defaultTableFont), { size: 16, weight: 800 }) })
+        test('should be able to set and retrieve style for the row header', () => {
+            const styledTable = TableStyler_1.TableStyler.fromTableData(formattedTableData)
+                .withRowHeaderStyle({ font: Object.assign(Object.assign({}, stylings_1.defaultTableFont), { size: 16, weight: 800 }) })
                 .styleTable();
             expect(styledTable.rowHeaderStyle().getOrThrow()).toEqual({
-                style: __assign(__assign({}, stylings_1.defaultRowHeaderStyle), { font: __assign(__assign({}, stylings_1.defaultTableFont), { size: 16, weight: 800 }) }),
+                style: Object.assign(Object.assign({}, stylings_1.defaultRowHeaderStyle), { font: Object.assign(Object.assign({}, stylings_1.defaultTableFont), { size: 16, weight: 800 }) }),
                 priority: Infinity
             });
         });
-        test('should be able to set and retrieve style for the footer', function () {
-            var styledTable = TableStyler_1.TableStyler.fromTableData(formattedTableData)
-                .withFooterStyle({ font: __assign(__assign({}, stylings_1.defaultTableFont), { size: 16, weight: 800 }) })
+        test('should be able to set and retrieve style for the footer', () => {
+            const styledTable = TableStyler_1.TableStyler.fromTableData(formattedTableData)
+                .withFooterStyle({ font: Object.assign(Object.assign({}, stylings_1.defaultTableFont), { size: 16, weight: 800 }) })
                 .styleTable();
             expect(styledTable.footerStyle().getOrThrow()).toEqual({
-                style: __assign(__assign({}, stylings_1.defaultFooterStyle), { font: __assign(__assign({}, stylings_1.defaultTableFont), { size: 16, weight: 800 }) }),
+                style: Object.assign(Object.assign({}, stylings_1.defaultFooterStyle), { font: Object.assign(Object.assign({}, stylings_1.defaultTableFont), { size: 16, weight: 800 }) }),
                 priority: Infinity
             });
         });
-        describe('retrieve the cell style with highest priority', function () {
-            var styledTable = TableStyler_1.TableStyler.fromTableData(formattedTableData)
-                .withColumnHeaderStyle({ font: __assign(__assign({}, stylings_1.defaultTableFont), { size: 16, weight: 800 }) })
-                .withCellStyle(2, 3, { font: __assign(__assign({}, stylings_1.defaultTableFont), { size: 12, weight: 600 }) }, 100)
-                .withRowStyle(2, { font: __assign(__assign({}, stylings_1.defaultTableFont), { size: 14, weight: 700 }) }, 50)
-                .withRowHeaderStyle({ font: __assign(__assign({}, stylings_1.defaultTableFont), { size: 15, weight: 650 }) })
+        describe('retrieve the cell style with highest priority', () => {
+            const styledTable = TableStyler_1.TableStyler.fromTableData(formattedTableData)
+                .withColumnHeaderStyle({ font: Object.assign(Object.assign({}, stylings_1.defaultTableFont), { size: 16, weight: 800 }) })
+                .withCellStyle(2, 3, { font: Object.assign(Object.assign({}, stylings_1.defaultTableFont), { size: 12, weight: 600 }) }, 100)
+                .withRowStyle(2, { font: Object.assign(Object.assign({}, stylings_1.defaultTableFont), { size: 14, weight: 700 }) }, 50)
+                .withRowHeaderStyle({ font: Object.assign(Object.assign({}, stylings_1.defaultTableFont), { size: 15, weight: 650 }) })
                 .withColumnStyle(4, { padding: { left: 1000, right: 1111 } }, 75)
                 .styleTable();
             function expectDefaultCellStyleFor(row, column) {
                 expect(styledTable.stylesForTableCoordinates(row, column).getOrThrow()).toEqual(stylings_1.defaultCellStyle);
             }
-            test('should get the default cell style for cells with no available style', function () {
-                var e_1, _a, e_2, _b;
-                var unstyledRows = [1, 3, 4, 5]; // row 0 is the column header, row 2 has a row-style
-                var unstyledColumns = [1, 2, 3, 5]; // column 0 is the row header, column 4 has a column-style
-                try {
-                    for (var unstyledRows_1 = __values(unstyledRows), unstyledRows_1_1 = unstyledRows_1.next(); !unstyledRows_1_1.done; unstyledRows_1_1 = unstyledRows_1.next()) {
-                        var row = unstyledRows_1_1.value;
-                        try {
-                            for (var unstyledColumns_1 = (e_2 = void 0, __values(unstyledColumns)), unstyledColumns_1_1 = unstyledColumns_1.next(); !unstyledColumns_1_1.done; unstyledColumns_1_1 = unstyledColumns_1.next()) {
-                                var column = unstyledColumns_1_1.value;
-                                expectDefaultCellStyleFor(row, column);
-                            }
-                        }
-                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                        finally {
-                            try {
-                                if (unstyledColumns_1_1 && !unstyledColumns_1_1.done && (_b = unstyledColumns_1.return)) _b.call(unstyledColumns_1);
-                            }
-                            finally { if (e_2) throw e_2.error; }
-                        }
+            test('should get the default cell style for cells with no available style', () => {
+                const unstyledRows = [1, 3, 4, 5]; // row 0 is the column header, row 2 has a row-style
+                const unstyledColumns = [1, 2, 3, 5]; // column 0 is the row header, column 4 has a column-style
+                for (const row of unstyledRows) {
+                    for (const column of unstyledColumns) {
+                        expectDefaultCellStyleFor(row, column);
                     }
                 }
-                catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                finally {
-                    try {
-                        if (unstyledRows_1_1 && !unstyledRows_1_1.done && (_a = unstyledRows_1.return)) _a.call(unstyledRows_1);
-                    }
-                    finally { if (e_1) throw e_1.error; }
-                }
             });
-            test('should get cell style for (2, 3) is the highest priority', function () {
-                expect(styledTable.stylesForTableCoordinates(2, 3).getOrThrow()).toEqual(__assign(__assign({}, stylings_1.defaultCellStyle), { font: __assign(__assign({}, stylings_1.defaultTableFont), { size: 12, weight: 600 }) }));
+            test('should get cell style for (2, 3) is the highest priority', () => {
+                expect(styledTable.stylesForTableCoordinates(2, 3).getOrThrow()).toEqual(Object.assign(Object.assign({}, stylings_1.defaultCellStyle), { font: Object.assign(Object.assign({}, stylings_1.defaultTableFont), { size: 12, weight: 600 }) }));
             });
-            test('should get column header style for (0, 3) is the highest priority', function () {
+            test('should get column header style for (0, 3) is the highest priority', () => {
                 // column header style for (0, 3) is the highest priority
-                expect(styledTable.stylesForTableCoordinates(0, 3).getOrThrow()).toEqual(__assign(__assign(__assign({}, stylings_1.defaultCellStyle), stylings_1.defaultColumnStyle), { 
+                expect(styledTable.stylesForTableCoordinates(0, 3).getOrThrow()).toEqual(Object.assign(Object.assign(Object.assign({}, stylings_1.defaultCellStyle), stylings_1.defaultColumnStyle), { 
                     // these come from the default column header style
-                    dimension: __assign(__assign({}, stylings_1.defaultDimension), { height: 20, minHeight: 15 }), 
+                    dimension: Object.assign(Object.assign({}, stylings_1.defaultDimension), { height: 20, minHeight: 15 }), 
                     // these come from setting the column header style
-                    font: __assign(__assign({}, stylings_1.defaultTableFont), { size: 16, weight: 800 }) }));
+                    font: Object.assign(Object.assign({}, stylings_1.defaultTableFont), { size: 16, weight: 800 }) }));
             });
-            test('should return a failure when getting a style for a column index that is too large', function () {
-                var result = styledTable.stylesForTableCoordinates(1, 6);
+            test('should return a failure when getting a style for a column index that is too large', () => {
+                const result = styledTable.stylesForTableCoordinates(1, 6);
                 expect(result.failed).toBeTruthy();
                 expect(result.error).toEqual("(StyledTable::stylesFor) Invalid row and/or column index; row_index: 1; column_index: 6; valid_row_index: [0, 7); valid_column_index: [0, 6)");
             });
-            test('should return a failure when getting a style for a column index that is less than 0', function () {
-                var result = styledTable.stylesForTableCoordinates(3, -1);
+            test('should return a failure when getting a style for a column index that is less than 0', () => {
+                const result = styledTable.stylesForTableCoordinates(3, -1);
                 expect(result.failed).toBeTruthy();
                 expect(result.error).toEqual("(StyledTable::stylesFor) Invalid row and/or column index; row_index: 3; column_index: -1; valid_row_index: [0, 7); valid_column_index: [0, 6)");
             });
-            test('should return a failure when getting a style for a row index that is less than 0', function () {
-                var result = styledTable.stylesForTableCoordinates(-1, 3);
+            test('should return a failure when getting a style for a row index that is less than 0', () => {
+                const result = styledTable.stylesForTableCoordinates(-1, 3);
                 expect(result.failed).toBeTruthy();
                 expect(result.error).toEqual("(StyledTable::stylesFor) Invalid row and/or column index; row_index: -1; column_index: 3; valid_row_index: [0, 7); valid_column_index: [0, 6)");
             });
-            test('should return a failure when getting a style for a row index that is too large', function () {
-                var result = styledTable.stylesForTableCoordinates(7, 3);
+            test('should return a failure when getting a style for a row index that is too large', () => {
+                const result = styledTable.stylesForTableCoordinates(7, 3);
                 expect(result.failed).toBeTruthy();
                 expect(result.error).toEqual("(StyledTable::stylesFor) Invalid row and/or column index; row_index: 7; column_index: 3; valid_row_index: [0, 7); valid_column_index: [0, 6)");
             });
-            test('should get the row header style for (1, 0) because table has row header style', function () {
-                expect(styledTable.stylesForTableCoordinates(1, 0).getOrThrow()).toEqual(__assign(__assign(__assign({}, stylings_1.defaultCellStyle), stylings_1.defaultRowHeaderStyle), { font: __assign(__assign({}, stylings_1.defaultTableFont), { size: 15, weight: 650 }) }));
+            test('should get the row header style for (1, 0) because table has row header style', () => {
+                expect(styledTable.stylesForTableCoordinates(1, 0).getOrThrow()).toEqual(Object.assign(Object.assign(Object.assign({}, stylings_1.defaultCellStyle), stylings_1.defaultRowHeaderStyle), { font: Object.assign(Object.assign({}, stylings_1.defaultTableFont), { size: 15, weight: 650 }) }));
             });
-            test('should get column header style for (0, 4) because table has column header style', function () {
-                expect(styledTable.stylesForTableCoordinates(0, 4).getOrThrow()).toEqual(__assign(__assign({}, stylings_1.defaultCellStyle), { 
+            test('should get column header style for (0, 4) because table has column header style', () => {
+                expect(styledTable.stylesForTableCoordinates(0, 4).getOrThrow()).toEqual(Object.assign(Object.assign({}, stylings_1.defaultCellStyle), { 
                     // these come from the default column header style rather than the column style for
                     // the 4th column because the column header style has a higher priority
-                    dimension: __assign(__assign({}, stylings_1.defaultDimension), { height: 20, minHeight: 15 }), 
+                    dimension: Object.assign(Object.assign({}, stylings_1.defaultDimension), { height: 20, minHeight: 15 }), 
                     // these come from setting the column header style
-                    font: __assign(__assign({}, stylings_1.defaultTableFont), { size: 16, weight: 800 }) }));
+                    font: Object.assign(Object.assign({}, stylings_1.defaultTableFont), { size: 16, weight: 800 }) }));
             });
-            test('should get column style for (1, 4) because table has column style', function () {
-                expect(styledTable.stylesForTableCoordinates(1, 4).getOrThrow()).toEqual(__assign(__assign(__assign({}, stylings_1.defaultCellStyle), stylings_1.defaultColumnStyle), { padding: __assign(__assign({}, stylings_1.defaultTablePadding), { left: 1000, right: 1111 }) }));
+            test('should get column style for (1, 4) because table has column style', () => {
+                expect(styledTable.stylesForTableCoordinates(1, 4).getOrThrow()).toEqual(Object.assign(Object.assign(Object.assign({}, stylings_1.defaultCellStyle), stylings_1.defaultColumnStyle), { padding: Object.assign(Object.assign({}, stylings_1.defaultTablePadding), { left: 1000, right: 1111 }) }));
             });
-            test('should get column style for (2, 4) because table has column style with higher priority than row-style', function () {
-                expect(styledTable.stylesForTableCoordinates(2, 4).getOrThrow()).toEqual(__assign(__assign(__assign({}, stylings_1.defaultCellStyle), stylings_1.defaultColumnStyle), { 
+            test('should get column style for (2, 4) because table has column style with higher priority than row-style', () => {
+                expect(styledTable.stylesForTableCoordinates(2, 4).getOrThrow()).toEqual(Object.assign(Object.assign(Object.assign({}, stylings_1.defaultCellStyle), stylings_1.defaultColumnStyle), { 
                     // the row style sets the font (column style doesn't) have font, and so the column style
                     // that overrides the row style doesn't change the font
-                    font: __assign(__assign({}, stylings_1.defaultTableFont), { size: 14, weight: 700 }), 
+                    font: Object.assign(Object.assign({}, stylings_1.defaultTableFont), { size: 14, weight: 700 }), 
                     // and the column style sets the padding
-                    padding: __assign(__assign({}, stylings_1.defaultTablePadding), { left: 1000, right: 1111 }) }));
+                    padding: Object.assign(Object.assign({}, stylings_1.defaultTablePadding), { left: 1000, right: 1111 }) }));
             });
-            test('should get column style for (3, 4) because table has column style with higher priority than row-style', function () {
-                expect(styledTable.stylesForTableCoordinates(3, 4).getOrThrow()).toEqual(__assign(__assign(__assign({}, stylings_1.defaultCellStyle), stylings_1.defaultColumnStyle), { padding: __assign(__assign({}, stylings_1.defaultTablePadding), { left: 1000, right: 1111 }) }));
+            test('should get column style for (3, 4) because table has column style with higher priority than row-style', () => {
+                expect(styledTable.stylesForTableCoordinates(3, 4).getOrThrow()).toEqual(Object.assign(Object.assign(Object.assign({}, stylings_1.defaultCellStyle), stylings_1.defaultColumnStyle), { padding: Object.assign(Object.assign({}, stylings_1.defaultTablePadding), { left: 1000, right: 1111 }) }));
             });
-            test('should be able to retrieve cell styles using data row and column indices', function () {
+            test('should be able to retrieve cell styles using data row and column indices', () => {
                 // cell (2 ,3) in table coordinates translates to cell (1, 2) in data coordinates because
                 // the table has a column header and a row header. in this case the data coordinates are
                 // (table_row - 1, table_column - 1).
-                expect(styledTable.stylesForDataCoordinates(2 - 1, 3 - 1).getOrThrow()).toEqual(__assign(__assign({}, stylings_1.defaultCellStyle), { font: __assign(__assign({}, stylings_1.defaultTableFont), { size: 12, weight: 600 }) }));
+                expect(styledTable.stylesForDataCoordinates(2 - 1, 3 - 1).getOrThrow()).toEqual(Object.assign(Object.assign({}, stylings_1.defaultCellStyle), { font: Object.assign(Object.assign({}, stylings_1.defaultTableFont), { size: 12, weight: 600 }) }));
             });
         });
-        describe('set styles for multiple rows, columns, and cells', function () {
+        describe('set styles for multiple rows, columns, and cells', () => {
             function expectDefaultCellStyleFor(styledTable, row, column) {
                 expect(styledTable.stylesForTableCoordinates(row, column).getOrThrow()).toEqual(stylings_1.defaultCellStyle);
             }
-            test('should be able to set the style for multiple columns at once', function () {
-                var e_3, _a, e_4, _b, e_5, _c;
-                var styledColumns = [1, 3, 4];
-                var styledTable = TableStyler_1.TableStyler.fromTableData(formattedTableData)
+            test('should be able to set the style for multiple columns at once', () => {
+                const styledColumns = [1, 3, 4];
+                const styledTable = TableStyler_1.TableStyler.fromTableData(formattedTableData)
                     .withColumnStyles(styledColumns, { padding: { left: 1000, right: 1111 } }, 75)
                     .styleTable();
-                var unstyledRows = [1, 3, 4, 5];
-                var unstyledColumns = [0, 2, 5];
-                try {
-                    for (var unstyledRows_2 = __values(unstyledRows), unstyledRows_2_1 = unstyledRows_2.next(); !unstyledRows_2_1.done; unstyledRows_2_1 = unstyledRows_2.next()) {
-                        var row = unstyledRows_2_1.value;
-                        try {
-                            for (var unstyledColumns_2 = (e_4 = void 0, __values(unstyledColumns)), unstyledColumns_2_1 = unstyledColumns_2.next(); !unstyledColumns_2_1.done; unstyledColumns_2_1 = unstyledColumns_2.next()) {
-                                var column = unstyledColumns_2_1.value;
-                                expectDefaultCellStyleFor(styledTable, row, column);
-                            }
-                        }
-                        catch (e_4_1) { e_4 = { error: e_4_1 }; }
-                        finally {
-                            try {
-                                if (unstyledColumns_2_1 && !unstyledColumns_2_1.done && (_b = unstyledColumns_2.return)) _b.call(unstyledColumns_2);
-                            }
-                            finally { if (e_4) throw e_4.error; }
-                        }
-                    }
-                }
-                catch (e_3_1) { e_3 = { error: e_3_1 }; }
-                finally {
-                    try {
-                        if (unstyledRows_2_1 && !unstyledRows_2_1.done && (_a = unstyledRows_2.return)) _a.call(unstyledRows_2);
-                    }
-                    finally { if (e_3) throw e_3.error; }
-                }
-                try {
-                    for (var styledColumns_1 = __values(styledColumns), styledColumns_1_1 = styledColumns_1.next(); !styledColumns_1_1.done; styledColumns_1_1 = styledColumns_1.next()) {
-                        var column = styledColumns_1_1.value;
-                        expect(styledTable.columnStyleFor(column).map(function (styling) { return styling.style; }).getOrThrow())
-                            .toEqual(__assign(__assign({}, stylings_1.defaultColumnStyle), { padding: { left: 1000, right: 1111 } }));
+                const unstyledRows = [1, 3, 4, 5];
+                const unstyledColumns = [0, 2, 5];
+                for (const row of unstyledRows) {
+                    for (const column of unstyledColumns) {
+                        expectDefaultCellStyleFor(styledTable, row, column);
                     }
                 }
-                catch (e_5_1) { e_5 = { error: e_5_1 }; }
-                finally {
-                    try {
-                        if (styledColumns_1_1 && !styledColumns_1_1.done && (_c = styledColumns_1.return)) _c.call(styledColumns_1);
-                    }
-                    finally { if (e_5) throw e_5.error; }
+                for (const column of styledColumns) {
+                    expect(styledTable.columnStyleFor(column).map(styling => styling.style).getOrThrow())
+                        .toEqual(Object.assign(Object.assign({}, stylings_1.defaultColumnStyle), { padding: { left: 1000, right: 1111 } }));
                 }
             });
-            test('should be able to set the style for all columns at once', function () {
-                var e_6, _a;
-                var styledColumns = [0, 1, 2, 3, 4, 5];
-                var styledTable = TableStyler_1.TableStyler.fromTableData(formattedTableData)
+            test('should be able to set the style for all columns at once', () => {
+                const styledColumns = [0, 1, 2, 3, 4, 5];
+                const styledTable = TableStyler_1.TableStyler.fromTableData(formattedTableData)
                     // an empty array means that all the columns should be styled
                     .withColumnStyles([], { padding: { left: 1000, right: 1111 } }, 75)
                     .styleTable();
-                try {
-                    for (var styledColumns_2 = __values(styledColumns), styledColumns_2_1 = styledColumns_2.next(); !styledColumns_2_1.done; styledColumns_2_1 = styledColumns_2.next()) {
-                        var column = styledColumns_2_1.value;
-                        expect(styledTable.columnStyleFor(column).map(function (styling) { return styling.style; }).getOrThrow())
-                            .toEqual(__assign(__assign({}, stylings_1.defaultColumnStyle), { padding: { left: 1000, right: 1111 } }));
-                    }
-                }
-                catch (e_6_1) { e_6 = { error: e_6_1 }; }
-                finally {
-                    try {
-                        if (styledColumns_2_1 && !styledColumns_2_1.done && (_a = styledColumns_2.return)) _a.call(styledColumns_2);
-                    }
-                    finally { if (e_6) throw e_6.error; }
+                for (const column of styledColumns) {
+                    expect(styledTable.columnStyleFor(column).map(styling => styling.style).getOrThrow())
+                        .toEqual(Object.assign(Object.assign({}, stylings_1.defaultColumnStyle), { padding: { left: 1000, right: 1111 } }));
                 }
             });
-            test('should be able to set the style for multiple rows at once', function () {
-                var e_7, _a, e_8, _b, e_9, _c;
-                var styledRows = [1, 3, 4];
-                var styledTable = TableStyler_1.TableStyler.fromTableData(formattedTableData)
+            test('should be able to set the style for multiple rows at once', () => {
+                const styledRows = [1, 3, 4];
+                const styledTable = TableStyler_1.TableStyler.fromTableData(formattedTableData)
                     .withRowStyles(styledRows, { padding: { top: 1000, bottom: 1111 } }, 75)
                     .styleTable();
-                var unstyledRows = [0, 2];
-                var unstyledColumns = [0, 1, 2, 3, 4, 5];
-                try {
-                    for (var unstyledRows_3 = __values(unstyledRows), unstyledRows_3_1 = unstyledRows_3.next(); !unstyledRows_3_1.done; unstyledRows_3_1 = unstyledRows_3.next()) {
-                        var row = unstyledRows_3_1.value;
-                        try {
-                            for (var unstyledColumns_3 = (e_8 = void 0, __values(unstyledColumns)), unstyledColumns_3_1 = unstyledColumns_3.next(); !unstyledColumns_3_1.done; unstyledColumns_3_1 = unstyledColumns_3.next()) {
-                                var column = unstyledColumns_3_1.value;
-                                expectDefaultCellStyleFor(styledTable, row, column);
-                            }
-                        }
-                        catch (e_8_1) { e_8 = { error: e_8_1 }; }
-                        finally {
-                            try {
-                                if (unstyledColumns_3_1 && !unstyledColumns_3_1.done && (_b = unstyledColumns_3.return)) _b.call(unstyledColumns_3);
-                            }
-                            finally { if (e_8) throw e_8.error; }
-                        }
+                const unstyledRows = [0, 2];
+                const unstyledColumns = [0, 1, 2, 3, 4, 5];
+                for (const row of unstyledRows) {
+                    for (const column of unstyledColumns) {
+                        expectDefaultCellStyleFor(styledTable, row, column);
                     }
                 }
-                catch (e_7_1) { e_7 = { error: e_7_1 }; }
-                finally {
-                    try {
-                        if (unstyledRows_3_1 && !unstyledRows_3_1.done && (_a = unstyledRows_3.return)) _a.call(unstyledRows_3);
-                    }
-                    finally { if (e_7) throw e_7.error; }
-                }
-                try {
-                    for (var styledRows_1 = __values(styledRows), styledRows_1_1 = styledRows_1.next(); !styledRows_1_1.done; styledRows_1_1 = styledRows_1.next()) {
-                        var row = styledRows_1_1.value;
-                        expect(styledTable.rowStyleFor(row).map(function (styling) { return styling.style; }).getOrThrow())
-                            .toEqual(__assign(__assign({}, stylings_1.defaultRowStyle), { padding: { top: 1000, bottom: 1111 } }));
-                    }
-                }
-                catch (e_9_1) { e_9 = { error: e_9_1 }; }
-                finally {
-                    try {
-                        if (styledRows_1_1 && !styledRows_1_1.done && (_c = styledRows_1.return)) _c.call(styledRows_1);
-                    }
-                    finally { if (e_9) throw e_9.error; }
+                for (const row of styledRows) {
+                    expect(styledTable.rowStyleFor(row).map(styling => styling.style).getOrThrow())
+                        .toEqual(Object.assign(Object.assign({}, stylings_1.defaultRowStyle), { padding: { top: 1000, bottom: 1111 } }));
                 }
             });
-            test('should be able to set the style for all rows at once', function () {
-                var e_10, _a;
-                var styledRows = [0, 1, 2, 3, 4];
-                var styledTable = TableStyler_1.TableStyler.fromTableData(formattedTableData)
+            test('should be able to set the style for all rows at once', () => {
+                const styledRows = [0, 1, 2, 3, 4];
+                const styledTable = TableStyler_1.TableStyler.fromTableData(formattedTableData)
                     // an empty array means that all the columns should be styled
                     .withRowStyles([], { padding: { top: 1000, bottom: 1111 } }, 75)
                     .styleTable();
-                try {
-                    for (var styledRows_2 = __values(styledRows), styledRows_2_1 = styledRows_2.next(); !styledRows_2_1.done; styledRows_2_1 = styledRows_2.next()) {
-                        var row = styledRows_2_1.value;
-                        expect(styledTable.rowStyleFor(row).map(function (styling) { return styling.style; }).getOrThrow())
-                            .toEqual(__assign(__assign({}, stylings_1.defaultRowStyle), { padding: { top: 1000, bottom: 1111 } }));
-                    }
-                }
-                catch (e_10_1) { e_10 = { error: e_10_1 }; }
-                finally {
-                    try {
-                        if (styledRows_2_1 && !styledRows_2_1.done && (_a = styledRows_2.return)) _a.call(styledRows_2);
-                    }
-                    finally { if (e_10) throw e_10.error; }
+                for (const row of styledRows) {
+                    expect(styledTable.rowStyleFor(row).map(styling => styling.style).getOrThrow())
+                        .toEqual(Object.assign(Object.assign({}, stylings_1.defaultRowStyle), { padding: { top: 1000, bottom: 1111 } }));
                 }
             });
         });
-        describe('conditionally set styles for cells', function () {
+        describe('conditionally set styles for cells', () => {
             function expectDefaultCellStyleFor(styledTable, row, column) {
                 expect(styledTable.stylesForTableCoordinates(row, column).getOrThrow()).toEqual(stylings_1.defaultCellStyle);
             }
-            test('should be able to set the style for multiple columns at once', function () {
-                var e_11, _a, e_12, _b, e_13, _c;
+            test('should be able to set the style for multiple columns at once', () => {
                 // const styledTable: StyledTable<string> = TableStyler.fromTableData(formattedTableData)
-                var styledTable = TableStyler_1.TableStyler.fromDataFrame(formattedTableData.unwrapDataFrame())
-                    .withCellStyleWhen(function (value, row, column) { return parseInt(value) >= 45678 && column === 2; }, { padding: __assign(__assign({}, stylings_1.defaultTablePadding), { left: 1000, right: 1111 }) }, 75)
+                const styledTable = TableStyler_1.TableStyler.fromDataFrame(formattedTableData.unwrapDataFrame())
+                    .withCellStyleWhen((value, _row, column) => parseInt(value) >= 45678 && column === 2, { padding: Object.assign(Object.assign({}, stylings_1.defaultTablePadding), { left: 1000, right: 1111 }) }, 75)
                     .styleTable();
-                var unstyledColumns = [0, 1, 3, 4];
-                var unstyledRows = [0, 1, 2, 3, 4, 5];
-                try {
-                    for (var unstyledRows_4 = __values(unstyledRows), unstyledRows_4_1 = unstyledRows_4.next(); !unstyledRows_4_1.done; unstyledRows_4_1 = unstyledRows_4.next()) {
-                        var row = unstyledRows_4_1.value;
-                        try {
-                            for (var unstyledColumns_4 = (e_12 = void 0, __values(unstyledColumns)), unstyledColumns_4_1 = unstyledColumns_4.next(); !unstyledColumns_4_1.done; unstyledColumns_4_1 = unstyledColumns_4.next()) {
-                                var column = unstyledColumns_4_1.value;
-                                expectDefaultCellStyleFor(styledTable, row, column);
-                            }
-                        }
-                        catch (e_12_1) { e_12 = { error: e_12_1 }; }
-                        finally {
-                            try {
-                                if (unstyledColumns_4_1 && !unstyledColumns_4_1.done && (_b = unstyledColumns_4.return)) _b.call(unstyledColumns_4);
-                            }
-                            finally { if (e_12) throw e_12.error; }
-                        }
+                const unstyledColumns = [0, 1, 3, 4];
+                const unstyledRows = [0, 1, 2, 3, 4, 5];
+                for (const row of unstyledRows) {
+                    for (const column of unstyledColumns) {
+                        expectDefaultCellStyleFor(styledTable, row, column);
                     }
                 }
-                catch (e_11_1) { e_11 = { error: e_11_1 }; }
-                finally {
-                    try {
-                        if (unstyledRows_4_1 && !unstyledRows_4_1.done && (_a = unstyledRows_4.return)) _a.call(unstyledRows_4);
-                    }
-                    finally { if (e_11) throw e_11.error; }
-                }
                 expectDefaultCellStyleFor(styledTable, 0, 2);
                 expectDefaultCellStyleFor(styledTable, 1, 2);
                 expectDefaultCellStyleFor(styledTable, 2, 2);
                 expectDefaultCellStyleFor(styledTable, 3, 2);
-                try {
-                    for (var _d = __values([4, 5]), _e = _d.next(); !_e.done; _e = _d.next()) {
-                        var row = _e.value;
-                        expect(styledTable.cellStyleFor(row, 2).map(function (styling) { return styling.style; }).getOrThrow())
-                            .toEqual(__assign(__assign({}, stylings_1.defaultCellStyle), { padding: __assign(__assign({}, stylings_1.defaultTablePadding), { left: 1000, right: 1111 }) }));
-                    }
-                }
-                catch (e_13_1) { e_13 = { error: e_13_1 }; }
-                finally {
-                    try {
-                        if (_e && !_e.done && (_c = _d.return)) _c.call(_d);
-                    }
-                    finally { if (e_13) throw e_13.error; }
+                for (const row of [4, 5]) {
+                    expect(styledTable.cellStyleFor(row, 2).map(styling => styling.style).getOrThrow())
+                        .toEqual(Object.assign(Object.assign({}, stylings_1.defaultCellStyle), { padding: Object.assign(Object.assign({}, stylings_1.defaultTablePadding), { left: 1000, right: 1111 }) }));
                 }
             });
         });