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

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.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;

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"}