@loaders.gl/schema 4.0.0-alpha.4 → 4.0.0-alpha.6

package/dist/lib/table/batches/table-batch-builder.d.ts

@@ -0,0 +1,53 @@
+import type { Schema } from '../../../types/schema';
+import type { TableBatch } from '../../../types/category-table';
+import type { TableBatchConstructor } from './table-batch-aggregator';
+type TableBatchBuilderOptions = {
+    shape: 'row-table' | 'array-row-table' | 'object-row-table' | 'columnar-table' | 'arrow-table';
+    batchSize?: number | 'auto';
+    batchDebounceMs?: number;
+    limit: number;
+    _limitMB: number;
+};
+type GetBatchOptions = {
+    bytesUsed?: number;
+    [key: string]: any;
+};
+/** Incrementally builds batches from a stream of rows */
+export declare class TableBatchBuilder {
+    schema: Schema;
+    options: Required<TableBatchBuilderOptions>;
+    private aggregator;
+    private batchCount;
+    private bytesUsed;
+    private isChunkComplete;
+    private lastBatchEmittedMs;
+    private totalLength;
+    private totalBytes;
+    private rowBytes;
+    static ArrowBatch?: TableBatchConstructor;
+    constructor(schema: Schema, options?: TableBatchBuilderOptions);
+    limitReached(): boolean;
+    /** @deprecated Use addArrayRow or addObjectRow */
+    addRow(row: any[] | {
+        [columnName: string]: any;
+    }): void;
+    /** Add one row to the batch */
+    protected addArrayRow(row: any[]): void;
+    /** Add one row to the batch */
+    protected addObjectRow(row: {
+        [columnName: string]: any;
+    }): void;
+    /** Mark an incoming raw memory chunk has completed */
+    chunkComplete(chunk: ArrayBuffer | string): void;
+    getFullBatch(options?: GetBatchOptions): TableBatch | null;
+    getFinalBatch(options?: GetBatchOptions): TableBatch | null;
+    _estimateRowMB(row: any[] | object): number;
+    private _isFull;
+    /**
+     * bytesUsed can be set via chunkComplete or via getBatch*
+     */
+    private _getBatch;
+    private _getTableBatchType;
+}
+export {};
+//# sourceMappingURL=table-batch-builder.d.ts.map

package/dist/lib/table/batches/table-batch-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-batch-builder.d.ts","sourceRoot":"","sources":["../../../../src/lib/table/batches/table-batch-builder.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,uBAAuB,CAAC;AAClD,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,+BAA+B,CAAC;AAC9D,OAAO,KAAK,EAAuB,qBAAqB,EAAC,MAAM,0BAA0B,CAAC;AAM1F,KAAK,wBAAwB,GAAG;IAC9B,KAAK,EAAE,WAAW,GAAG,iBAAiB,GAAG,kBAAkB,GAAG,gBAAgB,GAAG,aAAa,CAAC;IAC/F,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC5B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,KAAK,eAAe,GAAG;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB,CAAC;AAYF,yDAAyD;AACzD,qBAAa,iBAAiB;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,QAAQ,CAAC,wBAAwB,CAAC,CAAC;IAE5C,OAAO,CAAC,UAAU,CAAqC;IACvD,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,SAAS,CAAa;IAC9B,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,kBAAkB,CAAsB;IAChD,OAAO,CAAC,WAAW,CAAa;IAChC,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,QAAQ,CAAa;IAE7B,MAAM,CAAC,UAAU,CAAC,EAAE,qBAAqB,CAAC;gBAE9B,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,wBAAwB;IAK9D,YAAY,IAAI,OAAO;IAUvB,kDAAkD;IAClD,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG;QAAC,CAAC,UAAU,EAAE,MAAM,GAAG,GAAG,CAAA;KAAC,GAAG,IAAI;IActD,+BAA+B;IAC/B,SAAS,CAAC,WAAW,CAAC,GAAG,EAAE,GAAG,EAAE;IAQhC,+BAA+B;IAC/B,SAAS,CAAC,YAAY,CAAC,GAAG,EAAE;QAAC,CAAC,UAAU,EAAE,MAAM,GAAG,GAAG,CAAA;KAAC,GAAG,IAAI;IAQ9D,sDAAsD;IACtD,aAAa,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,GAAG,IAAI;IAUhD,YAAY,CAAC,OAAO,CAAC,EAAE,eAAe,GAAG,UAAU,GAAG,IAAI;IAI1D,aAAa,CAAC,OAAO,CAAC,EAAE,eAAe,GAAG,UAAU,GAAG,IAAI;IAM3D,cAAc,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,MAAM,GAAG,MAAM;IAI3C,OAAO,CAAC,OAAO;IA2Bf;;OAEG;IACH,OAAO,CAAC,SAAS;IAmBjB,OAAO,CAAC,kBAAkB;CAkB3B"}

package/dist/lib/table/batches/table-batch-builder.js

@@ -0,0 +1,152 @@
+"use strict";
+// loaders.gl, MIT license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableBatchBuilder = void 0;
+const base_table_batch_aggregator_1 = require("./base-table-batch-aggregator");
+const row_table_batch_aggregator_1 = require("./row-table-batch-aggregator");
+const columnar_table_batch_aggregator_1 = require("./columnar-table-batch-aggregator");
+const DEFAULT_OPTIONS = {
+    shape: 'array-row-table',
+    batchSize: 'auto',
+    batchDebounceMs: 0,
+    limit: 0,
+    _limitMB: 0
+};
+const ERR_MESSAGE = 'TableBatchBuilder';
+/** Incrementally builds batches from a stream of rows */
+class TableBatchBuilder {
+    constructor(schema, options) {
+        this.aggregator = null;
+        this.batchCount = 0;
+        this.bytesUsed = 0;
+        this.isChunkComplete = false;
+        this.lastBatchEmittedMs = Date.now();
+        this.totalLength = 0;
+        this.totalBytes = 0;
+        this.rowBytes = 0;
+        this.schema = schema;
+        this.options = { ...DEFAULT_OPTIONS, ...options };
+    }
+    limitReached() {
+        if (Boolean(this.options?.limit) && this.totalLength >= this.options.limit) {
+            return true;
+        }
+        if (Boolean(this.options?._limitMB) && this.totalBytes / 1e6 >= this.options._limitMB) {
+            return true;
+        }
+        return false;
+    }
+    /** @deprecated Use addArrayRow or addObjectRow */
+    addRow(row) {
+        if (this.limitReached()) {
+            return;
+        }
+        this.totalLength++;
+        this.rowBytes = this.rowBytes || this._estimateRowMB(row);
+        this.totalBytes += this.rowBytes;
+        if (Array.isArray(row)) {
+            this.addArrayRow(row);
+        }
+        else {
+            this.addObjectRow(row);
+        }
+    }
+    /** Add one row to the batch */
+    addArrayRow(row) {
+        if (!this.aggregator) {
+            const TableBatchType = this._getTableBatchType();
+            this.aggregator = new TableBatchType(this.schema, this.options);
+        }
+        this.aggregator.addArrayRow(row);
+    }
+    /** Add one row to the batch */
+    addObjectRow(row) {
+        if (!this.aggregator) {
+            const TableBatchType = this._getTableBatchType();
+            this.aggregator = new TableBatchType(this.schema, this.options);
+        }
+        this.aggregator.addObjectRow(row);
+    }
+    /** Mark an incoming raw memory chunk has completed */
+    chunkComplete(chunk) {
+        if (chunk instanceof ArrayBuffer) {
+            this.bytesUsed += chunk.byteLength;
+        }
+        if (typeof chunk === 'string') {
+            this.bytesUsed += chunk.length;
+        }
+        this.isChunkComplete = true;
+    }
+    getFullBatch(options) {
+        return this._isFull() ? this._getBatch(options) : null;
+    }
+    getFinalBatch(options) {
+        return this._getBatch(options);
+    }
+    // INTERNAL
+    _estimateRowMB(row) {
+        return Array.isArray(row) ? row.length * 8 : Object.keys(row).length * 8;
+    }
+    _isFull() {
+        // No batch, not ready
+        if (!this.aggregator || this.aggregator.rowCount() === 0) {
+            return false;
+        }
+        // if batchSize === 'auto' we wait for chunk to complete
+        // if batchSize === number, ensure we have enough rows
+        if (this.options.batchSize === 'auto') {
+            if (!this.isChunkComplete) {
+                return false;
+            }
+        }
+        else if (this.options.batchSize > this.aggregator.rowCount()) {
+            return false;
+        }
+        // Debounce batches
+        if (this.options.batchDebounceMs > Date.now() - this.lastBatchEmittedMs) {
+            return false;
+        }
+        // Emit batch
+        this.isChunkComplete = false;
+        this.lastBatchEmittedMs = Date.now();
+        return true;
+    }
+    /**
+     * bytesUsed can be set via chunkComplete or via getBatch*
+     */
+    _getBatch(options) {
+        if (!this.aggregator) {
+            return null;
+        }
+        // TODO - this can overly increment bytes used?
+        if (options?.bytesUsed) {
+            this.bytesUsed = options.bytesUsed;
+        }
+        const normalizedBatch = this.aggregator.getBatch();
+        normalizedBatch.count = this.batchCount;
+        normalizedBatch.bytesUsed = this.bytesUsed;
+        Object.assign(normalizedBatch, options);
+        this.batchCount++;
+        this.aggregator = null;
+        return normalizedBatch;
+    }
+    _getTableBatchType() {
+        switch (this.options.shape) {
+            case 'row-table':
+                return base_table_batch_aggregator_1.BaseTableBatchAggregator;
+            case 'array-row-table':
+            case 'object-row-table':
+                return row_table_batch_aggregator_1.RowTableBatchAggregator;
+            case 'columnar-table':
+                return columnar_table_batch_aggregator_1.ColumnarTableBatchAggregator;
+            case 'arrow-table':
+                if (!TableBatchBuilder.ArrowBatch) {
+                    throw new Error(ERR_MESSAGE);
+                }
+                return TableBatchBuilder.ArrowBatch;
+            default:
+                throw new Error(ERR_MESSAGE);
+        }
+    }
+}
+exports.TableBatchBuilder = TableBatchBuilder;

package/dist/lib/table/simple-table/convert-table.d.ts

@@ -0,0 +1,8 @@
+import { Table, ArrayRowTable, ObjectRowTable, ColumnarTable } from '../../../types/category-table';
+/** Convert any simple table into columnar format */
+export declare function makeColumnarTable(table: Table): ColumnarTable;
+/** Convert any table into array row format */
+export declare function makeArrayRowTable(table: Table): ArrayRowTable;
+/** Convert any table into object row format */
+export declare function makeObjectRowTable(table: Table): ObjectRowTable;
+//# sourceMappingURL=convert-table.d.ts.map

package/dist/lib/table/simple-table/convert-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-table.d.ts","sourceRoot":"","sources":["../../../../src/lib/table/simple-table/convert-table.ts"],"names":[],"mappings":"AAOA,OAAO,EAAC,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,aAAa,EAAC,MAAM,+BAA+B,CAAC;AAIlG,oDAAoD;AACpD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,KAAK,GAAG,aAAa,CAyB7D;AAED,8CAA8C;AAC9C,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,KAAK,GAAG,aAAa,CAc7D;AAED,+CAA+C;AAC/C,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,KAAK,GAAG,cAAc,CAc/D"}

package/dist/lib/table/simple-table/convert-table.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeObjectRowTable = exports.makeArrayRowTable = exports.makeColumnarTable = void 0;
+// loaders.gl, MIT license
+const table_accessors_1 = require("./table-accessors");
+const table_schema_1 = require("./table-schema");
+const table_column_1 = require("./table-column");
+/** Convert any simple table into columnar format */
+function makeColumnarTable(table) {
+    // TODO - should schema really be optional?
+    const schema = table.schema || (0, table_schema_1.deduceTableSchema)(table);
+    const fields = table.schema?.fields || [];
+    if (table.shape === 'columnar-table') {
+        return { ...table, schema };
+    }
+    const length = (0, table_accessors_1.getTableLength)(table);
+    const columns = {};
+    for (const field of fields) {
+        const column = (0, table_column_1.makeColumnFromField)(field, length);
+        columns[field.name] = column;
+        for (let rowIndex = 0; rowIndex < length; rowIndex++) {
+            column[rowIndex] = (0, table_accessors_1.getTableCell)(table, rowIndex, field.name);
+        }
+    }
+    return {
+        shape: 'columnar-table',
+        schema,
+        data: columns
+    };
+}
+exports.makeColumnarTable = makeColumnarTable;
+/** Convert any table into array row format */
+function makeArrayRowTable(table) {
+    if (table.shape === 'array-row-table') {
+        return table;
+    }
+    const length = (0, table_accessors_1.getTableLength)(table);
+    const data = new Array(length);
+    for (let rowIndex = 0; rowIndex < length; rowIndex++) {
+        data[rowIndex] = (0, table_accessors_1.getTableRowAsArray)(table, rowIndex);
+    }
+    return {
+        shape: 'array-row-table',
+        schema: table.schema,
+        data
+    };
+}
+exports.makeArrayRowTable = makeArrayRowTable;
+/** Convert any table into object row format */
+function makeObjectRowTable(table) {
+    if (table.shape === 'object-row-table') {
+        return table;
+    }
+    const length = (0, table_accessors_1.getTableLength)(table);
+    const data = new Array(length);
+    for (let rowIndex = 0; rowIndex < length; rowIndex++) {
+        data[rowIndex] = (0, table_accessors_1.getTableRowAsObject)(table, rowIndex);
+    }
+    return {
+        shape: 'object-row-table',
+        schema: table.schema,
+        data
+    };
+}
+exports.makeObjectRowTable = makeObjectRowTable;

package/dist/lib/table/simple-table/data-type.d.ts

@@ -0,0 +1,17 @@
+import { DataType } from '../../../types/schema';
+import { TypedArray, TypedArrayConstructor, ArrayType } from '../../../types/types';
+/** Deduce column types from values */
+export declare function getDataTypeFromValue(value: unknown, defaultNumberType?: 'float32'): DataType;
+/**
+ * Deduces a simple data type "descriptor from a typed array instance
+ */
+export declare function getDataTypeFromArray(array: ArrayType): {
+    type: DataType;
+    nullable: boolean;
+};
+/**
+ * Deduces a simple data type "descriptor from a typed array instance
+ */
+export declare function getDataTypeFromTypedArray(array: TypedArray): DataType;
+export declare function getArrayTypeFromDataType(type: DataType, nullable: boolean | undefined): TypedArrayConstructor | ArrayConstructor;
+//# sourceMappingURL=data-type.d.ts.map

package/dist/lib/table/simple-table/data-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-type.d.ts","sourceRoot":"","sources":["../../../../src/lib/table/simple-table/data-type.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,QAAQ,EAAC,MAAM,uBAAuB,CAAC;AAC/C,OAAO,EAAC,UAAU,EAAE,qBAAqB,EAAE,SAAS,EAAC,MAAM,sBAAsB,CAAC;AAElF,sCAAsC;AACtC,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,OAAO,EACd,iBAAiB,GAAE,SAAqB,GACvC,QAAQ,CAcV;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,SAAS,GAAG;IAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAC,CAW1F;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,UAAU,GAAG,QAAQ,CAsBrE;AAED,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,OAAO,GAAG,SAAS,GAC5B,qBAAqB,GAAG,gBAAgB,CA8B1C"}

package/dist/lib/table/simple-table/data-type.js

@@ -0,0 +1,93 @@
+"use strict";
+// loaders.gl, MIT license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getArrayTypeFromDataType = exports.getDataTypeFromTypedArray = exports.getDataTypeFromArray = exports.getDataTypeFromValue = void 0;
+/** Deduce column types from values */
+function getDataTypeFromValue(value, defaultNumberType = 'float32') {
+    if (value instanceof Date) {
+        return 'date-millisecond';
+    }
+    if (value instanceof Number) {
+        return defaultNumberType;
+    }
+    if (typeof value === 'string') {
+        return 'utf8';
+    }
+    if (value === null || value === 'undefined') {
+        return 'null';
+    }
+    return 'null';
+}
+exports.getDataTypeFromValue = getDataTypeFromValue;
+/**
+ * Deduces a simple data type "descriptor from a typed array instance
+ */
+function getDataTypeFromArray(array) {
+    let type = getDataTypeFromTypedArray(array);
+    if (type !== 'null') {
+        return { type, nullable: false };
+    }
+    if (array.length > 0) {
+        type = getDataTypeFromValue(array[0]);
+        return { type, nullable: true };
+    }
+    return { type: 'null', nullable: true };
+}
+exports.getDataTypeFromArray = getDataTypeFromArray;
+/**
+ * Deduces a simple data type "descriptor from a typed array instance
+ */
+function getDataTypeFromTypedArray(array) {
+    switch (array.constructor) {
+        case Int8Array:
+            return 'int8';
+        case Uint8Array:
+        case Uint8ClampedArray:
+            return 'uint8';
+        case Int16Array:
+            return 'int16';
+        case Uint16Array:
+            return 'uint16';
+        case Int32Array:
+            return 'int32';
+        case Uint32Array:
+            return 'uint32';
+        case Float32Array:
+            return 'float32';
+        case Float64Array:
+            return 'float64';
+        default:
+            return 'null';
+    }
+}
+exports.getDataTypeFromTypedArray = getDataTypeFromTypedArray;
+function getArrayTypeFromDataType(type, nullable) {
+    if (!nullable) {
+        switch (type) {
+            case 'int8':
+                return Int8Array;
+            case 'uint8':
+                return Uint8Array;
+            case 'int16':
+                return Int16Array;
+            case 'uint16':
+                return Uint16Array;
+            case 'int32':
+                return Int32Array;
+            case 'uint32':
+                return Uint32Array;
+            case 'float32':
+                return Float32Array;
+            case 'float64':
+                return Float64Array;
+            default:
+                break;
+        }
+    }
+    // if (typeof BigInt64Array !== 'undefined') {
+    //   TYPED_ARRAY_TO_TYPE.BigInt64Array = new Int64();
+    //   TYPED_ARRAY_TO_TYPE.BigUint64Array = new Uint64();
+    // }
+    return Array;
+}
+exports.getArrayTypeFromDataType = getArrayTypeFromDataType;

package/dist/lib/table/simple-table/make-table.d.ts

@@ -0,0 +1,65 @@
+import { ArrayRowTable, ObjectRowTable, ColumnarTable } from '../../../types/category-table';
+/**
+ * Makes a typed table from data.
+ * @throws Row tables must contain at least one row. Columnar tables must contain empty arrays
+ */
+export declare function makeTableFromData(data: unknown[][]): ArrayRowTable;
+export declare function makeTableFromData(data: {
+    [column: string]: unknown;
+}[]): ObjectRowTable;
+export declare function makeTableFromData(data: {
+    [column: string]: ArrayLike<unknown>;
+}): ColumnarTable;
+/** Convert any table into object row format *
+export function makeColumnarTable(table: Table): ColumnarTable {
+  if (table.shape === 'columnar-table') {
+    return table;
+  }
+  const length = getTableLength(table);
+  const data = new Array<{[key: string]: unknown}>(length);
+  for (let rowIndex = 0; rowIndex < length; rowIndex++) {
+    data[rowIndex] = getTableRowAsObject(table, rowIndex);
+  }
+  return {
+    shape: 'columnar-table',
+    schema: table.schema,
+    data
+  };
+}
+
+
+/** Convert any table into array row format *
+export function makeArrayRowTable(table: TableLike): ArrayRowTable {
+  if (table.shape === 'array-row-table') {
+    return table;
+  }
+  const length = getTableLength(table);
+  const data = new Array<unknown[]>(length);
+  for (let rowIndex = 0; rowIndex < length; rowIndex++) {
+    data[rowIndex] = getTableRowAsArray(table, rowIndex);
+  }
+  return {
+    shape: 'array-row-table',
+    schema: table.schema,
+    data
+  };
+}
+
+/** Convert any table into object row format *
+export function makeObjectRowTable(table: Table): ObjectRowTable {
+  if (table.shape === 'object-row-table') {
+    return table;
+  }
+  const length = getTableLength(table);
+  const data = new Array<{[key: string]: unknown}>(length);
+  for (let rowIndex = 0; rowIndex < length; rowIndex++) {
+    data[rowIndex] = getTableRowAsObject(table, rowIndex);
+  }
+  return {
+    shape: 'object-row-table',
+    schema: table.schema,
+    data
+  };
+}
+*/
+//# sourceMappingURL=make-table.d.ts.map

package/dist/lib/table/simple-table/make-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"make-table.d.ts","sourceRoot":"","sources":["../../../../src/lib/table/simple-table/make-table.ts"],"names":[],"mappings":"AACA,OAAO,EAAQ,aAAa,EAAE,cAAc,EAAE,aAAa,EAAC,MAAM,+BAA+B,CAAC;AAGlG;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,GAAG,aAAa,CAAC;AACpE,wBAAgB,iBAAiB,CAAC,IAAI,EAAE;IAAC,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAA;CAAC,EAAE,GAAG,cAAc,CAAC;AACvF,wBAAgB,iBAAiB,CAAC,IAAI,EAAE;IAAC,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,OAAO,CAAC,CAAA;CAAC,GAAG,aAAa,CAAC;AA8C/F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmDE"}

package/dist/lib/table/simple-table/make-table.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTableFromData = void 0;
+const table_schema_1 = require("./table-schema");
+function makeTableFromData(data) {
+    let table;
+    switch (getTableShapeFromData(data)) {
+        case 'array-row-table':
+            table = { shape: 'array-row-table', data: data };
+            break;
+        case 'object-row-table':
+            table = { shape: 'object-row-table', data: data };
+            break;
+        case 'columnar-table':
+            table = { shape: 'columnar-table', data: data };
+            break;
+        default:
+            throw new Error('table');
+    }
+    const schema = (0, table_schema_1.deduceTableSchema)(table);
+    return { ...table, schema };
+}
+exports.makeTableFromData = makeTableFromData;
+/** Helper function to get shape of data */
+function getTableShapeFromData(data) {
+    if (Array.isArray(data)) {
+        if (data.length === 0) {
+            throw new Error('cannot deduce type of empty table');
+        }
+        // Deduce the table shape from the first row
+        const firstRow = data[0];
+        if (Array.isArray(firstRow)) {
+            return 'array-row-table';
+        }
+        if (firstRow && typeof firstRow === 'object') {
+            return 'object-row-table';
+        }
+    }
+    if (data && typeof data === 'object') {
+        return 'columnar-table';
+    }
+    throw new Error('invalid table');
+}
+/** Convert any table into object row format *
+export function makeColumnarTable(table: Table): ColumnarTable {
+  if (table.shape === 'columnar-table') {
+    return table;
+  }
+  const length = getTableLength(table);
+  const data = new Array<{[key: string]: unknown}>(length);
+  for (let rowIndex = 0; rowIndex < length; rowIndex++) {
+    data[rowIndex] = getTableRowAsObject(table, rowIndex);
+  }
+  return {
+    shape: 'columnar-table',
+    schema: table.schema,
+    data
+  };
+}
+
+
+/** Convert any table into array row format *
+export function makeArrayRowTable(table: TableLike): ArrayRowTable {
+  if (table.shape === 'array-row-table') {
+    return table;
+  }
+  const length = getTableLength(table);
+  const data = new Array<unknown[]>(length);
+  for (let rowIndex = 0; rowIndex < length; rowIndex++) {
+    data[rowIndex] = getTableRowAsArray(table, rowIndex);
+  }
+  return {
+    shape: 'array-row-table',
+    schema: table.schema,
+    data
+  };
+}
+
+/** Convert any table into object row format *
+export function makeObjectRowTable(table: Table): ObjectRowTable {
+  if (table.shape === 'object-row-table') {
+    return table;
+  }
+  const length = getTableLength(table);
+  const data = new Array<{[key: string]: unknown}>(length);
+  for (let rowIndex = 0; rowIndex < length; rowIndex++) {
+    data[rowIndex] = getTableRowAsObject(table, rowIndex);
+  }
+  return {
+    shape: 'object-row-table',
+    schema: table.schema,
+    data
+  };
+}
+*/

package/dist/lib/table/simple-table/row-utils.d.ts

@@ -0,0 +1,9 @@
+/** Convert an object row to an array row */
+export declare function convertToObjectRow(arrayRow: any[], headers: string[]): {
+    [columnName: string]: any;
+};
+/** Convert an object row to an array row */
+export declare function convertToArrayRow(objectRow: {
+    [columnName: string]: any;
+}, headers: string[]): any[];
+//# sourceMappingURL=row-utils.d.ts.map

package/dist/lib/table/simple-table/row-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"row-utils.d.ts","sourceRoot":"","sources":["../../../../src/lib/table/simple-table/row-utils.ts"],"names":[],"mappings":"AAAA,4CAA4C;AAC5C,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,GAAG,EAAE,EACf,OAAO,EAAE,MAAM,EAAE,GAChB;IAAC,CAAC,UAAU,EAAE,MAAM,GAAG,GAAG,CAAA;CAAC,CAY7B;AAED,4CAA4C;AAC5C,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE;IAAC,CAAC,UAAU,EAAE,MAAM,GAAG,GAAG,CAAA;CAAC,EACtC,OAAO,EAAE,MAAM,EAAE,GAChB,GAAG,EAAE,CAYP"}

package/dist/lib/table/simple-table/row-utils.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToArrayRow = exports.convertToObjectRow = void 0;
+/** Convert an object row to an array row */
+function convertToObjectRow(arrayRow, headers) {
+    if (!arrayRow) {
+        throw new Error('null row');
+    }
+    if (!headers) {
+        throw new Error('no headers');
+    }
+    const objectRow = {};
+    for (let i = 0; i < headers.length; i++) {
+        objectRow[headers[i]] = arrayRow[i];
+    }
+    return objectRow;
+}
+exports.convertToObjectRow = convertToObjectRow;
+/** Convert an object row to an array row */
+function convertToArrayRow(objectRow, headers) {
+    if (!objectRow) {
+        throw new Error('null row');
+    }
+    if (!headers) {
+        throw new Error('no headers');
+    }
+    const arrayRow = new Array(headers.length);
+    for (let i = 0; i < headers.length; i++) {
+        arrayRow[i] = objectRow[headers[i]];
+    }
+    return arrayRow;
+}
+exports.convertToArrayRow = convertToArrayRow;