@loaders.gl/schema 4.0.1 → 4.0.3

package/src/lib/table/simple-table/make-table-from-batches.ts

@@ -0,0 +1,102 @@
+// loaders.gl, MIT license
+// Copyright (c) vis.gl contributors
+
+import type {
+  TableBatch,
+  Table,
+  Schema,
+  ObjectRowTable,
+  ArrayRowTable,
+  Feature
+} from '@loaders.gl/schema';
+import {getTableLength} from '@loaders.gl/schema';
+
+/**
+ * Returns an iterator that yields a single table as a sequence of batches.
+ * @note Currently only a single batch is yielded.
+ * @note All batches will have the same shape and schema as the original table.
+ * @returns
+ */
+export function* makeBatchesFromTable(table: Table): IterableIterator<TableBatch> {
+  yield makeBatchFromTable(table);
+}
+
+/**
+ * Returns a table packaged as a single table batch
+ * @note The batch will have the same shape and schema as the original table.
+ * @returns `null` if no batches are yielded by the async iterator
+ */
+export function makeBatchFromTable(table: Table): TableBatch {
+  return {...table, length: getTableLength(table), batchType: 'data'};
+}
+
+/**
+ * Assembles all batches from an async iterator into a single table.
+ * @note All batches must have the same shape and schema
+ * @param batchIterator
+ * @returns `null` if no batches are yielded by the async iterator
+ */
+// eslint-disable-next-line complexity
+export async function makeTableFromBatches(
+  batchIterator: AsyncIterable<TableBatch> | Iterable<TableBatch>
+): Promise<Table | null> {
+  let arrayRows: ArrayRowTable['data'];
+  let objectRows: ObjectRowTable['data'];
+  let features: Feature[];
+  let shape: Table['shape'] | null = null;
+  let schema: Schema | undefined;
+
+  for await (const batch of batchIterator) {
+    shape = shape || batch.shape;
+    schema = schema || batch.schema;
+
+    switch (batch.shape) {
+      case 'array-row-table':
+        arrayRows = arrayRows! || [];
+        for (let rowIndex = 0; rowIndex < getTableLength(batch); rowIndex++) {
+          const row = batch.data[rowIndex];
+          arrayRows.push(row);
+        }
+        break;
+
+      case 'object-row-table':
+        objectRows = objectRows! || [];
+        for (let rowIndex = 0; rowIndex < getTableLength(batch); rowIndex++) {
+          const row = batch.data[rowIndex];
+          objectRows.push(row);
+        }
+        break;
+
+      case 'geojson-table':
+        features = features! || [];
+        for (let rowIndex = 0; rowIndex < getTableLength(batch); rowIndex++) {
+          const row = batch.features[rowIndex];
+          features.push(row);
+        }
+        break;
+
+      case 'columnar-table':
+      case 'arrow-table':
+      default:
+        throw new Error('shape');
+    }
+  }
+
+  if (!shape) {
+    return null;
+  }
+
+  switch (shape) {
+    case 'array-row-table':
+      return {shape: 'array-row-table', data: arrayRows!, schema};
+
+    case 'object-row-table':
+      return {shape: 'object-row-table', data: objectRows!, schema};
+
+    case 'geojson-table':
+      return {shape: 'geojson-table', type: 'FeatureCollection', features: features!, schema};
+
+    default:
+      return null;
+  }
+}

package/src/lib/table/simple-table/make-table.ts

@@ -1,5 +1,6 @@
 // loaders.gl, MIT license
 // Copyright (c) vis.gl contributors
+
 import {Table, ArrayRowTable, ObjectRowTable, ColumnarTable} from '../../../types/category-table';
 import {deduceTableSchema} from './table-schema';
 

package/src/lib/table/simple-table/row-utils.ts

@@ -1,3 +1,6 @@
+// loaders.gl, MIT license
+// Copyright (c) vis.gl contributors
+
 /** Convert an object row to an array row */
 export function convertToObjectRow(
   arrayRow: any[],

package/src/lib/table/simple-table/table-accessors.ts

@@ -5,6 +5,27 @@
 
 import {Table, ArrayRowTable, ObjectRowTable} from '../../../types/category-table';
 
+export function isTable(table: any): table is Table {
+  const shape = typeof table === 'object' && table?.shape;
+  switch (shape) {
+    case 'array-row-table':
+    case 'object-row-table':
+      return Array.isArray(table.data);
+
+    case 'geojson-table':
+      return Array.isArray(table.features);
+
+    case 'columnar-table':
+      return table.data && typeof table.data === 'object';
+
+    case 'arrow-table':
+      return Boolean(table?.data?.numRows !== undefined);
+
+    default:
+      return false;
+  }
+}
+
 /**
  * Returns the length of the table (i.e. the number of rows)
  */

package/src/lib/table/simple-table/table-schema.ts

@@ -1,3 +1,6 @@
+// loaders.gl, MIT license
+// Copyright (c) vis.gl contributors
+
 // Type deduction
 import {Schema, Field} from '../../../types/schema';
 import {ArrayType} from '../../../types/types';

package/src/types/batch.ts

@@ -19,7 +19,7 @@ export type Batch = {
   /** Schema of the data in this batch */
   schema?: Schema;
   /** Data in this batch */
-  data: unknown;
+  data?: unknown;
   /**  If this is an arrow table. @deprecated Use `data` */
   recordBatch?: ApacheRecordBatch;
   /** Length of data in this batch */

package/src/types/binary-geometries.ts

@@ -1,3 +1,6 @@
+// loaders.gl, MIT license
+// Copyright (c) vis.gl contributors
+
 // GIS
 import type {TypedArray} from './types';
 

package/src/types/category-gis.ts

@@ -1,3 +1,6 @@
+// loaders.gl, MIT license
+// Copyright (c) vis.gl contributors
+
 // GIS
 
 // NORMAL GEOJSON FORMAT GEOMETRY

package/src/types/category-image.ts

@@ -1,3 +1,6 @@
+// loaders.gl, MIT license
+// Copyright (c) vis.gl contributors
+
 /**
  * data images
  */

package/src/types/schema.ts

@@ -37,6 +37,7 @@ export type DataType =
   | 'interval-daytime'
   | 'interval-yearmonth'
   // Composite types
+  | {type: 'decimal'; bitWidth: number; precision: number; scale: number}
   | {type: 'list'; children: Field[]} // one child only
   | {type: 'struct'; children: Field[]}
   | {

package/src/types/types.ts

@@ -1,3 +1,6 @@
+// loaders.gl, MIT license
+// Copyright (c) vis.gl contributors
+
 /** Any typed array */
 export type TypedArray =
   | Int8Array