svg-table 0.0.1 → 0.1.0

package/index.ts

@@ -1,11 +1,3 @@
-export type {
-    GroupSelection,
-    TextSelection,
-    RectSelection,
-    LineSelection,
-    BorderSelection
-} from './d3types'
-
 export type {
     Styling,
     TableStylerProps,
@@ -47,12 +39,12 @@ export {
 export {
     TableData,
     TableTagType
-} from './tableData';
+} from './TableData';
 
 export type {
     Formatter,
     Formatting,
-} from './tableFormatter';
+} from './TableFormatter';
 
 export {
     defaultFormatter,
@@ -60,12 +52,12 @@ export {
     TableFormatterType,
     isFormattingTag,
     TableFormatter
-} from './tableFormatter';
+} from './TableFormatter';
 
 export {
     StyledTable,
     TableStyler
-} from './tableStyler';
+} from './TableStyler';
 
 export type {
     ElementPlacementInfo,
@@ -80,3 +72,12 @@ export {
     createTable,
     tableId,
 } from './tableSvg';
+
+export type {
+    GroupSelection,
+    TextSelection,
+    RectSelection,
+    LineSelection,
+    BorderSelection
+} from './d3types';
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svg-table",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "author": "Rob Philipp",
   "homepage": "https://github.com/robphilipp/svg-table",
   "license": "MIT",
@@ -28,7 +28,7 @@
   "dependencies": {
     "d3": "^7.9.0",
     "result-fn": "^0.2.1",
-    "data-frame-ts": "^1.0.2"
+    "data-frame-ts": "^1.0.3"
   },
   "devDependencies": {
     "@eslint/js": "^9.33.0",

package/tableData.test.ts

@@ -1,5 +1,5 @@
 import {DataFrame} from "data-frame-ts";
-import {TableData} from "./tableData";
+import {TableData} from "./TableData";
 
 
 describe('creating and manipulating table data', () => {

package/tableFormatter.test.ts

@@ -1,6 +1,6 @@
-import {TableData} from "./tableData";
+import {TableData} from "./TableData";
 import {DataFrame} from "data-frame-ts"
-import {TableFormatter, defaultFormatter} from "./tableFormatter";
+import {TableFormatter, defaultFormatter} from "./TableFormatter";
 
 
 describe('creating tables with mixed data types', () => {
@@ -67,10 +67,10 @@ describe('creating tables with mixed data types', () => {
             .flatMap(tableData => TableFormatter.fromTableData(tableData)
                 // 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, defaultFormatter, Infinity)
+                .addRowFormatters([0], defaultFormatter, Infinity)
                 // add the default formatter for the row header, at the highest priority so that
                 // it is the one that applies to the column representing the row header
-                .flatMap(tf => tf.addColumnFormatter(0, defaultFormatter, Infinity))
+                .flatMap(tf => tf.addColumnFormatters([0], defaultFormatter, Infinity))
                 // add the column formatters for each column at the default (lowest) priority
                 // (notice that the columns are shifted by one for the columns because the row-header
                 // occupies the first column (index=0))
@@ -93,6 +93,50 @@ describe('creating tables with mixed data types', () => {
         expect(tableData.hasFooter()).toBeFalsy()
     })
 
+    test('should be able to create a table with string column and row headers and numeric values', () => {
+
+        const expectedData = DataFrame.from<string>([
+            ['2/1/2021', '12345', 'gnm-f234', '123.45', '4'], // overwrite (1, 4) to remove $
+            ['2/2/2021', '23456', 'gnm-g234', '$ 23.45', '5'],
+            ['2/3/2021', '34567', 'gnm-h234', '$ 3.65', '400'], // overwrite (3, 5) to multiply by 10
+            ['2/4/2021', '45678', 'gnm-i234', '$ 314.15', '90'], // overwrite (4, 5) to multiply by 10
+        ]).getOrThrow()
+
+        const tableData = TableData.fromDataFrame<string | number | Date>(data)
+            .withColumnHeader(columnHeader)
+            .flatMap(td => td.withRowHeader(rowHeader))
+            .flatMap(tableData => TableFormatter.fromTableData(tableData)
+                // 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
+                .addRowFormatters([0], defaultFormatter, Infinity)
+                // add the default formatter for the row header, at the highest priority so that
+                // it is the one that applies to the column representing the row header
+                .flatMap(tf => tf.addColumnFormatters([0], defaultFormatter, Infinity))
+                // add the column formatters for each column at the default (lowest) priority
+                // (notice that the columns are shifted by one for the columns because the row-header
+                // occupies the first column (index=0))
+                .flatMap(tf => tf.addColumnFormatter(1, value => (value as Date).toLocaleDateString()))
+                .flatMap(tf => tf.addColumnFormatter(2, value => defaultFormatter(value)))
+                .flatMap(tf => tf.addColumnFormatter(4, value => `$ ${(value as number).toFixed(2)}`))
+                .flatMap(tf => tf.addColumnFormatter(5, value => `${(value as number).toFixed(0)}`))
+                // override the cell formatter for a select set of cells
+                .flatMap(tf => tf.addCellFormatter(1, 4, value => `${(value as number).toFixed(2)}`, 1000))
+                .flatMap(tf => tf.addCellFormatters([[3, 5], [4, 5]], value => `${((value as number) * 10).toFixed(0)}`, 1000))
+                // format the table data and get back a TableData<string>
+                .flatMap(tf => tf.formatTable())
+            )
+            .getOrThrow()
+
+        expect(tableData.columnHeader().getOrThrow()).toEqual(columnHeader)
+        expect(tableData.rowHeader().getOrThrow()).toEqual(rowHeader.map(hdr => defaultFormatter(hdr)))
+        expect(tableData.data().map(df => df.equals(expectedData)).getOrThrow()).toBeTruthy()
+        expect(tableData.tableColumnCount()).toEqual(5 + 1) // data + row-header
+        expect(tableData.tableRowCount()).toEqual(4 + 1) // data + column-header
+        expect(tableData.hasColumnHeader()).toBeTruthy()
+        expect(tableData.hasRowHeader()).toBeTruthy()
+        expect(tableData.hasFooter()).toBeFalsy()
+    })
+
     test('should be report failures when formatting function fails', () => {
         const columnHeader = ['Date-Time', 'Customer ID', 'Product ID', 'Purchase Price', 'Amount']
 

package/tableStyler.test.ts

@@ -1,6 +1,6 @@
-import {TableData} from "./tableData";
+import {TableData} from "./TableData";
 import {DataFrame} from "data-frame-ts"
-import {defaultFormatter, TableFormatter} from "./tableFormatter";
+import {defaultFormatter, TableFormatter} from "./TableFormatter";
 import {
     type Border,
     type CellStyle,
@@ -11,7 +11,7 @@ import {
     defaultColumnStyle,
     defaultDimension,
     defaultFooterStyle,
-    defaultRowHeaderStyle,
+    defaultRowHeaderStyle, defaultRowStyle,
     defaultTableFont,
     defaultTableMargin,
     defaultTablePadding,
@@ -19,7 +19,7 @@ import {
     type RowHeaderStyle,
     type Styling,
 } from "./stylings";
-import {type StyledTable, TableStyler} from "./tableStyler";
+import {type StyledTable, TableStyler} from "./TableStyler";
 
 
 describe('styling data tables', () => {
@@ -32,9 +32,10 @@ describe('styling data tables', () => {
         [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()
     const columnHeader = ['Date-Time', 'Customer ID', 'Product ID', 'Purchase Price', 'Amount']
-    const rowHeader = [1, 2, 3, 4]
+    const rowHeader = [1, 2, 3, 4, 5]
     const footer = ['A', 'B', 'C', 'D', 'E']
 
     describe('adding basic table styles', () => {
@@ -94,6 +95,23 @@ describe('styling data tables', () => {
             test('should be able to retrieve the margin', () => {
                 expect(styledTable.tableMargin()).toEqual({...defaultTableMargin, left: 10, right: 10})
             })
+
+            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', () => {
+                expect(styledTable.hasRowHeader()).toBeTruthy()
+            })
+
+            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', () => {
+                expect(styledTable.hasFooter()).toBeTruthy()
+            })
         })
 
         test('should be able to set and retrieve style for the column header', () => {
@@ -183,26 +201,26 @@ describe('styling data tables', () => {
             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, 6); valid_column_index: [0, 6)")
+                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', () => {
                 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, 6); valid_column_index: [0, 6)")
+                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', () => {
                 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, 6); valid_column_index: [0, 6)")
+                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', () => {
-                const result = styledTable.stylesForTableCoordinates(6, 3)
+                const result = styledTable.stylesForTableCoordinates(7, 3)
                 expect(result.failed).toBeTruthy()
-                expect(result.error).toEqual("(StyledTable::stylesFor) Invalid row and/or column index; row_index: 6; column_index: 3; valid_row_index: [0, 6); valid_column_index: [0, 6)")
+                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', () => {
@@ -264,5 +282,110 @@ describe('styling data tables', () => {
                 } as CellStyle)
             })
         })
+
+        describe('set styles for multiple rows, columns, and cells', () => {
+
+            function expectDefaultCellStyleFor(styledTable: StyledTable<string>, row: number, column: number) {
+                expect(styledTable.stylesForTableCoordinates(row, column).getOrThrow()).toEqual(defaultCellStyle)
+            }
+
+            test('should be able to set the style for multiple columns at once', () => {
+                const styledColumns = [1, 3, 4]
+                const styledTable: StyledTable<string> = TableStyler.fromTableData(formattedTableData)
+                    .withColumnStyles(styledColumns, {padding: {left: 1000, right: 1111}}, 75)
+                    .styleTable()
+                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)
+                    }
+                }
+
+                for (const column of styledColumns) {
+                    expect(styledTable.columnStyleFor(column).map(styling => styling.style).getOrThrow())
+                        .toEqual({...defaultColumnStyle, padding: {left: 1000, right: 1111}})
+                }
+            })
+
+            test('should be able to set the style for all columns at once', () => {
+                const styledColumns = [0, 1, 2, 3, 4, 5]
+                const styledTable: StyledTable<string> = TableStyler.fromTableData(formattedTableData)
+                    // an empty array means that all the columns should be styled
+                    .withColumnStyles([], {padding: {left: 1000, right: 1111}}, 75)
+                    .styleTable()
+
+                for (const column of styledColumns) {
+                    expect(styledTable.columnStyleFor(column).map(styling => styling.style).getOrThrow())
+                        .toEqual({...defaultColumnStyle, padding: {left: 1000, right: 1111}})
+                }
+            })
+
+            test('should be able to set the style for multiple rows at once', () => {
+                const styledRows = [1, 3, 4]
+                const styledTable: StyledTable<string> = TableStyler.fromTableData(formattedTableData)
+                    .withRowStyles(styledRows, {padding: {top: 1000, bottom: 1111}}, 75)
+                    .styleTable()
+                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)
+                    }
+                }
+
+                for (const row of styledRows) {
+                    expect(styledTable.rowStyleFor(row).map(styling => styling.style).getOrThrow())
+                        .toEqual({...defaultRowStyle, padding: {top: 1000, bottom: 1111}})
+                }
+            })
+
+            test('should be able to set the style for all rows at once', () => {
+                const styledRows = [0, 1, 2, 3, 4]
+                const styledTable: StyledTable<string> = TableStyler.fromTableData(formattedTableData)
+                    // an empty array means that all the columns should be styled
+                    .withRowStyles([], {padding: {top: 1000, bottom: 1111}}, 75)
+                    .styleTable()
+
+                for (const row of styledRows) {
+                    expect(styledTable.rowStyleFor(row).map(styling => styling.style).getOrThrow())
+                        .toEqual({...defaultRowStyle, padding: {top: 1000, bottom: 1111}})
+                }
+            })
+        })
+
+        describe('conditionally set styles for cells', () => {
+            function expectDefaultCellStyleFor(styledTable: StyledTable<string>, row: number, column: number) {
+                expect(styledTable.stylesForTableCoordinates(row, column).getOrThrow()).toEqual(defaultCellStyle)
+            }
+
+            test('should be able to set the style for multiple columns at once', () => {
+                // const styledTable: StyledTable<string> = TableStyler.fromTableData(formattedTableData)
+                const styledTable: StyledTable<string> = TableStyler.fromDataFrame(formattedTableData.unwrapDataFrame())
+                    .withCellStyleWhen(
+                        (value, row, column) => parseInt(value) >= 45678 && column === 2,
+                        {padding: {...defaultTablePadding, left: 1000, right: 1111}},
+                        75
+                    )
+                    .styleTable()
+                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)
+                    }
+                }
+                expectDefaultCellStyleFor(styledTable, 0, 2)
+                expectDefaultCellStyleFor(styledTable, 1, 2)
+                expectDefaultCellStyleFor(styledTable, 2, 2)
+                expectDefaultCellStyleFor(styledTable, 3, 2)
+
+                for (const row of [4, 5]) {
+                    expect(styledTable.cellStyleFor(row, 2).map(styling => styling.style).getOrThrow())
+                        .toEqual({...defaultCellStyle, padding: {...defaultTablePadding, left: 1000, right: 1111}})
+                }
+            })
+
+        })
     })
 })

package/tableSvg.ts

@@ -1,9 +1,9 @@
 import {select, type Selection} from 'd3';
 import {type BorderSelection, type GroupSelection, type RectSelection, type TextSelection} from "./d3types";
 import {textHeightOf, textWidthOf} from "./tableUtils";
-import {TableData} from "./tableData";
+import {TableData} from "./TableData";
 import {type Result} from "result-fn";
-import {StyledTable} from "./tableStyler";
+import {StyledTable} from "./TableStyler";
 import {
     BorderLocation,
     type CellStyle,
@@ -16,7 +16,7 @@ import {
     type VerticalTextAlignment
 } from './stylings';
 import {DataFrame} from "data-frame-ts";
-import {defaultFormatting} from "./tableFormatter";
+import {defaultFormatting} from "./TableFormatter";
 
 export type ElementPlacementInfo = {
     cellSelection: RectSelection

package/dist/tableFormatter.d.ts

@@ -1,179 +0,0 @@
-import { DataFrame, type Tag, type TagCoordinate, type TagValue } from "data-frame-ts";
-import { type Result } from "result-fn";
-import { TableData } from "./tableData";
-/**
- * Type representing a formatter function
- */
-export type Formatter<D> = (value: D) => string;
-/**
- * Default formatter that converts a {@link value} of type `V` to a string
- * @param value The value to convert
- * @return a string representation of the {@link value}
- */
-export declare function defaultFormatter<D>(value: D): string;
-export type Formatting<V> = {
-    formatter: Formatter<V>;
-    priority: number;
-};
-export declare function defaultFormatting<D>(): Formatting<D>;
-export declare enum TableFormatterType {
-    CELL = "cell-formatter",
-    COLUMN = "column-formatter",
-    ROW = "row-formatter"
-}
-export declare function isFormattingTag(tag: Tag<TagValue, TagCoordinate>): boolean;
-/**
- * Represents a formatter used to apply row, column, and cell formatting to a data table.
- * This class is used to define custom formatters for specific rows, columns, or cells,
- * with support for priority-based selection of formatters.
- */
-export declare class TableFormatter<V> {
-    private readonly dataFrame;
-    /**
-     * @param dataFrame A data-frame that will be tagged with the row, column, and
-     * cell formatters.
-     * @private
-     */
-    private constructor();
-    /**
-     * Constructs a new {@link TableFormatter} from a {@link TableData} object. Underneath,
-     * this factory method merely unwraps the {@link DataFrame} from the {@link TableData}
-     * and hands it to the constructor.
-     * @param tableData The table data object from which to construct the table formatter
-     * @return A new {@link TableFormatter} based on the {@link TableData}
-     * @see TableFormatter.fromDataFrame
-     */
-    static fromTableData<V>(tableData: TableData<V>): TableFormatter<V>;
-    /**
-     * Constructs a new {@link TableFormatter} from a {@link DataFrame} object
-     * @param dataFrame The data-frame object from which to construct the table formatter
-     * @return A new {@link TableFormatter} based on the {@link DataFrame}
-     @see TableFormatter.fromTableData
-     */
-    static fromDataFrame<V>(dataFrame: DataFrame<V>): TableFormatter<V>;
-    /**
-     * Formatters convert the column value types to formatted strings. The formatter used to format a given
-     * cell depends on the priority of each formatter associated with that cell. The formatter with the
-     * highest priority is used. If two or more formatters for a given cell have the same priority, the selected
-     * formatter is indeterminant.
-     * @param columnIndex The index of the column to which to add the formatter
-     * @param formatter The formatter
-     * @param [priority = 0] The priority of this formatter. If cells have more than one associated formatter,
-     * the one with the highest priority number is used.
-     * @example
-     * ```typescript
-     * // create the data
-     * const data = DataFrame.from<string | number | Date>([
-     *     [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],
-     * ]).getOrThrow()
-     *
-     * // create the table-data object from the data, and then hand the table-data
-     * // to the table formatter, add column formats, and format the table, getting
-     * // back a new TableData<string>
-     * const tableData: TableData<string> = TableData.fromDataFrame<string | number | Date>(data)
-     *     // from the table-data, create a table-formatter
-     *     .flatMap(tableData => createTableFormatterFrom(tableData)
-     *         // add a column formatter for the first column of dates
-     *         .addColumnFormatter(0, value => (value as Date).toLocaleDateString())
-     *         // add a column formatter to the second column of number
-     *         .flatMap(tf => tf.addColumnFormatter(1, value => defaultFormatter(value)))
-     *         // add a column formatter to the fourth column of currencies
-     *         .flatMap(tf => tf.addColumnFormatter(3, value => `$ ${(value as number).toFixed(2)}`))
-     *         .flatMap(tf => tf.addColumnFormatter(4, value => `${(value as number).toFixed(0)}`))
-     *         // format the table into a new TableData<string> object
-     *         .flatMap(tf => tf.formatTable())
-     *     )
-     *     .getOrThrow()
-     *
-     * // we expect the data-frame in the table data to be the following
-     * const expectedData = DataFrame.from<string>([
-     *     ['2/1/2021', '12345', 'gnm-f234', '$ 123.45', '4'],
-     *     ['2/2/2021', '23456', 'gnm-g234', '$ 23.45', '5'],
-     *     ['2/3/2021', '34567', 'GNM-H234', '$ 3.65', '40'],
-     *     ['2/4/2021', '45678', 'gnm-i234', '$ 314.15', '9'],
-     * ]).getOrThrow()
-     * ```
-     */
-    addColumnFormatter(columnIndex: number, formatter: Formatter<V>, priority?: number): Result<TableFormatter<V>, string>;
-    addColumnFormatters(columnIndexes: Array<number>, formatter: Formatter<V>, priority?: number): Result<TableFormatter<V>, string>;
-    private static addColumnFormatters;
-    addRowFormatter(rowIndex: number, formatter: Formatter<V>, priority?: number): Result<TableFormatter<V>, string>;
-    addRowFormatters(rowIndexes: Array<number>, formatter: Formatter<V>, priority?: number): Result<TableFormatter<V>, string>;
-    private static addRowFormatters;
-    addCellFormatter(rowIndex: number, columnIndex: number, formatter: Formatter<V>, priority?: number): Result<TableFormatter<V>, string>;
-    addCellFormatters(cellIndexes: Array<[x: number, y: number]>, formatter: Formatter<V>, priority?: number): Result<TableFormatter<V>, string>;
-    private static addCellFormatters;
-    /**
-     * Formats the table headers, footer, and values using the formatters that have been added
-     * to this `TableData<V>` object and returns a new `TableData<string>` object where all the
-     * elements have been converted to a formatted string.
-     * @return a new `TableData<string>` object where all the elements have been converted to a
-     * formatted string.
-     * @example
-     * ```typescript
-     * function dateTimeFor(day: number, hour: number): Date {
-     *   return new Date(2021, 1, day, hour, 0, 0, 0);
-     * }
-     *
-     * // the headers for the table
-     * const columnHeader = ['Date-Time', 'Customer ID', 'Product ID', 'Purchase Price', 'Amount']
-     * const rowHeader = [1, 2, 3, 4]
-     *
-     * // this is the actual data used to creat the data table (in row-form)
-     * const data = DataFrame.from<string | number | Date>([
-     *     [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],
-     * ]).getOrThrow()
-     *
-     * // this is what we expect that formatted data to look like
-     * const expectedData = DataFrame.from<string>([
-     *     ['2/1/2021', '12345', 'gnm-f234', '$ 123.45',  '4'],
-     *     ['2/2/2021', '23456', 'gnm-g234',  '$ 23.45',  '5'],
-     *     ['2/3/2021', '34567', 'gnm-h234',   '$ 3.65', '40'],
-     *     ['2/4/2021', '45678', 'gnm-i234', '$ 314.15',  '9'],
-     * ]).getOrThrow()
-     *
-     * // 1. create a data-table that has a column-header and a row-header and mixed-type
-     * //    data (number, string, Date)
-     * // 2. add formatters for the row and column headers (at highest priority)
-     * // 3. add formatters for some of the other data columns
-     * // 4. format the table
-     * const tableData = TableData.fromDataFrame<string | number | Date>(data)
-     *     .withColumnHeader(columnHeader)
-     *     .flatMap(table => table.withRowHeader(rowHeader))
-     *     // 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
-     *     .flatMap(td => td.addRowFormatter(0, defaultFormatter, Infinity))
-     *     // add the default formatter for the row header, at the highest priority so that
-     *     // it is the one that applies to the column representing the row header
-     *     .flatMap(td => td.addColumnFormatter(0, defaultFormatter, Infinity))
-     *     // add the column formatters for each column at the default (lowest) priority
-     *     // (notice that the columns are shifted by one for the columns because the row-header
-     *     // occupies the first column (index=0))
-     *     .flatMap(td => td.addColumnFormatter(1, value => (value as Date).toLocaleDateString()))
-     *     .flatMap(td => td.addColumnFormatter(2, value => defaultFormatter(value)))
-     *     .flatMap(td => td.addColumnFormatter(4, value => `$ ${(value as number).toFixed(2)}`))
-     *     .flatMap(td => td.addColumnFormatter(5, value => `${(value as number).toFixed(0)}`))
-     *     // format the table data and get back a TableData<string>
-     *     .map(td => td.formatTable())
-     *     .getOrThrow()
-     *
-     * // the column header of the formatted table should be the same as the one specified
-     * expect(tableData.columnHeader().getOrThrow()).toEqual(columnHeader)
-     *
-     * // the row header of the formatted table should be the same as the one specified
-     * expect(tableData.rowHeader().getOrThrow()).toEqual(rowHeader.map(hdr => defaultFormatter(hdr)))
-     *
-     * // the data should be equal to the expected data
-     * expect(tableData.data().map(df => df.equals(expectedData)).getOrThrow()).toBeTruthy()
-     * ```
-     */
-    formatTable<C extends TagCoordinate>(): Result<TableData<string>, string>;
-    formatTableInto<C extends TagCoordinate, D = TableData<string>>(mapper: (dataFrame: DataFrame<string>) => D): Result<D, string>;
-}
-//# sourceMappingURL=tableFormatter.d.ts.map

package/dist/tableFormatter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tableFormatter.d.ts","sourceRoot":"","sources":["../tableFormatter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,SAAS,EAAE,KAAK,GAAG,EAAE,KAAK,aAAa,EAAE,KAAK,QAAQ,EAAC,MAAM,eAAe,CAAC;AACrF,OAAO,EAAgB,KAAK,MAAM,EAAgB,MAAM,WAAW,CAAC;AACpE,OAAO,EAAC,SAAS,EAAC,MAAM,aAAa,CAAC;AAEtC;;GAEG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,CAAA;AAE/C;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,MAAM,CAEpD;AAED,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI;IACxB,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,CAAA;IACvB,QAAQ,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,wBAAgB,iBAAiB,CAAC,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,CAKpD;AAED,oBAAY,kBAAkB;IAC1B,IAAI,mBAAmB;IACvB,MAAM,qBAAqB;IAC3B,GAAG,kBAAkB;CACxB;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,GAAG,CAAC,QAAQ,EAAE,aAAa,CAAC,GAAG,OAAO,CAM1E;AAED;;;;GAIG;AACH,qBAAa,cAAc,CAAC,CAAC;IAOL,OAAO,CAAC,QAAQ,CAAC,SAAS;IAL9C;;;;OAIG;IACH,OAAO;IAGP;;;;;;;OAOG;IACH,MAAM,CAAC,aAAa,CAAC,CAAC,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC;IAInE;;;;;OAKG;IACH,MAAM,CAAC,aAAa,CAAC,CAAC,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC;IAInE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6CG;IACH,kBAAkB,CAAC,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,QAAQ,GAAE,MAAU,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC;IAMzH,mBAAmB,CAAC,aAAa,EAAE,KAAK,CAAC,MAAM,CAAC,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,QAAQ,GAAE,MAAU,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC;IAInI,OAAO,CAAC,MAAM,CAAC,mBAAmB;IAiBlC,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,QAAQ,GAAE,MAAU,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC;IAMnH,gBAAgB,CAAC,UAAU,EAAE,KAAK,CAAC,MAAM,CAAC,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,QAAQ,GAAE,MAAU,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC;IAI7H,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAiB/B,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,QAAQ,GAAE,MAAU,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC;IAMzI,iBAAiB,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,CAAC,CAAC,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,QAAQ,GAAE,MAAU,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC;IAI/I,OAAO,CAAC,MAAM,CAAC,iBAAiB;IAiBhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkEG;IACH,WAAW,CAAC,CAAC,SAAS,aAAa,KAAK,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAIzE,eAAe,CAAC,CAAC,SAAS,aAAa,EAAE,CAAC,GAAG,SAAS,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC,SAAS,EAAE,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC;CA0BlI"}