@loaders.gl/schema-utils 4.4.0-alpha.1

package/dist/lib/table/tables/convert-arrow-table.js

@@ -0,0 +1,150 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import * as arrow from 'apache-arrow';
+import { convertTable } from "./convert-table.js";
+import { convertArrowToSchema } from "../../schema/convert-arrow-schema.js";
+import { makeArrowRecordBatchIterator } from "../batches/make-arrow-batch-iterator.js";
+/**
+ * * Convert a loaders.gl Table to an Apache Arrow Table
+ * @param mesh
+ * @param metadata
+ * @param batchSize
+ * @returns
+ */
+export function convertTableToArrow(table, options) {
+    switch (table.shape) {
+        case 'arrow-table':
+            return table.data;
+        case 'columnar-table':
+        // TODO - optimized implementation is possible
+        // return convertColumnarTableToArrow(table, options);
+        // fall through
+        default:
+            const arrowBatchIterator = makeArrowRecordBatchIterator(table, options);
+            return new arrow.Table(arrowBatchIterator);
+    }
+}
+/**
+ * Convert an Apache Arrow table to a loaders.gl Table
+ * @note Currently does not convert schema
+ */
+export function convertArrowToTable(arrowTable, shape) {
+    switch (shape) {
+        case 'arrow-table':
+            return convertArrowToArrowTable(arrowTable);
+        case 'array-row-table':
+            return convertArrowToArrayRowTable(arrowTable);
+        case 'object-row-table':
+            return convertArrowToObjectRowTable(arrowTable);
+        case 'columnar-table':
+            return convertArrowToColumnarTable(arrowTable);
+        case 'geojson-table':
+            return convertArrowToGeoJSONTable(arrowTable);
+        default:
+            throw new Error(shape);
+    }
+}
+/**
+ * Wrap an apache arrow table in a loaders.gl table wrapper.
+ * From this additional conversions are available.
+ * @param arrowTable
+ * @returns
+ */
+function convertArrowToArrowTable(arrowTable) {
+    return {
+        shape: 'arrow-table',
+        schema: convertArrowToSchema(arrowTable.schema),
+        data: arrowTable
+    };
+}
+function convertArrowToArrayRowTable(arrowTable) {
+    const columnarTable = convertArrowToColumnarTable(arrowTable);
+    return convertTable(columnarTable, 'array-row-table');
+}
+function convertArrowToObjectRowTable(arrowTable) {
+    const columnarTable = convertArrowToColumnarTable(arrowTable);
+    return convertTable(columnarTable, 'object-row-table');
+}
+/**
+ * Convert an Apache Arrow table to a ColumnarTable
+ * @note Currently does not convert schema
+ */
+function convertArrowToColumnarTable(arrowTable) {
+    // TODO - avoid calling `getColumn` on columns we are not interested in?
+    // Add options object?
+    const columns = {};
+    for (const field of arrowTable.schema.fields) {
+        // This (is intended to) coalesce all record batches into a single typed array
+        const arrowColumn = arrowTable.getChild(field.name);
+        const values = arrowColumn?.toArray();
+        columns[field.name] = values;
+    }
+    const schema = convertArrowToSchema(arrowTable.schema);
+    return {
+        shape: 'columnar-table',
+        schema,
+        data: columns
+    };
+}
+/**
+ * Convert an Apache Arrow table to a GeoJSONTable
+ * @note Currently does not convert schema
+ */
+function convertArrowToGeoJSONTable(arrowTable) {
+    const schema = convertArrowToSchema(arrowTable.schema);
+    const features = [];
+    for (let row = 0; row < arrowTable.numRows; row++) {
+        // parse arrow geometry to geojson feature
+        const properties = arrowTable.get(row)?.toJSON() || {};
+        features.push({ type: 'Feature', geometry: null, properties });
+    }
+    return {
+        shape: 'geojson-table',
+        type: 'FeatureCollection',
+        schema,
+        features
+    };
+}
+// /**
+//  * Wrap an apache arrow table in a loaders.gl table wrapper.
+//  * From this additional conversions are available.
+//  * @param arrowTable
+//  * @returns
+//  */
+// function convertArrowToArrowTable(arrowTable: arrow.Table): ArrowTable {
+//   return {
+//     shape: 'arrow-table',
+//     schema: convertArrowToSchema(arrowTable.schema),
+//     data: arrowTable
+//   };
+// }
+// function convertArrowToArrayRowTable(arrowTable: arrow.Table): Table {
+//   const columnarTable = convertArrowToColumnarTable(arrowTable);
+//   return convertTable(columnarTable, 'array-row-table');
+// }
+// function convertArrowToObjectRowTable(arrowTable: arrow.Table): Table {
+//   const columnarTable = convertArrowToColumnarTable(arrowTable);
+//   return convertTable(columnarTable, 'object-row-table');
+// }
+// /**
+//  * Convert an Apache Arrow table to a ColumnarTable
+//  * @note Currently does not convert schema
+//  */
+// function convertArrowToColumnarTable(arrowTable: arrow.Table): ColumnarTable {
+//   // TODO - avoid calling `getColumn` on columns we are not interested in?
+//   // Add options object?
+//   const columns: ColumnarTable['data'] = {};
+//   for (const field of arrowTable.schema.fields) {
+//     // This (is intended to) coalesce all record batches into a single typed array
+//     const arrowColumn = arrowTable.getChild(field.name);
+//     const values = arrowColumn?.toArray();
+//     columns[field.name] = values;
+//   }
+//   const schema = convertArrowToSchema(arrowTable.schema);
+//   return {
+//     shape: 'columnar-table',
+//     schema,
+//     data: columns
+//   };
+// }

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

@@ -0,0 +1,43 @@
+import type { Table, ArrayRowTable, ObjectRowTable, ColumnarTable, ArrowTable } from '@loaders.gl/schema';
+export declare function convertTable(table: Table, shape: 'object-row-table'): ObjectRowTable;
+export declare function convertTable(table: Table, shape: 'array-row-table'): ArrayRowTable;
+export declare function convertTable(table: Table, shape: 'columnar-table'): ColumnarTable;
+export declare function convertTable(table: Table, shape: 'arrow-table'): ArrowTable;
+/** Convert any simple table into columnar format */
+export declare function convertToColumnarTable(table: Table): ColumnarTable;
+/** Convert any table into array row format */
+export declare function convertToArrayRowTable(table: Table): ArrayRowTable;
+/** Convert any table into object row format */
+export declare function convertToObjectRowTable(table: Table): ObjectRowTable;
+/**
+ * Convert a table to apache arrow format
+ * @note this depends on the `@loaders.gl/arrow module being imported
+ */
+export declare function convertToArrowTable(table: Table): ArrowTable;
+/**
+ *
+ * @note - should be part of schema module
+ *
+export function convertColumnarToRowFormatTable(columnarTable: ColumnarTable): ObjectRowTable {
+  const tableKeys = Object.keys(columnarTable);
+  const tableRowsCount = columnarTable[tableKeys[0]].length;
+
+  const rowFormatTable: {}[] = [];
+
+  for (let index = 0; index < tableRowsCount; index++) {
+    const tableItem = {};
+    for (let keyIndex = 0; keyIndex < tableKeys.length; keyIndex++) {
+      const fieldName = tableKeys[keyIndex];
+      tableItem[fieldName] = columnarTable[fieldName][index];
+    }
+    rowFormatTable.push(tableItem);
+  }
+
+  return {
+    shape: 'object-row-table',
+    schema: columnarTable.schema,
+    data: rowFormatTable
+  };
+}
+*/
+//# sourceMappingURL=convert-table.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"convert-table.d.ts","sourceRoot":"","sources":["../../../../src/lib/table/tables/convert-table.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,KAAK,EACL,aAAa,EACb,cAAc,EACd,aAAa,EACb,UAAU,EACX,MAAM,oBAAoB,CAAC;AAW5B,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,kBAAkB,GAAG,cAAc,CAAC;AACtF,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,iBAAiB,GAAG,aAAa,CAAC;AACpF,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,gBAAgB,GAAG,aAAa,CAAC;AACnF,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,aAAa,GAAG,UAAU,CAAC;AA0B7E,oDAAoD;AACpD,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,KAAK,GAAG,aAAa,CAyBlE;AAED,8CAA8C;AAC9C,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,KAAK,GAAG,aAAa,CAclE;AAED,+CAA+C;AAC/C,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,KAAK,GAAG,cAAc,CAcpE;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,KAAK,GAAG,UAAU,CAO5D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;EAyBE"}

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

@@ -0,0 +1,120 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { getTableCell, getTableLength, getTableRowAsArray, getTableRowAsObject } from "./table-accessors.js";
+import { deduceTableSchema } from "../../schema/deduce-table-schema.js";
+import { makeColumnFromField } from "./table-column.js";
+import { convertTableToArrow } from "./convert-arrow-table.js";
+/**
+ * Convert a table to a different shape
+ * @param table
+ * @param shape
+ * @returns
+ */
+export function convertTable(table, shape) {
+    switch (shape) {
+        case 'object-row-table':
+            return convertToObjectRowTable(table);
+        case 'array-row-table':
+            return convertToArrayRowTable(table);
+        case 'columnar-table':
+            return convertToColumnarTable(table);
+        case 'arrow-table':
+            return convertToArrowTable(table);
+        default:
+            throw new Error(shape);
+    }
+}
+/** Convert any simple table into columnar format */
+export function convertToColumnarTable(table) {
+    // TODO - should schema really be optional?
+    const schema = table.schema || deduceTableSchema(table);
+    const fields = table.schema?.fields || [];
+    if (table.shape === 'columnar-table') {
+        return { ...table, schema };
+    }
+    const length = getTableLength(table);
+    const columns = {};
+    for (const field of fields) {
+        const column = makeColumnFromField(field, length);
+        columns[field.name] = column;
+        for (let rowIndex = 0; rowIndex < length; rowIndex++) {
+            column[rowIndex] = getTableCell(table, rowIndex, field.name);
+        }
+    }
+    return {
+        shape: 'columnar-table',
+        schema,
+        data: columns
+    };
+}
+/** Convert any table into array row format */
+export function convertToArrayRowTable(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
+    };
+}
+/** Convert any table into object row format */
+export function convertToObjectRowTable(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
+    };
+}
+/**
+ * Convert a table to apache arrow format
+ * @note this depends on the `@loaders.gl/arrow module being imported
+ */
+export function convertToArrowTable(table) {
+    const arrowTable = convertTableToArrow(table);
+    return {
+        shape: 'arrow-table',
+        schema: table.schema,
+        data: arrowTable
+    };
+}
+/**
+ *
+ * @note - should be part of schema module
+ *
+export function convertColumnarToRowFormatTable(columnarTable: ColumnarTable): ObjectRowTable {
+  const tableKeys = Object.keys(columnarTable);
+  const tableRowsCount = columnarTable[tableKeys[0]].length;
+
+  const rowFormatTable: {}[] = [];
+
+  for (let index = 0; index < tableRowsCount; index++) {
+    const tableItem = {};
+    for (let keyIndex = 0; keyIndex < tableKeys.length; keyIndex++) {
+      const fieldName = tableKeys[keyIndex];
+      tableItem[fieldName] = columnarTable[fieldName][index];
+    }
+    rowFormatTable.push(tableItem);
+  }
+
+  return {
+    shape: 'object-row-table',
+    schema: columnarTable.schema,
+    data: rowFormatTable
+  };
+}
+*/

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

@@ -0,0 +1,67 @@
+import * as arrow from 'apache-arrow';
+import type { ArrayRowTable, ObjectRowTable, ColumnarTable, ArrowTable } from '@loaders.gl/schema';
+/**
+ * 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;
+export declare function makeTableFromData(data: arrow.Table): ArrowTable;
+/** 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/tables/make-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"make-table.d.ts","sourceRoot":"","sources":["../../../../src/lib/table/tables/make-table.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AACtC,OAAO,KAAK,EAEV,aAAa,EACb,cAAc,EACd,aAAa,EACb,UAAU,EACX,MAAM,oBAAoB,CAAC;AAG5B;;;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;AAC/F,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,KAAK,CAAC,KAAK,GAAG,UAAU,CAAC;AAsDjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmDE"}

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

@@ -0,0 +1,101 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import * as arrow from 'apache-arrow';
+import { deduceTableSchema } from "../../schema/deduce-table-schema.js";
+export 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;
+        case 'arrow-table':
+            table = { shape: 'arrow-table', data: data };
+            break;
+        default:
+            throw new Error('table');
+    }
+    const schema = deduceTableSchema(table);
+    return { ...table, schema };
+}
+/** Helper function to get shape of data */
+function getTableShapeFromData(data) {
+    if (data instanceof arrow.Table) {
+        return 'arrow-table';
+    }
+    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/tables/row-utils.d.ts

@@ -0,0 +1,15 @@
+/** Convert an object row to an array row */
+export declare function convertToObjectRow(arrayRow: unknown[], headers: string[] | null): {
+    [columnName: string]: unknown;
+};
+/** Convert an object row to an array row */
+export declare function convertToArrayRow(objectRow: {
+    [columnName: string]: unknown;
+}, headers: string[] | null): unknown[];
+/** Get headers from a sample array row */
+export declare function inferHeadersFromArrayRow(arrayRow: unknown[]): string[];
+/** Get headers from a smaple object row */
+export declare function inferHeadersFromObjectRow(row: {
+    [columnName: string]: unknown;
+}): string[];
+//# sourceMappingURL=row-utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"row-utils.d.ts","sourceRoot":"","sources":["../../../../src/lib/table/tables/row-utils.ts"],"names":[],"mappings":"AAIA,4CAA4C;AAC5C,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,OAAO,EAAE,EACnB,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,GACvB;IAAC,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAA;CAAC,CAgBjC;AAED,4CAA4C;AAC5C,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE;IAAC,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAA;CAAC,EAC1C,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,GACvB,OAAO,EAAE,CAaX;AAED,0CAA0C;AAC1C,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,OAAO,EAAE,YAO3D;AAED,2CAA2C;AAC3C,wBAAgB,yBAAyB,CAAC,GAAG,EAAE;IAAC,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAA;CAAC,YAE7E"}

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

@@ -0,0 +1,49 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+/** Convert an object row to an array row */
+export function convertToObjectRow(arrayRow, headers) {
+    if (!arrayRow) {
+        throw new Error('null row');
+    }
+    const objectRow = {};
+    if (headers) {
+        for (let i = 0; i < headers.length; i++) {
+            objectRow[headers[i]] = arrayRow[i];
+        }
+    }
+    else {
+        for (let i = 0; i < arrayRow.length; i++) {
+            const columnName = `column-${i}`;
+            objectRow[columnName] = arrayRow[i];
+        }
+    }
+    return objectRow;
+}
+/** Convert an object row to an array row */
+export function convertToArrayRow(objectRow, headers) {
+    if (!objectRow) {
+        throw new Error('null row');
+    }
+    if (headers) {
+        const arrayRow = new Array(headers.length);
+        for (let i = 0; i < headers.length; i++) {
+            arrayRow[i] = objectRow[headers[i]];
+        }
+        return arrayRow;
+    }
+    return Object.values(objectRow);
+}
+/** Get headers from a sample array row */
+export function inferHeadersFromArrayRow(arrayRow) {
+    const headers = [];
+    for (let i = 0; i < arrayRow.length; i++) {
+        const columnName = `column-${i}`;
+        headers.push(columnName);
+    }
+    return headers;
+}
+/** Get headers from a smaple object row */
+export function inferHeadersFromObjectRow(row) {
+    return Object.keys(row);
+}

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

@@ -0,0 +1,68 @@
+import type { Table, ArrayRowTable, ObjectRowTable } from '@loaders.gl/schema';
+export declare function isTable(table: any): table is 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/tables/table-accessors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-accessors.d.ts","sourceRoot":"","sources":["../../../../src/lib/table/tables/table-accessors.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAC,KAAK,EAAE,aAAa,EAAE,cAAc,EAAC,MAAM,oBAAoB,CAAC;AAE7E,wBAAgB,OAAO,CAAC,KAAK,EAAE,GAAG,GAAG,KAAK,IAAI,KAAK,CAmBlD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAqBnD;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,CA0BxF;AAED,0DAA0D;AAC1D,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAyB3F;AAED,iCAAiC;AACjC,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,KAAK,GAAG,iBAAiB,GAAG,kBAAkB,CAcrF;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,CAwDjC;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,CA2DX;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"}