@loaders.gl/arrow 4.2.0-alpha.4 → 4.2.0-alpha.6

package/dist/lib/arrow-table-batch.js

@@ -1,62 +1,66 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { ColumnarTableBatchAggregator } from '@loaders.gl/schema';
 import * as arrow from 'apache-arrow';
 export class ArrowTableBatchAggregator extends ColumnarTableBatchAggregator {
-  constructor(schema, options) {
-    super(schema, options);
-    this.arrowSchema = void 0;
-    this.arrowSchema = null;
-  }
-  getBatch() {
-    const batch = super.getBatch();
-    if (batch) {
-      this.arrowSchema = this.arrowSchema || getArrowSchema(batch.schema);
-      const arrowVectors = getArrowVectors(this.arrowSchema, batch.data);
-      const recordBatch = new arrow.RecordBatch(this.arrowSchema, arrow.makeData({
-        type: new arrow.Struct(this.arrowSchema.fields),
-        children: arrowVectors.map(_ref => {
-          let {
-            data
-          } = _ref;
-          return data[0];
-        })
-      }));
-      return {
-        shape: 'arrow-table',
-        batchType: 'data',
-        data: new arrow.Table([recordBatch]),
-        length: batch.length
-      };
+    arrowSchema;
+    constructor(schema, options) {
+        super(schema, options);
+        this.arrowSchema = null;
+    }
+    getBatch() {
+        const batch = super.getBatch();
+        if (batch) {
+            // Get the arrow schema
+            this.arrowSchema = this.arrowSchema || getArrowSchema(batch.schema);
+            // Get arrow format vectors
+            const arrowVectors = getArrowVectors(this.arrowSchema, batch.data);
+            // Create the record batch
+            const recordBatch = new arrow.RecordBatch(this.arrowSchema, arrow.makeData({
+                type: new arrow.Struct(this.arrowSchema.fields),
+                children: arrowVectors.map(({ data }) => data[0])
+            }));
+            return {
+                shape: 'arrow-table',
+                batchType: 'data',
+                data: new arrow.Table([recordBatch]),
+                length: batch.length
+            };
+        }
+        return null;
     }
-    return null;
-  }
 }
+// Convert from a simple loaders.gl schema to an Arrow schema
 function getArrowSchema(schema) {
-  const arrowFields = [];
-  for (const key in schema) {
-    const field = schema[key];
-    if (field.type === Float32Array) {
-      const metadata = new Map();
-      const arrowField = new arrow.Field(field.name, new arrow.Float32(), field.nullable, metadata);
-      arrowFields.push(arrowField);
+    const arrowFields = [];
+    for (const key in schema) {
+        const field = schema[key];
+        if (field.type === Float32Array) {
+            // TODO - just store the original field as metadata?
+            const metadata = new Map(); // field;
+            // arrow: new arrow.Field(name, nullable, metadata)
+            const arrowField = new arrow.Field(field.name, new arrow.Float32(), field.nullable, metadata);
+            arrowFields.push(arrowField);
+        }
+    }
+    if (arrowFields.length === 0) {
+        throw new Error('No arrow convertible fields');
     }
-  }
-  if (arrowFields.length === 0) {
-    throw new Error('No arrow convertible fields');
-  }
-  return new arrow.Schema(arrowFields);
+    return new arrow.Schema(arrowFields);
 }
+// Convert from simple loaders.gl arrays to arrow vectors
 function getArrowVectors(arrowSchema, data) {
-  const arrowVectors = [];
-  for (const field of arrowSchema.fields) {
-    const vector = data[field.name];
-    if (vector instanceof Float32Array) {
-      const arrowVector = arrow.makeVector(vector);
-      arrowVectors.push(arrowVector);
+    const arrowVectors = [];
+    for (const field of arrowSchema.fields) {
+        const vector = data[field.name];
+        if (vector instanceof Float32Array) {
+            const arrowVector = arrow.makeVector(vector);
+            arrowVectors.push(arrowVector);
+        }
+    }
+    if (arrowSchema.fields.length !== arrowVectors.length) {
+        throw new Error('Some columns not arrow convertible');
     }
-  }
-  if (arrowSchema.fields.length !== arrowVectors.length) {
-    throw new Error('Some columns not arrow convertible');
-  }
-  return arrowVectors;
+    return arrowVectors;
 }
-//# sourceMappingURL=arrow-table-batch.js.map

package/dist/lib/arrow-table.js

@@ -1,2 +1,4 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 export {};
-//# sourceMappingURL=arrow-table.js.map

package/dist/lib/encode-arrow.d.ts

@@ -1,4 +1,4 @@
-import { AnyArrayType } from '../types';
+import { AnyArrayType } from "../types.js";
 export type ColumnarTable = {
     name: string;
     array: AnyArrayType;

package/dist/lib/encode-arrow.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"encode-arrow.d.ts","sourceRoot":"","sources":["../../src/lib/encode-arrow.ts"],"names":[],"mappings":"AAKA,OAAO,EAAC,YAAY,EAAe,MAAM,UAAU,CAAC;AAEpD,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,YAAY,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;CACd,EAAE,CAAC;AAEJ;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,aAAa,GAAG,WAAW,CAShE"}
+{"version":3,"file":"encode-arrow.d.ts","sourceRoot":"","sources":["../../src/lib/encode-arrow.ts"],"names":[],"mappings":"AAKA,OAAO,EAAC,YAAY,EAAe,oBAAiB;AAEpD,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,YAAY,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;CACd,EAAE,CAAC;AAEJ;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,aAAa,GAAG,WAAW,CAShE"}

package/dist/lib/encode-arrow.js

@@ -1,22 +1,37 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import * as arrow from 'apache-arrow';
 import { VECTOR_TYPES } from "../types.js";
+/**
+ * Encodes set of arrays into the Apache Arrow columnar format
+ * https://arrow.apache.org/docs/format/Columnar.html#ipc-file-format
+ * @param data - columns data
+ * @param options - the writer options
+ * @returns - encoded ArrayBuffer
+ */
 export function encodeArrowSync(data) {
-  const vectors = {};
-  for (const arrayData of data) {
-    const arrayVector = createVector(arrayData.array, arrayData.type);
-    vectors[arrayData.name] = arrayVector;
-  }
-  const table = new arrow.Table(vectors);
-  const arrowBuffer = arrow.tableToIPC(table);
-  return arrowBuffer;
+    const vectors = {};
+    for (const arrayData of data) {
+        const arrayVector = createVector(arrayData.array, arrayData.type);
+        vectors[arrayData.name] = arrayVector;
+    }
+    const table = new arrow.Table(vectors);
+    const arrowBuffer = arrow.tableToIPC(table);
+    return arrowBuffer;
 }
+/**
+ * Create Arrow arrow.Vector from given data and vector type
+ * @param array {import('../types').AnyArrayType} - columns data
+ * @param type {number} - the writer options
+ * @return a vector of one of vector's types defined in the Apache Arrow library
+ */
 function createVector(array, type) {
-  switch (type) {
-    case VECTOR_TYPES.DATE:
-      return arrow.vectorFromArray(array);
-    case VECTOR_TYPES.FLOAT:
-    default:
-      return arrow.vectorFromArray(array);
-  }
+    switch (type) {
+        case VECTOR_TYPES.DATE:
+            return arrow.vectorFromArray(array);
+        case VECTOR_TYPES.FLOAT:
+        default:
+            return arrow.vectorFromArray(array);
+    }
 }
-//# sourceMappingURL=encode-arrow.js.map

package/dist/lib/encode-geoarrow.d.ts

@@ -1,4 +1,4 @@
-import { AnyArrayType } from '../types';
+import { AnyArrayType } from "../types.js";
 export type ColumnarTable = {
     name: string;
     array: AnyArrayType;

package/dist/lib/encode-geoarrow.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"encode-geoarrow.d.ts","sourceRoot":"","sources":["../../src/lib/encode-geoarrow.ts"],"names":[],"mappings":"AAKA,OAAO,EAAC,YAAY,EAAe,MAAM,UAAU,CAAC;AAEpD,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,YAAY,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;CACd,EAAE,CAAC;AAEJ;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,aAAa,GAAG,WAAW,CASnE"}
+{"version":3,"file":"encode-geoarrow.d.ts","sourceRoot":"","sources":["../../src/lib/encode-geoarrow.ts"],"names":[],"mappings":"AAKA,OAAO,EAAC,YAAY,EAAe,oBAAiB;AAEpD,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,YAAY,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;CACd,EAAE,CAAC;AAEJ;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,aAAa,GAAG,WAAW,CASnE"}

package/dist/lib/encode-geoarrow.js

@@ -1,22 +1,37 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import * as arrow from 'apache-arrow';
 import { VECTOR_TYPES } from "../types.js";
+/**
+ * Encodes set of arrays into the Apache Arrow columnar format
+ * https://arrow.apache.org/docs/format/Columnar.html#ipc-file-format
+ * @param data - columns data
+ * @param options - the writer options
+ * @returns - encoded ArrayBuffer
+ */
 export function encodeGeoArrowSync(data) {
-  const vectors = {};
-  for (const arrayData of data) {
-    const arrayVector = createVector(arrayData.array, arrayData.type);
-    vectors[arrayData.name] = arrayVector;
-  }
-  const table = new arrow.Table(vectors);
-  const arrowBuffer = arrow.tableToIPC(table);
-  return arrowBuffer;
+    const vectors = {};
+    for (const arrayData of data) {
+        const arrayVector = createVector(arrayData.array, arrayData.type);
+        vectors[arrayData.name] = arrayVector;
+    }
+    const table = new arrow.Table(vectors);
+    const arrowBuffer = arrow.tableToIPC(table);
+    return arrowBuffer;
 }
+/**
+ * Create Arrow arrow.Vector from given data and vector type
+ * @param array {import('../types').AnyArrayType} - columns data
+ * @param type {number} - the writer options
+ * @return a vector of one of vector's types defined in the Apache Arrow library
+ */
 function createVector(array, type) {
-  switch (type) {
-    case VECTOR_TYPES.DATE:
-      return arrow.vectorFromArray(array);
-    case VECTOR_TYPES.FLOAT:
-    default:
-      return arrow.vectorFromArray(array);
-  }
+    switch (type) {
+        case VECTOR_TYPES.DATE:
+            return arrow.vectorFromArray(array);
+        case VECTOR_TYPES.FLOAT:
+        default:
+            return arrow.vectorFromArray(array);
+    }
 }
-//# sourceMappingURL=encode-geoarrow.js.map

package/dist/parsers/parse-arrow-in-batches.d.ts

@@ -1,5 +1,5 @@
-import type { ArrowTableBatch } from '../lib/arrow-table';
-import { ArrowLoaderOptions } from '../arrow-loader';
+import type { ArrowTableBatch } from "../lib/arrow-table.js";
+import { ArrowLoaderOptions } from "../arrow-loader.js";
 /**
  */
 export declare function parseArrowInBatches(asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>, options?: ArrowLoaderOptions): AsyncIterable<ArrowTableBatch>;

package/dist/parsers/parse-arrow-in-batches.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse-arrow-in-batches.d.ts","sourceRoot":"","sources":["../../src/parsers/parse-arrow-in-batches.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,oBAAoB,CAAC;AAExD,OAAO,EAAC,kBAAkB,EAAC,MAAM,iBAAiB,CAAC;AAGnD;GACG;AACH,wBAAgB,mBAAmB,CACjC,aAAa,EAAE,aAAa,CAAC,WAAW,CAAC,GAAG,QAAQ,CAAC,WAAW,CAAC,EACjE,OAAO,CAAC,EAAE,kBAAkB,GAC3B,aAAa,CAAC,eAAe,CAAC,CA0ChC"}
+{"version":3,"file":"parse-arrow-in-batches.d.ts","sourceRoot":"","sources":["../../src/parsers/parse-arrow-in-batches.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,eAAe,EAAC,8BAA2B;AAExD,OAAO,EAAC,kBAAkB,EAAC,2BAAwB;AAGnD;GACG;AACH,wBAAgB,mBAAmB,CACjC,aAAa,EAAE,aAAa,CAAC,WAAW,CAAC,GAAG,QAAQ,CAAC,WAAW,CAAC,EACjE,OAAO,CAAC,EAAE,kBAAkB,GAC3B,aAAa,CAAC,eAAe,CAAC,CA0ChC"}

package/dist/parsers/parse-arrow-in-batches.js

@@ -1,27 +1,55 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import * as arrow from 'apache-arrow';
+// import {isIterable} from '@loaders.gl/core';
+/**
+ */
 export function parseArrowInBatches(asyncIterator, options) {
-  async function* makeArrowAsyncIterator() {
-    const readers = arrow.RecordBatchReader.readAll(asyncIterator);
-    for await (const reader of readers) {
-      for await (const recordBatch of reader) {
-        var _options$arrow, _options$arrow2;
-        if ((options === null || options === void 0 ? void 0 : (_options$arrow = options.arrow) === null || _options$arrow === void 0 ? void 0 : _options$arrow.batchDebounceMs) !== undefined && (options === null || options === void 0 ? void 0 : (_options$arrow2 = options.arrow) === null || _options$arrow2 === void 0 ? void 0 : _options$arrow2.batchDebounceMs) > 0) {
-          await new Promise(resolve => {
-            var _options$arrow3;
-            return setTimeout(resolve, ((_options$arrow3 = options.arrow) === null || _options$arrow3 === void 0 ? void 0 : _options$arrow3.batchDebounceMs) || 0);
-          });
+    // Creates the appropriate arrow.RecordBatchReader subclasses from the input
+    // This will also close the underlying source in case of early termination or errors
+    // As an optimization, return a non-async iterator
+    /*
+    if (isIterable(readers)) {
+      function* makeArrowIterator() {
+        for (const reader of readers) {
+          for (const batch of reader) {
+            yield processBatch(batch, reader);
+          }
+          break; // only processing one stream of batches
         }
-        const arrowTabledBatch = {
-          shape: 'arrow-table',
-          batchType: 'data',
-          data: new arrow.Table([recordBatch]),
-          length: recordBatch.data.length
-        };
-        yield arrowTabledBatch;
       }
-      break;
+      const arrowIterator = makeArrowIterator();
     }
-  }
-  return makeArrowAsyncIterator();
+    */
+    async function* makeArrowAsyncIterator() {
+        // @ts-ignore
+        const readers = arrow.RecordBatchReader.readAll(asyncIterator);
+        for await (const reader of readers) {
+            for await (const recordBatch of reader) {
+                // use options.batchDebounceMs to add a delay between batches if needed (use case: incremental loading)
+                if (options?.arrow?.batchDebounceMs !== undefined && options?.arrow?.batchDebounceMs > 0) {
+                    await new Promise((resolve) => setTimeout(resolve, options.arrow?.batchDebounceMs || 0));
+                }
+                const arrowTabledBatch = {
+                    shape: 'arrow-table',
+                    batchType: 'data',
+                    data: new arrow.Table([recordBatch]),
+                    length: recordBatch.data.length
+                };
+                // processBatch(recordBatch);
+                yield arrowTabledBatch;
+            }
+            break; // only processing one stream of batches
+        }
+    }
+    return makeArrowAsyncIterator(); // as AsyncIterator<ArrowTableBatch>;
 }
-//# sourceMappingURL=parse-arrow-in-batches.js.map
+// function processBatch(batch: RecordBatch): ArrowTableBatch {
+//   const values = {};
+//   batch.schema.fields.forEach(({name}, index) => {
+//     values[name] = batch.getChildAt(index)?.toArray();
+//   });
+//   return {
+//   };
+// }

package/dist/parsers/parse-arrow-sync.d.ts

@@ -1,5 +1,5 @@
 import type { ArrayRowTable, ColumnarTable, ObjectRowTable } from '@loaders.gl/schema';
-import type { ArrowTable } from '../lib/arrow-table';
+import type { ArrowTable } from "../lib/arrow-table.js";
 export declare function parseArrowSync(arrayBuffer: any, options?: {
     shape?: 'arrow-table' | 'columnar-table' | 'object-row-table' | 'array-row-table';
 }): ArrowTable | ColumnarTable | ObjectRowTable | ArrayRowTable;

package/dist/parsers/parse-arrow-sync.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse-arrow-sync.d.ts","sourceRoot":"","sources":["../../src/parsers/parse-arrow-sync.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,aAAa,EAAE,aAAa,EAAE,cAAc,EAAC,MAAM,oBAAoB,CAAC;AACrF,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,oBAAoB,CAAC;AAOnD,wBAAgB,cAAc,CAC5B,WAAW,KAAA,EACX,OAAO,CAAC,EAAE;IAAC,KAAK,CAAC,EAAE,aAAa,GAAG,gBAAgB,GAAG,kBAAkB,GAAG,iBAAiB,CAAA;CAAC,GAC5F,UAAU,GAAG,aAAa,GAAG,cAAc,GAAG,aAAa,CA4B7D"}
+{"version":3,"file":"parse-arrow-sync.d.ts","sourceRoot":"","sources":["../../src/parsers/parse-arrow-sync.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,aAAa,EAAE,aAAa,EAAE,cAAc,EAAC,MAAM,oBAAoB,CAAC;AACrF,OAAO,KAAK,EAAC,UAAU,EAAC,8BAA2B;AAOnD,wBAAgB,cAAc,CAC5B,WAAW,KAAA,EACX,OAAO,CAAC,EAAE;IAAC,KAAK,CAAC,EAAE,aAAa,GAAG,gBAAgB,GAAG,kBAAkB,GAAG,iBAAiB,CAAA;CAAC,GAC5F,UAAU,GAAG,aAAa,GAAG,cAAc,GAAG,aAAa,CA4B7D"}

package/dist/parsers/parse-arrow-sync.js

@@ -1,28 +1,32 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { convertTable } from '@loaders.gl/schema';
 import * as arrow from 'apache-arrow';
 import { convertArrowToColumnarTable } from "../tables/convert-arrow-to-columnar-table.js";
 import { serializeArrowSchema } from "../schema/convert-arrow-schema.js";
+// Parses arrow to a columnar table
 export function parseArrowSync(arrayBuffer, options) {
-  const apacheArrowTable = arrow.tableFromIPC([new Uint8Array(arrayBuffer)]);
-  const arrowTable = {
-    shape: 'arrow-table',
-    schema: serializeArrowSchema(apacheArrowTable.schema),
-    data: apacheArrowTable
-  };
-  const shape = (options === null || options === void 0 ? void 0 : options.shape) || 'arrow-table';
-  switch (shape) {
-    case 'arrow-table':
-      return arrowTable;
-    case 'columnar-table':
-      return convertArrowToColumnarTable(arrowTable);
-    case 'object-row-table':
-      let columnarTable = convertArrowToColumnarTable(arrowTable);
-      return convertTable(columnarTable, 'object-row-table');
-    case 'array-row-table':
-      columnarTable = convertArrowToColumnarTable(arrowTable);
-      return convertTable(columnarTable, 'array-row-table');
-    default:
-      throw new Error(shape);
-  }
+    const apacheArrowTable = arrow.tableFromIPC([new Uint8Array(arrayBuffer)]);
+    const arrowTable = {
+        shape: 'arrow-table',
+        schema: serializeArrowSchema(apacheArrowTable.schema),
+        data: apacheArrowTable
+    };
+    const shape = options?.shape || 'arrow-table';
+    switch (shape) {
+        case 'arrow-table':
+            return arrowTable;
+        case 'columnar-table':
+            return convertArrowToColumnarTable(arrowTable);
+        case 'object-row-table':
+            let columnarTable = convertArrowToColumnarTable(arrowTable);
+            return convertTable(columnarTable, 'object-row-table');
+        case 'array-row-table':
+            columnarTable = convertArrowToColumnarTable(arrowTable);
+            return convertTable(columnarTable, 'array-row-table');
+        default:
+            // TODO
+            throw new Error(shape);
+    }
 }
-//# sourceMappingURL=parse-arrow-sync.js.map

package/dist/parsers/parse-geoarrow-in-batches.d.ts

@@ -1,5 +1,5 @@
 import type { GeoJSONTableBatch } from '@loaders.gl/schema';
-import type { ArrowTableBatch } from '../lib/arrow-table';
+import type { ArrowTableBatch } from "../lib/arrow-table.js";
 /**
  */
 export declare function parseGeoArrowInBatches(asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>): AsyncIterable<ArrowTableBatch | GeoJSONTableBatch>;

package/dist/parsers/parse-geoarrow-in-batches.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse-geoarrow-in-batches.d.ts","sourceRoot":"","sources":["../../src/parsers/parse-geoarrow-in-batches.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,oBAAoB,CAAC;AAC1D,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,oBAAoB,CAAC;AAGxD;GACG;AACH,wBAAgB,sBAAsB,CACpC,aAAa,EAAE,aAAa,CAAC,WAAW,CAAC,GAAG,QAAQ,CAAC,WAAW,CAAC,GAChE,aAAa,CAAC,eAAe,GAAG,iBAAiB,CAAC,CAGpD"}
+{"version":3,"file":"parse-geoarrow-in-batches.d.ts","sourceRoot":"","sources":["../../src/parsers/parse-geoarrow-in-batches.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,oBAAoB,CAAC;AAC1D,OAAO,KAAK,EAAC,eAAe,EAAC,8BAA2B;AAGxD;GACG;AACH,wBAAgB,sBAAsB,CACpC,aAAa,EAAE,aAAa,CAAC,WAAW,CAAC,GAAG,QAAQ,CAAC,WAAW,CAAC,GAChE,aAAa,CAAC,eAAe,GAAG,iBAAiB,CAAC,CAGpD"}

package/dist/parsers/parse-geoarrow-in-batches.js

@@ -1,5 +1,10 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { parseArrowInBatches } from "./parse-arrow-in-batches.js";
+/**
+ */
 export function parseGeoArrowInBatches(asyncIterator) {
-  return parseArrowInBatches(asyncIterator);
+    // | BinaryGeometry
+    return parseArrowInBatches(asyncIterator);
 }
-//# sourceMappingURL=parse-geoarrow-in-batches.js.map

package/dist/parsers/parse-geoarrow-sync.d.ts

@@ -1,5 +1,5 @@
 import type { GeoJSONTable } from '@loaders.gl/schema';
-import type { ArrowTable } from '../lib/arrow-table';
+import type { ArrowTable } from "../lib/arrow-table.js";
 export declare function parseGeoArrowSync(arrayBuffer: any, options?: {
     shape?: 'arrow-table' | 'geojson-table' | 'binary-geometry';
 }): ArrowTable | GeoJSONTable;

package/dist/parsers/parse-geoarrow-sync.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse-geoarrow-sync.d.ts","sourceRoot":"","sources":["../../src/parsers/parse-geoarrow-sync.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,oBAAoB,CAAC;AAKnD,wBAAgB,iBAAiB,CAC/B,WAAW,KAAA,EACX,OAAO,CAAC,EAAE;IAAC,KAAK,CAAC,EAAE,aAAa,GAAG,eAAe,GAAG,iBAAiB,CAAA;CAAC,GACtE,UAAU,GAAG,YAAY,CAS3B"}
+{"version":3,"file":"parse-geoarrow-sync.d.ts","sourceRoot":"","sources":["../../src/parsers/parse-geoarrow-sync.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAC,UAAU,EAAC,8BAA2B;AAKnD,wBAAgB,iBAAiB,CAC/B,WAAW,KAAA,EACX,OAAO,CAAC,EAAE;IAAC,KAAK,CAAC,EAAE,aAAa,GAAG,eAAe,GAAG,iBAAiB,CAAA;CAAC,GACtE,UAAU,GAAG,YAAY,CAS3B"}

package/dist/parsers/parse-geoarrow-sync.js

@@ -1,14 +1,16 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { parseArrowSync } from "./parse-arrow-sync.js";
 import { convertArrowToGeoJSONTable } from "../tables/convert-arrow-to-geojson-table.js";
+// Parses arrow to a columnar table
 export function parseGeoArrowSync(arrayBuffer, options) {
-  const table = parseArrowSync(arrayBuffer, {
-    shape: 'arrow-table'
-  });
-  switch (options === null || options === void 0 ? void 0 : options.shape) {
-    case 'geojson-table':
-      return convertArrowToGeoJSONTable(table);
-    default:
-      return table;
-  }
+    // | BinaryGeometry
+    const table = parseArrowSync(arrayBuffer, { shape: 'arrow-table' });
+    switch (options?.shape) {
+        case 'geojson-table':
+            return convertArrowToGeoJSONTable(table);
+        default:
+            return table;
+    }
 }
-//# sourceMappingURL=parse-geoarrow-sync.js.map

package/dist/schema/arrow-type-utils.js

@@ -1,24 +1,51 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import * as arrow from 'apache-arrow';
+/** Return an Apache Arrow Type instance that corresponds to the type of the elements in the supplied Typed Array */
 export function getArrowType(array) {
+    switch (array.constructor) {
+        case Int8Array:
+            return new arrow.Int8();
+        case Uint8Array:
+            return new arrow.Uint8();
+        case Int16Array:
+            return new arrow.Int16();
+        case Uint16Array:
+            return new arrow.Uint16();
+        case Int32Array:
+            return new arrow.Int32();
+        case Uint32Array:
+            return new arrow.Uint32();
+        case Float32Array:
+            return new arrow.Float32();
+        case Float64Array:
+            return new arrow.Float64();
+        default:
+            throw new Error('array type not supported');
+    }
+}
+/*
+export function getArrowVector(array: TypedArray): AbstractVector {
   switch (array.constructor) {
     case Int8Array:
-      return new arrow.Int8();
+      return Int8Vector.from(array);
     case Uint8Array:
-      return new arrow.Uint8();
+      return Uint8Vector.from(array);
     case Int16Array:
-      return new arrow.Int16();
+      return Int16Vector.from(array);
     case Uint16Array:
-      return new arrow.Uint16();
+      return Uint16Vector.from(array);
     case Int32Array:
-      return new arrow.Int32();
+      return Int32Vector.from(array);
     case Uint32Array:
-      return new arrow.Uint32();
+      return Uint32Vector.from(array);
     case Float32Array:
-      return new arrow.Float32();
+      return Float32Vector.from(array);
     case Float64Array:
-      return new arrow.Float64();
+      return Float64Vector.from(array);
     default:
       throw new Error('array type not supported');
   }
 }
-//# sourceMappingURL=arrow-type-utils.js.map
+*/