@loaders.gl/schema 4.0.0-alpha.1 → 4.0.0-alpha.11

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

@@ -0,0 +1,67 @@
+import { Table, ArrayRowTable, ObjectRowTable } from '../../../types/category-table';
+/**
+ * Returns the length of the table (i.e. the number of rows)
+ */
+export declare function getTableLength(table: Table): number;
+/**
+ * Returns the number of columns in the table
+ * @throws Fails to deduce number of columns if the table has no schema and is empty
+ */
+export declare function getTableNumCols(table: Table): number;
+/** Get a table cell value at row index and column name */
+export declare function getTableCell(table: Table, rowIndex: number, columnName: string): unknown;
+/** Get a table cell value at row index and column name */
+export declare function getTableCellAt(table: Table, rowIndex: number, columnIndex: number): unknown;
+/** Deduce the table row shape */
+export declare function getTableRowShape(table: Table): 'array-row-table' | 'object-row-table';
+/** Get the index of a named table column. Requires the table to have a schema */
+export declare function getTableColumnIndex(table: Table, columnName: string): number;
+/** Get the name of a table column by index. Requires the table to have a schema */
+export declare function getTableColumnName(table: Table, columnIndex: number): string;
+/**
+ * Returns one row of the table in object format.
+ * @param target Optional parameter will be used if needed to store the row. Can be reused between calls to improve performance
+ * @returns an array representing the row. May be the original array in the row, a new object, or the target parameter
+ */
+export declare function getTableRowAsObject(table: Table, rowIndex: number, target?: {
+    [columnName: string]: unknown;
+}, copy?: 'copy'): {
+    [columnName: string]: unknown;
+};
+/**
+ * Returns one row of the table in array format.
+ * @param target Optional parameter will be used if needed to store the row. Can be reused between calls to improve performance.
+ * @returns an array representing the row. May be the original array in the row, a new object, or the target parameter
+ */
+export declare function getTableRowAsArray(table: Table, rowIndex: number, target?: unknown[], copy?: 'copy'): unknown[];
+/** 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;
+/** Convert any table into object row format */
+export declare function makeColumnarTable(table: Table): ObjectRowTable;
+/**
+ * Iterate over table rows
+ * @param table
+ * @param shape
+ */
+export declare function makeRowIterator(table: Table, shape: 'object-row-table' | 'array-row-table'): Iterable<unknown[] | {
+    [key: string]: unknown;
+}>;
+/**
+ * Streaming processing: Iterate over table, yielding array rows
+ * @param table
+ * @param shape
+ */
+export declare function makeArrayRowIterator(table: Table, target?: unknown[]): Iterable<unknown[]>;
+/**
+ * Streaming processing: Iterate over table, yielding object rows
+ * @param table
+ * @param shape
+ */
+export declare function makeObjectRowIterator(table: Table, target?: {
+    [key: string]: unknown;
+}): Iterable<{
+    [key: string]: unknown;
+}>;
+//# sourceMappingURL=table-accessors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"table-accessors.d.ts","sourceRoot":"","sources":["../../../../src/lib/table/simple-table/table-accessors.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,KAAK,EAAE,aAAa,EAAE,cAAc,EAAC,MAAM,+BAA+B,CAAC;AAEnF;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAkBnD;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAsBpD;AAED,0DAA0D;AAC1D,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAuBxF;AAED,0DAA0D;AAC1D,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAqB3F;AAED,iCAAiC;AACjC,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,KAAK,GAAG,iBAAiB,GAAG,kBAAkB,CAarF;AAED,iFAAiF;AACjF,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAM5E;AAED,mFAAmF;AACnF,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAM5E;AAED;;;;GAIG;AAEH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,MAAM,EAChB,MAAM,CAAC,EAAE;IAAC,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAA;CAAC,EACxC,IAAI,CAAC,EAAE,MAAM,GACZ;IAAC,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAA;CAAC,CA6CjC;AAED;;;;GAIG;AAEH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,MAAM,EAChB,MAAM,CAAC,EAAE,OAAO,EAAE,EAClB,IAAI,CAAC,EAAE,MAAM,GACZ,OAAO,EAAE,CA+CX;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;AAED,+CAA+C;AAC/C,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,KAAK,GAAG,cAAc,CAc9D;AAID;;;;GAIG;AACH,wBAAiB,eAAe,CAC9B,KAAK,EAAE,KAAK,EACZ,KAAK,EAAE,kBAAkB,GAAG,iBAAiB,GAC5C,QAAQ,CAAC,OAAO,EAAE,GAAG;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAC,CAAC,CAYhD;AAED;;;;GAIG;AACH,wBAAiB,oBAAoB,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,GAAE,OAAO,EAAO,GAAG,QAAQ,CAAC,OAAO,EAAE,CAAC,CAK/F;AAED;;;;GAIG;AACH,wBAAiB,qBAAqB,CACpC,KAAK,EAAE,KAAK,EACZ,MAAM,GAAE;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAM,GACpC,QAAQ,CAAC;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAC,CAAC,CAKpC"}

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

@@ -0,0 +1,319 @@
+"use strict";
+// loaders.gl, MIT license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeObjectRowIterator = exports.makeArrayRowIterator = exports.makeRowIterator = exports.makeColumnarTable = exports.makeObjectRowTable = exports.makeArrayRowTable = exports.getTableRowAsArray = exports.getTableRowAsObject = exports.getTableColumnName = exports.getTableColumnIndex = exports.getTableRowShape = exports.getTableCellAt = exports.getTableCell = exports.getTableNumCols = exports.getTableLength = void 0;
+/**
+ * Returns the length of the table (i.e. the number of rows)
+ */
+function getTableLength(table) {
+    switch (table.shape) {
+        case 'array-row-table':
+        case 'object-row-table':
+        case 'geojson-row-table':
+            return table.data.length;
+        case 'arrow-table':
+            return table.data.numRows;
+        case 'columnar-table':
+            for (const column of Object.values(table.data)) {
+                return column.length || 0;
+            }
+            return 0;
+        default:
+            throw new Error('table');
+    }
+}
+exports.getTableLength = getTableLength;
+/**
+ * Returns the number of columns in the table
+ * @throws Fails to deduce number of columns if the table has no schema and is empty
+ */
+function getTableNumCols(table) {
+    if (table.schema) {
+        return table.schema.fields.length;
+    }
+    if (getTableLength(table) === 0) {
+        throw new Error('empty table');
+    }
+    switch (table.shape) {
+        case 'array-row-table':
+            return table.data[0].length;
+        case 'object-row-table':
+        case 'geojson-row-table':
+            return Object.keys(table.data[0]).length;
+        case 'columnar-table':
+            return Object.keys(table.data).length;
+        case 'arrow-table':
+            return table.data.numCols;
+        default:
+            throw new Error('table');
+    }
+}
+exports.getTableNumCols = getTableNumCols;
+/** Get a table cell value at row index and column name */
+function getTableCell(table, rowIndex, columnName) {
+    switch (table.shape) {
+        case 'array-row-table':
+            const columnIndex = getTableColumnIndex(table, columnName);
+            return table.data[rowIndex][columnIndex];
+        case 'object-row-table':
+        case 'geojson-row-table':
+            return table.data[rowIndex][columnName];
+        case 'columnar-table':
+            const column = table.data[columnName];
+            return column[rowIndex];
+        case 'arrow-table':
+            const arrowColumnIndex = table.data.schema.fields.findIndex((field) => field.name === columnName);
+            return table.data.getChildAt(arrowColumnIndex)?.get(rowIndex);
+        default:
+            throw new Error('todo');
+    }
+}
+exports.getTableCell = getTableCell;
+/** Get a table cell value at row index and column name */
+function getTableCellAt(table, rowIndex, columnIndex) {
+    switch (table.shape) {
+        case 'array-row-table':
+            return table.data[rowIndex][columnIndex];
+        case 'object-row-table':
+        case 'geojson-row-table':
+            let columnName = getTableColumnName(table, columnIndex);
+            return table.data[rowIndex][columnName];
+        case 'columnar-table':
+            columnName = getTableColumnName(table, columnIndex);
+            const column = table.data[columnName];
+            return column[rowIndex];
+        case 'arrow-table':
+            return table.data.getChildAt(columnIndex)?.get(rowIndex);
+        default:
+            throw new Error('todo');
+    }
+}
+exports.getTableCellAt = getTableCellAt;
+/** Deduce the table row shape */
+function getTableRowShape(table) {
+    switch (table.shape) {
+        case 'array-row-table':
+        case 'object-row-table':
+            return table.shape;
+        case 'geojson-row-table':
+            return 'object-row-table';
+        case 'columnar-table':
+        default:
+            throw new Error('Not a row table');
+    }
+}
+exports.getTableRowShape = getTableRowShape;
+/** Get the index of a named table column. Requires the table to have a schema */
+function getTableColumnIndex(table, columnName) {
+    const columnIndex = table.schema?.fields.findIndex((field) => field.name === columnName);
+    if (columnIndex === undefined) {
+        throw new Error(columnName);
+    }
+    return columnIndex;
+}
+exports.getTableColumnIndex = getTableColumnIndex;
+/** Get the name of a table column by index. Requires the table to have a schema */
+function getTableColumnName(table, columnIndex) {
+    const columnName = table.schema?.fields[columnIndex]?.name;
+    if (!columnName) {
+        throw new Error(`${columnIndex}`);
+    }
+    return columnName;
+}
+exports.getTableColumnName = getTableColumnName;
+/**
+ * Returns one row of the table in object format.
+ * @param target Optional parameter will be used if needed to store the row. Can be reused between calls to improve performance
+ * @returns an array representing the row. May be the original array in the row, a new object, or the target parameter
+ */
+// eslint-disable-next-line complexity
+function getTableRowAsObject(table, rowIndex, target, copy) {
+    switch (table.shape) {
+        case 'object-row-table':
+            return copy ? Object.fromEntries(Object.entries(table.data[rowIndex])) : table.data[rowIndex];
+        case 'array-row-table':
+        case 'geojson-row-table':
+            if (table.schema) {
+                const objectRow = target || {};
+                for (let i = 0; i < table.schema.fields.length; i++) {
+                    objectRow[table.schema.fields[i].name] = table.data[rowIndex][i];
+                }
+                return objectRow;
+            }
+            throw new Error('no schema');
+        case 'columnar-table':
+            if (table.schema) {
+                const objectRow = target || {};
+                for (let i = 0; i < table.schema.fields.length; i++) {
+                    objectRow[table.schema.fields[i].name] =
+                        table.data[table.schema.fields[i].name][rowIndex];
+                }
+                return objectRow;
+            }
+            else {
+                // eslint-disable-line no-else-return
+                const objectRow = target || {};
+                for (const [name, column] of Object.entries(table.data)) {
+                    objectRow[name] = column[rowIndex];
+                }
+                return objectRow;
+            }
+        case 'arrow-table':
+            const objectRow = target || {};
+            const row = table.data.get(rowIndex);
+            const schema = table.data.schema;
+            for (let i = 0; i < schema.fields.length; i++) {
+                objectRow[schema.fields[i].name] = row?.[schema.fields[i].name];
+            }
+            return objectRow;
+        default:
+            throw new Error('shape');
+    }
+}
+exports.getTableRowAsObject = getTableRowAsObject;
+/**
+ * Returns one row of the table in array format.
+ * @param target Optional parameter will be used if needed to store the row. Can be reused between calls to improve performance.
+ * @returns an array representing the row. May be the original array in the row, a new object, or the target parameter
+ */
+// eslint-disable-next-line complexity
+function getTableRowAsArray(table, rowIndex, target, copy) {
+    switch (table.shape) {
+        case 'array-row-table':
+            return copy ? Array.from(table.data[rowIndex]) : table.data[rowIndex];
+        case 'object-row-table':
+        case 'geojson-row-table':
+            if (table.schema) {
+                const arrayRow = target || [];
+                for (let i = 0; i < table.schema.fields.length; i++) {
+                    arrayRow[i] = table.data[rowIndex][table.schema.fields[i].name];
+                }
+                return arrayRow;
+            }
+            // Warning: just slap on the values, this risks mismatches between rows
+            return Object.values(table.data[rowIndex]);
+        case 'columnar-table':
+            if (table.schema) {
+                const arrayRow = target || [];
+                for (let i = 0; i < table.schema.fields.length; i++) {
+                    arrayRow[i] = table.data[table.schema.fields[i].name][rowIndex];
+                }
+                return arrayRow;
+            }
+            else {
+                // eslint-disable-line no-else-return
+                const arrayRow = target || [];
+                let i = 0;
+                for (const column of Object.values(table.data)) {
+                    arrayRow[i] = column[rowIndex];
+                    i++;
+                }
+                return arrayRow;
+            }
+        case 'arrow-table':
+            const arrayRow = target || [];
+            const row = table.data.get(rowIndex);
+            const schema = table.data.schema;
+            for (let i = 0; i < schema.fields.length; i++) {
+                arrayRow[i] = row?.[schema.fields[i].name];
+            }
+            return arrayRow;
+        default:
+            throw new Error('shape');
+    }
+}
+exports.getTableRowAsArray = getTableRowAsArray;
+/** Convert any table into array row format */
+function makeArrayRowTable(table) {
+    if (table.shape === 'array-row-table') {
+        return table;
+    }
+    const length = getTableLength(table);
+    const data = new Array(length);
+    for (let rowIndex = 0; rowIndex < length; rowIndex++) {
+        data[rowIndex] = 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 = getTableLength(table);
+    const data = new Array(length);
+    for (let rowIndex = 0; rowIndex < length; rowIndex++) {
+        data[rowIndex] = getTableRowAsObject(table, rowIndex);
+    }
+    return {
+        shape: 'object-row-table',
+        schema: table.schema,
+        data
+    };
+}
+exports.makeObjectRowTable = makeObjectRowTable;
+/** Convert any table into object row format */
+function makeColumnarTable(table) {
+    if (table.shape === 'object-row-table') {
+        return table;
+    }
+    const length = getTableLength(table);
+    const data = new Array(length);
+    for (let rowIndex = 0; rowIndex < length; rowIndex++) {
+        data[rowIndex] = getTableRowAsObject(table, rowIndex);
+    }
+    return {
+        shape: 'object-row-table',
+        schema: table.schema,
+        data
+    };
+}
+exports.makeColumnarTable = makeColumnarTable;
+// Row Iterators
+/**
+ * Iterate over table rows
+ * @param table
+ * @param shape
+ */
+function* makeRowIterator(table, shape) {
+    switch (shape) {
+        case 'array-row-table':
+            yield* makeArrayRowIterator(table);
+            break;
+        case 'object-row-table':
+            yield* makeObjectRowIterator(table);
+            break;
+        default:
+            throw new Error(`Unknown row type ${shape}`);
+    }
+}
+exports.makeRowIterator = makeRowIterator;
+/**
+ * Streaming processing: Iterate over table, yielding array rows
+ * @param table
+ * @param shape
+ */
+function* makeArrayRowIterator(table, target = []) {
+    const length = getTableLength(table);
+    for (let rowIndex = 0; rowIndex < length; rowIndex++) {
+        yield getTableRowAsArray(table, rowIndex, target);
+    }
+}
+exports.makeArrayRowIterator = makeArrayRowIterator;
+/**
+ * Streaming processing: Iterate over table, yielding object rows
+ * @param table
+ * @param shape
+ */
+function* makeObjectRowIterator(table, target = {}) {
+    const length = getTableLength(table);
+    for (let rowIndex = 0; rowIndex < length; rowIndex++) {
+        yield getTableRowAsObject(table, rowIndex, target);
+    }
+}
+exports.makeObjectRowIterator = makeObjectRowIterator;

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

@@ -0,0 +1,7 @@
+import { Field } from '../../../types/schema';
+export interface ArrayType<T = unknown> {
+    readonly length: number;
+    [n: number]: T;
+}
+export declare function makeColumnFromField(field: Field, length: number): ArrayType;
+//# sourceMappingURL=table-column.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"table-column.d.ts","sourceRoot":"","sources":["../../../../src/lib/table/simple-table/table-column.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,KAAK,EAAC,MAAM,uBAAuB,CAAC;AAG5C,MAAM,WAAW,SAAS,CAAC,CAAC,GAAG,OAAO;IACpC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,CAAC,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC;CAChB;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,CAG3E"}

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

@@ -0,0 +1,41 @@
+"use strict";
+// loaders.gl, MIT license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeColumnFromField = void 0;
+const data_type_1 = require("./data-type");
+function makeColumnFromField(field, length) {
+    const ArrayType = (0, data_type_1.getArrayTypeFromDataType)(field.type, field.nullable);
+    return new ArrayType(length);
+}
+exports.makeColumnFromField = makeColumnFromField;
+/*
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function deduceSchema(rows) {
+  const row = rows[0];
+
+  const schema = {};
+  let i = 0;
+  for (const columnName in row) {
+    const value = row[columnName];
+    switch (typeof value) {
+      case 'number':
+      case 'boolean':
+        // TODO - booleans could be handled differently...
+        schema[columnName] = {name: String(columnName), index: i, type: Float32Array};
+        break;
+
+      case 'object':
+        schema[columnName] = {name: String(columnName), index: i, type: Array};
+        break;
+
+      case 'string':
+      default:
+        schema[columnName] = {name: String(columnName), index: i, type: Array};
+      // We currently only handle numeric rows
+      // TODO we could offer a function to map strings to numbers?
+    }
+    i++;
+  }
+  return schema;
+}
+*/

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

@@ -0,0 +1,15 @@
+import { Schema } from '../../../types/schema';
+import { Table } from '../../../types/category-table';
+/**
+ * SCHEMA SUPPORT - AUTODEDUCTION
+ * @param {*} table
+ * @param {*} schema
+ * @returns
+ */
+export declare function deduceTableSchema(table: Table): Schema;
+export declare function deduceSchema(data: unknown[][] | {
+    [key: string]: unknown;
+}[] | {
+    [key: string]: unknown[];
+}): Schema;
+//# sourceMappingURL=table-schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"table-schema.d.ts","sourceRoot":"","sources":["../../../../src/lib/table/simple-table/table-schema.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,MAAM,EAAQ,MAAM,uBAAuB,CAAC;AAEpD,OAAO,EAAC,KAAK,EAAC,MAAM,+BAA+B,CAAC;AAGpD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAatD;AAED,wBAAgB,YAAY,CAC1B,IAAI,EAAE,OAAO,EAAE,EAAE,GAAG;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAC,EAAE,GAAG;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,EAAE,CAAA;CAAC,GAC1E,MAAM,CAER"}

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

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deduceSchema = exports.deduceTableSchema = void 0;
+const data_type_1 = require("./data-type");
+/**
+ * SCHEMA SUPPORT - AUTODEDUCTION
+ * @param {*} table
+ * @param {*} schema
+ * @returns
+ */
+function deduceTableSchema(table) {
+    switch (table.shape) {
+        case 'array-row-table':
+        case 'object-row-table':
+            return deduceSchemaFromRows(table.data);
+        case 'columnar-table':
+            return deduceSchemaFromColumns(table.data);
+        case 'arrow-table':
+        default:
+            throw new Error('Deduce schema');
+    }
+}
+exports.deduceTableSchema = deduceTableSchema;
+function deduceSchema(data) {
+    return Array.isArray(data) ? deduceSchemaFromRows(data) : deduceSchemaFromColumns(data);
+}
+exports.deduceSchema = deduceSchema;
+/** Given an object with columnar arrays, try to deduce a schema */
+function deduceSchemaFromColumns(columnarTable) {
+    const fields = [];
+    for (const [columnName, column] of Object.entries(columnarTable)) {
+        const field = deduceFieldFromColumn(column, columnName);
+        fields.push(field);
+    }
+    return { fields, metadata: {} };
+}
+/** Given an array of rows, try to deduce a schema */
+function deduceSchemaFromRows(rowTable) {
+    if (!rowTable.length) {
+        throw new Error('deduce from empty table');
+    }
+    const fields = [];
+    const row0 = rowTable[0];
+    // TODO - fields can be nullable, false detection...
+    // Could look at additional rows if nulls in first row
+    // TODO - if array, column names will be numbers
+    for (const [columnName, value] of Object.entries(row0)) {
+        fields.push(deduceFieldFromValue(value, columnName));
+    }
+    return { fields, metadata: {} };
+}
+/** Given a column (i.e. array), attempt to deduce an appropriate `Field` */
+function deduceFieldFromColumn(column, name) {
+    if (ArrayBuffer.isView(column)) {
+        const type = (0, data_type_1.getDataTypeFromArray)(column);
+        return {
+            name,
+            type: type.type || 'null',
+            nullable: type.nullable
+            // metadata: {}
+        };
+    }
+    if (Array.isArray(column) && column.length > 0) {
+        const value = column[0];
+        const type = (0, data_type_1.getDataTypeFromValue)(value);
+        // TODO - support nested schemas?
+        return {
+            name,
+            type,
+            nullable: true
+            // metadata: {},
+        };
+    }
+    throw new Error('empty table');
+}
+/** Given a value, attempt to deduce an appropriate `Field` */
+function deduceFieldFromValue(value, name) {
+    const type = (0, data_type_1.getDataTypeFromValue)(value);
+    return {
+        name,
+        type,
+        nullable: true
+        // metadata: {}
+    };
+}

package/dist/lib/utils/assert.d.ts

@@ -0,0 +1,2 @@
+export declare function assert(condition: boolean, message?: string): void;
+//# sourceMappingURL=assert.d.ts.map

package/dist/lib/utils/assert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/assert.ts"],"names":[],"mappings":"AAGA,wBAAgB,MAAM,CAAC,SAAS,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,MAAM,QAI1D"}

package/dist/lib/utils/assert.js

@@ -1,6 +1,12 @@
-export function assert(condition, message) {
-  if (!condition) {
-    throw new Error(message || 'loader assertion failed.');
-  }
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assert = void 0;
+// Replacement for the external assert method to reduce bundle size
+// Note: We don't use the second "message" argument in calling code,
+// so no need to support it here
+function assert(condition, message) {
+    if (!condition) {
+        throw new Error(message || 'loader assertion failed.');
+    }
 }
-//# sourceMappingURL=assert.js.map
+exports.assert = assert;

package/dist/lib/utils/async-queue.d.ts

@@ -0,0 +1,18 @@
+export default class AsyncQueue<T> {
+    private _values;
+    private _settlers;
+    private _closed;
+    constructor();
+    close(): void;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+    enqueue(value: T | Error): void;
+    /**
+     * @returns a Promise for an IteratorResult
+     */
+    next(): Promise<any>;
+}
+/**
+ * @returns a Promise for an Array with the elements in `asyncIterable`
+ */
+export declare function takeAsync(asyncIterable: AsyncIterable<any>, count?: number): Promise<any[]>;
+//# sourceMappingURL=async-queue.d.ts.map

package/dist/lib/utils/async-queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-queue.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/async-queue.ts"],"names":[],"mappings":"AAcA,MAAM,CAAC,OAAO,OAAO,UAAU,CAAC,CAAC;IAC/B,OAAO,CAAC,OAAO,CAAwB;IACvC,OAAO,CAAC,SAAS,CAA8E;IAC/F,OAAO,CAAC,OAAO,CAAU;;IAazB,KAAK,IAAI,IAAI;IAOb,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC;IAI1C,OAAO,CAAC,KAAK,EAAE,CAAC,GAAG,KAAK,GAAG,IAAI;IAoB/B;;OAEG;IACH,IAAI,IAAI,OAAO,CAAC,GAAG,CAAC;CAoBrB;AAED;;GAEG;AACH,wBAAsB,SAAS,CAC7B,aAAa,EAAE,aAAa,CAAC,GAAG,CAAC,EACjC,KAAK,SAAW,GACf,OAAO,CAAC,GAAG,EAAE,CAAC,CAWhB"}