@loaders.gl/schema 4.0.0-alpha.5 → 4.0.0-alpha.7

package/dist/lib/table/batches/base-table-batch-aggregator.js

@@ -0,0 +1,60 @@
+"use strict";
+// loaders.gl, MIT license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseTableBatchAggregator = void 0;
+const DEFAULT_ROW_COUNT = 100;
+class BaseTableBatchAggregator {
+    constructor(schema, options) {
+        this.length = 0;
+        this.rows = null;
+        this.cursor = 0;
+        this._headers = [];
+        this.options = options;
+        this.schema = schema;
+        // schema is an array if there're no headers
+        // object if there are headers
+        if (!Array.isArray(schema)) {
+            this._headers = [];
+            for (const key in schema) {
+                this._headers[schema[key].index] = schema[key].name;
+            }
+        }
+    }
+    rowCount() {
+        return this.length;
+    }
+    addArrayRow(row, cursor) {
+        if (Number.isFinite(cursor)) {
+            this.cursor = cursor;
+        }
+        this.rows = this.rows || new Array(DEFAULT_ROW_COUNT);
+        this.rows[this.length] = row;
+        this.length++;
+    }
+    addObjectRow(row, cursor) {
+        if (Number.isFinite(cursor)) {
+            this.cursor = cursor;
+        }
+        this.rows = this.rows || new Array(DEFAULT_ROW_COUNT);
+        this.rows[this.length] = row;
+        this.length++;
+    }
+    getBatch() {
+        let rows = this.rows;
+        if (!rows) {
+            return null;
+        }
+        rows = rows.slice(0, this.length);
+        this.rows = null;
+        const batch = {
+            shape: this.options.shape,
+            batchType: 'data',
+            data: rows,
+            length: this.length,
+            schema: this.schema,
+            cursor: this.cursor
+        };
+        return batch;
+    }
+}
+exports.BaseTableBatchAggregator = BaseTableBatchAggregator;

package/dist/lib/{batches → table/batches}/columnar-table-batch-aggregator.d.ts

@@ -1,8 +1,8 @@
-import type { Schema } from '../schema/schema';
-import type { ColumnarTableBatch, ArrowTableBatch } from '../../category/table/table-types';
+import type { Schema } from '../../../types/schema';
+import type { ColumnarTableBatch, ArrowTableBatch } from '../../../types/category-table';
 import { TableBatchAggregator } from './table-batch-aggregator';
-declare type ColumnarTableBatchOptions = {};
-export default class ColumnarTableBatchAggregator implements TableBatchAggregator {
+type ColumnarTableBatchOptions = {};
+export declare class ColumnarTableBatchAggregator implements TableBatchAggregator {
     schema: Schema;
     length: number;
     allocated: number;

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

@@ -0,0 +1 @@
+{"version":3,"file":"columnar-table-batch-aggregator.d.ts","sourceRoot":"","sources":["../../../../src/lib/table/batches/columnar-table-batch-aggregator.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,uBAAuB,CAAC;AAClD,OAAO,KAAK,EAAC,kBAAkB,EAAE,eAAe,EAAC,MAAM,+BAA+B,CAAC;AACvF,OAAO,EAAC,oBAAoB,EAAC,MAAM,0BAA0B,CAAC;AAE9D,KAAK,yBAAyB,GAAG,EAAE,CAAC;AAIpC,qBAAa,4BAA6B,YAAW,oBAAoB;IACvE,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAK;IACnB,SAAS,EAAE,MAAM,CAAK;IACtB,OAAO,EAAE;QAAC,CAAC,UAAU,EAAE,MAAM,GAAG,GAAG,EAAE,CAAA;KAAC,CAAM;gBAEhC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,yBAAyB;IAK9D,QAAQ,IAAI,MAAM;IAIlB,WAAW,CAAC,GAAG,EAAE,GAAG,EAAE;IAWtB,YAAY,CAAC,GAAG,EAAE;QAAC,CAAC,UAAU,EAAE,MAAM,GAAG,GAAG,CAAA;KAAC,GAAG,IAAI;IASpD,QAAQ,IAAI,kBAAkB,GAAG,eAAe,GAAG,IAAI;IA6BvD,kBAAkB;IA8BlB,aAAa;CAKd"}

package/dist/lib/table/batches/columnar-table-batch-aggregator.js

@@ -0,0 +1,92 @@
+"use strict";
+// loaders.gl, MIT license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColumnarTableBatchAggregator = void 0;
+const DEFAULT_ROW_COUNT = 100;
+class ColumnarTableBatchAggregator {
+    constructor(schema, options) {
+        this.length = 0;
+        this.allocated = 0;
+        this.columns = {};
+        this.schema = schema;
+        this._reallocateColumns();
+    }
+    rowCount() {
+        return this.length;
+    }
+    addArrayRow(row) {
+        // If user keeps pushing rows beyond batch size, reallocate
+        this._reallocateColumns();
+        let i = 0;
+        // TODO what if no csv header, columns not populated?
+        for (const fieldName in this.columns) {
+            this.columns[fieldName][this.length] = row[i++];
+        }
+        this.length++;
+    }
+    addObjectRow(row) {
+        // If user keeps pushing rows beyond batch size, reallocate
+        this._reallocateColumns();
+        for (const fieldName in row) {
+            this.columns[fieldName][this.length] = row[fieldName];
+        }
+        this.length++;
+    }
+    getBatch() {
+        this._pruneColumns();
+        const columns = Array.isArray(this.schema) ? this.columns : {};
+        // schema is an array if there're no headers
+        // object if there are headers
+        // columns should match schema format
+        if (!Array.isArray(this.schema)) {
+            for (const fieldName in this.schema) {
+                const field = this.schema[fieldName];
+                columns[field.name] = this.columns[field.index];
+            }
+        }
+        this.columns = {};
+        const batch = {
+            shape: 'columnar-table',
+            batchType: 'data',
+            data: columns,
+            schema: this.schema,
+            length: this.length
+        };
+        return batch;
+    }
+    // HELPERS
+    _reallocateColumns() {
+        if (this.length < this.allocated) {
+            return;
+        }
+        // @ts-ignore TODO
+        this.allocated = this.allocated > 0 ? (this.allocated *= 2) : DEFAULT_ROW_COUNT;
+        this.columns = {};
+        for (const fieldName in this.schema) {
+            const field = this.schema[fieldName];
+            const ArrayType = field.type || Float32Array;
+            const oldColumn = this.columns[field.index];
+            if (oldColumn && ArrayBuffer.isView(oldColumn)) {
+                // Copy the old data to the new array
+                const typedArray = new ArrayType(this.allocated);
+                typedArray.set(oldColumn);
+                this.columns[field.index] = typedArray;
+            }
+            else if (oldColumn) {
+                // Plain array
+                oldColumn.length = this.allocated;
+                this.columns[field.index] = oldColumn;
+            }
+            else {
+                // Create new
+                this.columns[field.index] = new ArrayType(this.allocated);
+            }
+        }
+    }
+    _pruneColumns() {
+        for (const [columnName, column] of Object.entries(this.columns)) {
+            this.columns[columnName] = column.slice(0, this.length);
+        }
+    }
+}
+exports.ColumnarTableBatchAggregator = ColumnarTableBatchAggregator;

package/dist/lib/{batches → table/batches}/row-table-batch-aggregator.d.ts

@@ -1,7 +1,7 @@
-import type { Schema } from '../schema/schema';
-import type { TableBatch } from '../../category/table/table-types';
+import type { Schema } from '../../../types/schema';
+import type { TableBatch } from '../../../types/category-table';
 import { TableBatchAggregator, TableBatchOptions } from './table-batch-aggregator';
-export default class RowTableBatchAggregator implements TableBatchAggregator {
+export declare class RowTableBatchAggregator implements TableBatchAggregator {
     schema: Schema;
     options: TableBatchOptions;
     length: number;

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

@@ -0,0 +1 @@
+{"version":3,"file":"row-table-batch-aggregator.d.ts","sourceRoot":"","sources":["../../../../src/lib/table/batches/row-table-batch-aggregator.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,uBAAuB,CAAC;AAClD,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,+BAA+B,CAAC;AAG9D,OAAO,EAAC,oBAAoB,EAAE,iBAAiB,EAAC,MAAM,0BAA0B,CAAC;AAIjF,qBAAa,uBAAwB,YAAW,oBAAoB;IAClE,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,iBAAiB,CAAC;IAE3B,MAAM,EAAE,MAAM,CAAK;IACnB,UAAU,EAAE;QAAC,CAAC,UAAU,EAAE,MAAM,GAAG,GAAG,CAAA;KAAC,GAAG,IAAI,CAAQ;IACtD,SAAS,EAAE,GAAG,EAAE,GAAG,IAAI,CAAQ;IAC/B,MAAM,EAAE,MAAM,CAAK;IACnB,OAAO,CAAC,QAAQ,CAAgB;gBAEpB,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB;IActD,QAAQ,IAAI,MAAM;IAIlB,WAAW,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI;IAmB9C,YAAY,CAAC,GAAG,EAAE;QAAC,CAAC,UAAU,EAAE,MAAM,GAAG,GAAG,CAAA;KAAC,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI;IAmBrE,QAAQ,IAAI,UAAU,GAAG,IAAI;CAmB9B"}

package/dist/lib/table/batches/row-table-batch-aggregator.js

@@ -0,0 +1,81 @@
+"use strict";
+// loaders.gl, MIT license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RowTableBatchAggregator = void 0;
+// import type {ArrayRowTableBatch, ObjectRowTableBatch} from '../../category/table.js';
+const row_utils_1 = require("../simple-table/row-utils");
+const DEFAULT_ROW_COUNT = 100;
+class RowTableBatchAggregator {
+    constructor(schema, options) {
+        this.length = 0;
+        this.objectRows = null;
+        this.arrayRows = null;
+        this.cursor = 0;
+        this._headers = [];
+        this.options = options;
+        this.schema = schema;
+        // schema is an array if there're no headers
+        // object if there are headers
+        if (!Array.isArray(schema)) {
+            this._headers = [];
+            for (const key in schema) {
+                this._headers[schema[key].index] = schema[key].name;
+            }
+        }
+    }
+    rowCount() {
+        return this.length;
+    }
+    addArrayRow(row, cursor) {
+        if (Number.isFinite(cursor)) {
+            this.cursor = cursor;
+        }
+        // eslint-disable-next-line default-case
+        switch (this.options.shape) {
+            case 'object-row-table':
+                const rowObject = (0, row_utils_1.convertToObjectRow)(row, this._headers);
+                this.addObjectRow(rowObject, cursor);
+                break;
+            case 'array-row-table':
+                this.arrayRows = this.arrayRows || new Array(DEFAULT_ROW_COUNT);
+                this.arrayRows[this.length] = row;
+                this.length++;
+                break;
+        }
+    }
+    addObjectRow(row, cursor) {
+        if (Number.isFinite(cursor)) {
+            this.cursor = cursor;
+        }
+        // eslint-disable-next-line default-case
+        switch (this.options.shape) {
+            case 'array-row-table':
+                const rowArray = (0, row_utils_1.convertToArrayRow)(row, this._headers);
+                this.addArrayRow(rowArray, cursor);
+                break;
+            case 'object-row-table':
+                this.objectRows = this.objectRows || new Array(DEFAULT_ROW_COUNT);
+                this.objectRows[this.length] = row;
+                this.length++;
+                break;
+        }
+    }
+    getBatch() {
+        let rows = this.arrayRows || this.objectRows;
+        if (!rows) {
+            return null;
+        }
+        rows = rows.slice(0, this.length);
+        this.arrayRows = null;
+        this.objectRows = null;
+        return {
+            shape: this.options.shape,
+            batchType: 'data',
+            data: rows,
+            length: this.length,
+            schema: this.schema,
+            cursor: this.cursor
+        };
+    }
+}
+exports.RowTableBatchAggregator = RowTableBatchAggregator;

package/dist/lib/{batches → table/batches}/table-batch-aggregator.d.ts

@@ -1,5 +1,5 @@
-import type { Schema } from '../schema/schema';
-import type { TableBatch } from '../../category/table/table-types';
+import type { Schema } from '../../../types/schema';
+import type { TableBatch } from '../../../types/category-table';
 export interface TableBatchOptions {
     batchSize: number | string;
     [key: string]: any;

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

@@ -0,0 +1 @@
+{"version":3,"file":"table-batch-aggregator.d.ts","sourceRoot":"","sources":["../../../../src/lib/table/batches/table-batch-aggregator.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,uBAAuB,CAAC;AAClD,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,+BAA+B,CAAC;AAE9D,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC;IAC3B,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED,MAAM,WAAW,qBAAqB;IACpC,KAAK,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,GAAG,oBAAoB,CAAC;CACxE;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,qBAAqB;IACrB,QAAQ,IAAI,MAAM,CAAC;IACnB,kBAAkB;IAClB,WAAW,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;IAC9B,kBAAkB;IAClB,YAAY,CAAC,GAAG,EAAE;QAAC,CAAC,UAAU,EAAE,MAAM,GAAG,GAAG,CAAA;KAAC,GAAG,IAAI,CAAC;IACrD,4BAA4B;IAC5B,QAAQ,IAAI,UAAU,GAAG,IAAI,CAAC;CAC/B"}

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

@@ -0,0 +1,3 @@
+"use strict";
+// loaders.gl, MIT license
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,19 +1,19 @@
-import type { Schema } from '../schema/schema';
-import type { TableBatch } from '../../category/table/table-types';
+import type { Schema } from '../../../types/schema';
+import type { TableBatch } from '../../../types/category-table';
 import type { TableBatchConstructor } from './table-batch-aggregator';
-declare type TableBatchBuilderOptions = {
+type TableBatchBuilderOptions = {
     shape: 'row-table' | 'array-row-table' | 'object-row-table' | 'columnar-table' | 'arrow-table';
     batchSize?: number | 'auto';
     batchDebounceMs?: number;
     limit: number;
     _limitMB: number;
 };
-declare type GetBatchOptions = {
+type GetBatchOptions = {
     bytesUsed?: number;
     [key: string]: any;
 };
 /** Incrementally builds batches from a stream of rows */
-export default class TableBatchBuilder {
+export declare class TableBatchBuilder {
     schema: Schema;
     options: Required<TableBatchBuilderOptions>;
     private aggregator;

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;