@loaders.gl/arrow 4.0.1 → 4.0.2

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

@@ -1,5 +1,5 @@
 import { ColumnarTableBatchAggregator } from '@loaders.gl/schema';
-import { Table as ApacheArrowTable, Schema, Field, RecordBatch, Struct, makeVector, makeData, Float32 } from 'apache-arrow';
+import * as arrow from 'apache-arrow';
 export class ArrowTableBatchAggregator extends ColumnarTableBatchAggregator {
   constructor(schema, options) {
     super(schema, options);
@@ -11,8 +11,8 @@ export class ArrowTableBatchAggregator extends ColumnarTableBatchAggregator {
     if (batch) {
       this.arrowSchema = this.arrowSchema || getArrowSchema(batch.schema);
       const arrowVectors = getArrowVectors(this.arrowSchema, batch.data);
-      const recordBatch = new RecordBatch(this.arrowSchema, makeData({
-        type: new Struct(this.arrowSchema.fields),
+      const recordBatch = new arrow.RecordBatch(this.arrowSchema, arrow.makeData({
+        type: new arrow.Struct(this.arrowSchema.fields),
         children: arrowVectors.map(_ref => {
           let {
             data
@@ -23,7 +23,7 @@ export class ArrowTableBatchAggregator extends ColumnarTableBatchAggregator {
       return {
         shape: 'arrow-table',
         batchType: 'data',
-        data: new ApacheArrowTable([recordBatch]),
+        data: new arrow.Table([recordBatch]),
         length: batch.length
       };
     }
@@ -36,21 +36,21 @@ function getArrowSchema(schema) {
     const field = schema[key];
     if (field.type === Float32Array) {
       const metadata = new Map();
-      const arrowField = new Field(field.name, new Float32(), field.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');
   }
-  return new Schema(arrowFields);
+  return new arrow.Schema(arrowFields);
 }
 function getArrowVectors(arrowSchema, data) {
   const arrowVectors = [];
   for (const field of arrowSchema.fields) {
     const vector = data[field.name];
     if (vector instanceof Float32Array) {
-      const arrowVector = makeVector(vector);
+      const arrowVector = arrow.makeVector(vector);
       arrowVectors.push(arrowVector);
     }
   }

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

@@ -1 +1 @@
-{"version":3,"file":"arrow-table-batch.js","names":["ColumnarTableBatchAggregator","Table","ApacheArrowTable","Schema","Field","RecordBatch","Struct","makeVector","makeData","Float32","ArrowTableBatchAggregator","constructor","schema","options","arrowSchema","getBatch","batch","getArrowSchema","arrowVectors","getArrowVectors","data","recordBatch","type","fields","children","map","_ref","shape","batchType","length","arrowFields","key","field","Float32Array","metadata","Map","arrowField","name","nullable","push","Error","vector","arrowVector"],"sources":["../../src/lib/arrow-table-batch.ts"],"sourcesContent":["import {ColumnarTableBatchAggregator} from '@loaders.gl/schema';\nimport type {ArrowTableBatch} from './arrow-table';\nimport {\n  Table as ApacheArrowTable,\n  Schema,\n  Field,\n  RecordBatch,\n  Struct,\n  makeVector,\n  makeData,\n  Vector,\n  Float32\n} from 'apache-arrow';\n\nexport class ArrowTableBatchAggregator extends ColumnarTableBatchAggregator {\n  arrowSchema: Schema | null;\n\n  constructor(schema, options) {\n    super(schema, options);\n    this.arrowSchema = null;\n  }\n\n  getBatch(): ArrowTableBatch | null {\n    const batch = super.getBatch();\n    if (batch) {\n      // Get the arrow schema\n      this.arrowSchema = this.arrowSchema || getArrowSchema(batch.schema);\n\n      // Get arrow format vectors\n      const arrowVectors = getArrowVectors(this.arrowSchema, batch.data);\n\n      // Create the record batch\n      const recordBatch = new RecordBatch(\n        this.arrowSchema,\n        makeData({\n          type: new Struct(this.arrowSchema.fields),\n          children: arrowVectors.map(({data}) => data[0])\n        })\n      );\n\n      return {\n        shape: 'arrow-table',\n        batchType: 'data',\n        data: new ApacheArrowTable([recordBatch]),\n        length: batch.length\n      };\n    }\n\n    return null;\n  }\n}\n\n// Convert from a simple loaders.gl schema to an Arrow schema\nfunction getArrowSchema(schema): Schema {\n  const arrowFields: Field[] = [];\n  for (const key in schema) {\n    const field = schema[key];\n    if (field.type === Float32Array) {\n      // TODO - just store the original field as metadata?\n      const metadata = new Map(); // field;\n      // arrow: new Field(name, nullable, metadata)\n      const arrowField = new Field(field.name, new Float32(), field.nullable, metadata);\n      arrowFields.push(arrowField);\n    }\n  }\n  if (arrowFields.length === 0) {\n    throw new Error('No arrow convertible fields');\n  }\n\n  return new Schema(arrowFields);\n}\n\n// Convert from simple loaders.gl arrays to arrow vectors\nfunction getArrowVectors(arrowSchema, data): Vector[] {\n  const arrowVectors: any[] = [];\n  for (const field of arrowSchema.fields) {\n    const vector = data[field.name];\n    if (vector instanceof Float32Array) {\n      const arrowVector = makeVector(vector);\n      arrowVectors.push(arrowVector);\n    }\n  }\n  if (arrowSchema.fields.length !== arrowVectors.length) {\n    throw new Error('Some columns not arrow convertible');\n  }\n  return arrowVectors;\n}\n"],"mappings":"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"}
+{"version":3,"file":"arrow-table-batch.js","names":["ColumnarTableBatchAggregator","arrow","ArrowTableBatchAggregator","constructor","schema","options","arrowSchema","getBatch","batch","getArrowSchema","arrowVectors","getArrowVectors","data","recordBatch","RecordBatch","makeData","type","Struct","fields","children","map","_ref","shape","batchType","Table","length","arrowFields","key","field","Float32Array","metadata","Map","arrowField","Field","name","Float32","nullable","push","Error","Schema","vector","arrowVector","makeVector"],"sources":["../../src/lib/arrow-table-batch.ts"],"sourcesContent":["import {ColumnarTableBatchAggregator} from '@loaders.gl/schema';\nimport type {ArrowTableBatch} from './arrow-table';\nimport * as arrow from 'apache-arrow';\n\nexport class ArrowTableBatchAggregator extends ColumnarTableBatchAggregator {\n  arrowSchema: arrow.Schema | null;\n\n  constructor(schema, options) {\n    super(schema, options);\n    this.arrowSchema = null;\n  }\n\n  getBatch(): ArrowTableBatch | null {\n    const batch = super.getBatch();\n    if (batch) {\n      // Get the arrow schema\n      this.arrowSchema = this.arrowSchema || getArrowSchema(batch.schema);\n\n      // Get arrow format vectors\n      const arrowVectors = getArrowVectors(this.arrowSchema, batch.data);\n\n      // Create the record batch\n      const recordBatch = new arrow.RecordBatch(\n        this.arrowSchema,\n        arrow.makeData({\n          type: new arrow.Struct(this.arrowSchema.fields),\n          children: arrowVectors.map(({data}) => data[0])\n        })\n      );\n\n      return {\n        shape: 'arrow-table',\n        batchType: 'data',\n        data: new arrow.Table([recordBatch]),\n        length: batch.length\n      };\n    }\n\n    return null;\n  }\n}\n\n// Convert from a simple loaders.gl schema to an Arrow schema\nfunction getArrowSchema(schema): arrow.Schema {\n  const arrowFields: arrow.Field[] = [];\n  for (const key in schema) {\n    const field = schema[key];\n    if (field.type === Float32Array) {\n      // TODO - just store the original field as metadata?\n      const metadata = new Map(); // field;\n      // arrow: new arrow.Field(name, nullable, metadata)\n      const arrowField = new arrow.Field(field.name, new arrow.Float32(), field.nullable, metadata);\n      arrowFields.push(arrowField);\n    }\n  }\n  if (arrowFields.length === 0) {\n    throw new Error('No arrow convertible fields');\n  }\n\n  return new arrow.Schema(arrowFields);\n}\n\n// Convert from simple loaders.gl arrays to arrow vectors\nfunction getArrowVectors(arrowSchema, data): arrow.Vector[] {\n  const arrowVectors: any[] = [];\n  for (const field of arrowSchema.fields) {\n    const vector = data[field.name];\n    if (vector instanceof Float32Array) {\n      const arrowVector = arrow.makeVector(vector);\n      arrowVectors.push(arrowVector);\n    }\n  }\n  if (arrowSchema.fields.length !== arrowVectors.length) {\n    throw new Error('Some columns not arrow convertible');\n  }\n  return arrowVectors;\n}\n"],"mappings":"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"}

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

@@ -1,5 +1,5 @@
 import type { Batch, Schema } from '@loaders.gl/schema';
-import type { Table as ApacheArrowTable } from 'apache-arrow';
+import type * as arrow from 'apache-arrow';
 /**
  * A table organized as an Apache Arrow table
  * @note This is a variant of the type from loaders.gl/schema
@@ -7,7 +7,7 @@ import type { Table as ApacheArrowTable } from 'apache-arrow';
 export type ArrowTable = {
     shape: 'arrow-table';
     schema?: Schema;
-    data: ApacheArrowTable;
+    data: arrow.Table;
 };
 /**
  * Batch for a table organized as an Apache Arrow table
@@ -17,7 +17,7 @@ export type ArrowTableBatch = Batch & {
     shape: 'arrow-table';
     schemaType?: 'explicit' | 'deduced';
     schema?: Schema;
-    data: ApacheArrowTable;
+    data: arrow.Table;
     length: number;
 };
 //# sourceMappingURL=arrow-table.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"arrow-table.d.ts","sourceRoot":"","sources":["../../src/lib/arrow-table.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,KAAK,EAAE,MAAM,EAAC,MAAM,oBAAoB,CAAC;AACtD,OAAO,KAAK,EAAC,KAAK,IAAI,gBAAgB,EAAC,MAAM,cAAc,CAAC;AAE5D;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,EAAE,aAAa,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,gBAAgB,CAAC;CACxB,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,KAAK,GAAG;IACpC,KAAK,EAAE,aAAa,CAAC;IACrB,UAAU,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC;IACpC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,gBAAgB,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC"}
+{"version":3,"file":"arrow-table.d.ts","sourceRoot":"","sources":["../../src/lib/arrow-table.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,KAAK,EAAE,MAAM,EAAC,MAAM,oBAAoB,CAAC;AACtD,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAC;AAE3C;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,EAAE,aAAa,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC;CACnB,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,KAAK,GAAG;IACpC,KAAK,EAAE,aAAa,CAAC;IACrB,UAAU,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC;IACpC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"arrow-table.js","names":[],"sources":["../../src/lib/arrow-table.ts"],"sourcesContent":["// loaders.gl, MIT license\n// Copyright (c) vis.gl contributors\n\nimport type {Batch, Schema} from '@loaders.gl/schema';\nimport type {Table as ApacheArrowTable} from 'apache-arrow';\n\n/**\n * A table organized as an Apache Arrow table\n * @note This is a variant of the type from loaders.gl/schema\n */\nexport type ArrowTable = {\n  shape: 'arrow-table';\n  schema?: Schema;\n  data: ApacheArrowTable;\n};\n\n/**\n * Batch for a table organized as an Apache Arrow table\n * @note This is a variant of the type from loaders.gl/schema\n */\nexport type ArrowTableBatch = Batch & {\n  shape: 'arrow-table';\n  schemaType?: 'explicit' | 'deduced';\n  schema?: Schema;\n  data: ApacheArrowTable; // ApacheRecordBatch;\n  length: number;\n};\n"],"mappings":""}
+{"version":3,"file":"arrow-table.js","names":[],"sources":["../../src/lib/arrow-table.ts"],"sourcesContent":["// loaders.gl, MIT license\n// Copyright (c) vis.gl contributors\n\nimport type {Batch, Schema} from '@loaders.gl/schema';\nimport type * as arrow from 'apache-arrow';\n\n/**\n * A table organized as an Apache Arrow table\n * @note This is a variant of the type from loaders.gl/schema\n */\nexport type ArrowTable = {\n  shape: 'arrow-table';\n  schema?: Schema;\n  data: arrow.Table;\n};\n\n/**\n * Batch for a table organized as an Apache Arrow table\n * @note This is a variant of the type from loaders.gl/schema\n */\nexport type ArrowTableBatch = Batch & {\n  shape: 'arrow-table';\n  schemaType?: 'explicit' | 'deduced';\n  schema?: Schema;\n  data: arrow.Table; // ApacheRecordBatch;\n  length: number;\n};\n"],"mappings":""}

package/dist/lib/encode-arrow.js

@@ -1,4 +1,4 @@
-import { Table, tableToIPC, vectorFromArray } from 'apache-arrow';
+import * as arrow from 'apache-arrow';
 import { VECTOR_TYPES } from "../types.js";
 export function encodeArrowSync(data) {
   const vectors = {};
@@ -6,17 +6,17 @@ export function encodeArrowSync(data) {
     const arrayVector = createVector(arrayData.array, arrayData.type);
     vectors[arrayData.name] = arrayVector;
   }
-  const table = new Table(vectors);
-  const arrowBuffer = tableToIPC(table);
+  const table = new arrow.Table(vectors);
+  const arrowBuffer = arrow.tableToIPC(table);
   return arrowBuffer;
 }
 function createVector(array, type) {
   switch (type) {
     case VECTOR_TYPES.DATE:
-      return vectorFromArray(array);
+      return arrow.vectorFromArray(array);
     case VECTOR_TYPES.FLOAT:
     default:
-      return vectorFromArray(array);
+      return arrow.vectorFromArray(array);
   }
 }
 //# sourceMappingURL=encode-arrow.js.map

package/dist/lib/encode-arrow.js.map

@@ -1 +1 @@
-{"version":3,"file":"encode-arrow.js","names":["Table","tableToIPC","vectorFromArray","VECTOR_TYPES","encodeArrowSync","data","vectors","arrayData","arrayVector","createVector","array","type","name","table","arrowBuffer","DATE","FLOAT"],"sources":["../../src/lib/encode-arrow.ts"],"sourcesContent":["import {Table, Vector, tableToIPC, vectorFromArray} from 'apache-arrow';\nimport {AnyArrayType, VECTOR_TYPES} from '../types';\n\nexport type ColumnarTable = {\n  name: string;\n  array: AnyArrayType;\n  type: number;\n}[];\n\n/**\n * Encodes set of arrays into the Apache Arrow columnar format\n * https://arrow.apache.org/docs/format/Columnar.html#ipc-file-format\n * @param data - columns data\n * @param options - the writer options\n * @returns - encoded ArrayBuffer\n */\nexport function encodeArrowSync(data: ColumnarTable): ArrayBuffer {\n  const vectors: Record<string, Vector> = {};\n  for (const arrayData of data) {\n    const arrayVector = createVector(arrayData.array, arrayData.type);\n    vectors[arrayData.name] = arrayVector;\n  }\n  const table = new Table(vectors);\n  const arrowBuffer = tableToIPC(table);\n  return arrowBuffer;\n}\n\n/**\n * Create Arrow Vector from given data and vector type\n * @param array {import('../types').AnyArrayType} - columns data\n * @param type {number} - the writer options\n * @return a vector of one of vector's types defined in the Apache Arrow library\n */\nfunction createVector(array, type): Vector {\n  switch (type) {\n    case VECTOR_TYPES.DATE:\n      return vectorFromArray(array);\n    case VECTOR_TYPES.FLOAT:\n    default:\n      return vectorFromArray(array);\n  }\n}\n"],"mappings":"AAAA,SAAQA,KAAK,EAAUC,UAAU,EAAEC,eAAe,QAAO,cAAc;AAAC,SAClDC,YAAY;AAelC,OAAO,SAASC,eAAeA,CAACC,IAAmB,EAAe;EAChE,MAAMC,OAA+B,GAAG,CAAC,CAAC;EAC1C,KAAK,MAAMC,SAAS,IAAIF,IAAI,EAAE;IAC5B,MAAMG,WAAW,GAAGC,YAAY,CAACF,SAAS,CAACG,KAAK,EAAEH,SAAS,CAACI,IAAI,CAAC;IACjEL,OAAO,CAACC,SAAS,CAACK,IAAI,CAAC,GAAGJ,WAAW;EACvC;EACA,MAAMK,KAAK,GAAG,IAAIb,KAAK,CAACM,OAAO,CAAC;EAChC,MAAMQ,WAAW,GAAGb,UAAU,CAACY,KAAK,CAAC;EACrC,OAAOC,WAAW;AACpB;AAQA,SAASL,YAAYA,CAACC,KAAK,EAAEC,IAAI,EAAU;EACzC,QAAQA,IAAI;IACV,KAAKR,YAAY,CAACY,IAAI;MACpB,OAAOb,eAAe,CAACQ,KAAK,CAAC;IAC/B,KAAKP,YAAY,CAACa,KAAK;IACvB;MACE,OAAOd,eAAe,CAACQ,KAAK,CAAC;EACjC;AACF"}
+{"version":3,"file":"encode-arrow.js","names":["arrow","VECTOR_TYPES","encodeArrowSync","data","vectors","arrayData","arrayVector","createVector","array","type","name","table","Table","arrowBuffer","tableToIPC","DATE","vectorFromArray","FLOAT"],"sources":["../../src/lib/encode-arrow.ts"],"sourcesContent":["import * as arrow from 'apache-arrow';\nimport {AnyArrayType, VECTOR_TYPES} from '../types';\n\nexport type ColumnarTable = {\n  name: string;\n  array: AnyArrayType;\n  type: number;\n}[];\n\n/**\n * Encodes set of arrays into the Apache Arrow columnar format\n * https://arrow.apache.org/docs/format/Columnar.html#ipc-file-format\n * @param data - columns data\n * @param options - the writer options\n * @returns - encoded ArrayBuffer\n */\nexport function encodeArrowSync(data: ColumnarTable): ArrayBuffer {\n  const vectors: Record<string, arrow.Vector> = {};\n  for (const arrayData of data) {\n    const arrayVector = createVector(arrayData.array, arrayData.type);\n    vectors[arrayData.name] = arrayVector;\n  }\n  const table = new arrow.Table(vectors);\n  const arrowBuffer = arrow.tableToIPC(table);\n  return arrowBuffer;\n}\n\n/**\n * Create Arrow arrow.Vector from given data and vector type\n * @param array {import('../types').AnyArrayType} - columns data\n * @param type {number} - the writer options\n * @return a vector of one of vector's types defined in the Apache Arrow library\n */\nfunction createVector(array, type): arrow.Vector {\n  switch (type) {\n    case VECTOR_TYPES.DATE:\n      return arrow.vectorFromArray(array);\n    case VECTOR_TYPES.FLOAT:\n    default:\n      return arrow.vectorFromArray(array);\n  }\n}\n"],"mappings":"AAAA,OAAO,KAAKA,KAAK,MAAM,cAAc;AAAC,SAChBC,YAAY;AAelC,OAAO,SAASC,eAAeA,CAACC,IAAmB,EAAe;EAChE,MAAMC,OAAqC,GAAG,CAAC,CAAC;EAChD,KAAK,MAAMC,SAAS,IAAIF,IAAI,EAAE;IAC5B,MAAMG,WAAW,GAAGC,YAAY,CAACF,SAAS,CAACG,KAAK,EAAEH,SAAS,CAACI,IAAI,CAAC;IACjEL,OAAO,CAACC,SAAS,CAACK,IAAI,CAAC,GAAGJ,WAAW;EACvC;EACA,MAAMK,KAAK,GAAG,IAAIX,KAAK,CAACY,KAAK,CAACR,OAAO,CAAC;EACtC,MAAMS,WAAW,GAAGb,KAAK,CAACc,UAAU,CAACH,KAAK,CAAC;EAC3C,OAAOE,WAAW;AACpB;AAQA,SAASN,YAAYA,CAACC,KAAK,EAAEC,IAAI,EAAgB;EAC/C,QAAQA,IAAI;IACV,KAAKR,YAAY,CAACc,IAAI;MACpB,OAAOf,KAAK,CAACgB,eAAe,CAACR,KAAK,CAAC;IACrC,KAAKP,YAAY,CAACgB,KAAK;IACvB;MACE,OAAOjB,KAAK,CAACgB,eAAe,CAACR,KAAK,CAAC;EACvC;AACF"}

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

@@ -1,13 +1,13 @@
-import { RecordBatchReader, Table as ApacheArrowTable } from 'apache-arrow';
+import * as arrow from 'apache-arrow';
 export function parseArrowInBatches(asyncIterator) {
   async function* makeArrowAsyncIterator() {
-    const readers = RecordBatchReader.readAll(asyncIterator);
+    const readers = arrow.RecordBatchReader.readAll(asyncIterator);
     for await (const reader of readers) {
       for await (const recordBatch of reader) {
         const arrowTabledBatch = {
           shape: 'arrow-table',
           batchType: 'data',
-          data: new ApacheArrowTable([recordBatch]),
+          data: new arrow.Table([recordBatch]),
           length: recordBatch.data.length
         };
         yield arrowTabledBatch;

package/dist/lib/parse-arrow-in-batches.js.map

@@ -1 +1 @@
-{"version":3,"file":"parse-arrow-in-batches.js","names":["RecordBatchReader","Table","ApacheArrowTable","parseArrowInBatches","asyncIterator","makeArrowAsyncIterator","readers","readAll","reader","recordBatch","arrowTabledBatch","shape","batchType","data","length"],"sources":["../../src/lib/parse-arrow-in-batches.ts"],"sourcesContent":["// TODO - this import defeats the sophisticated typescript checking in ArrowJS\nimport type {ArrowTableBatch} from './arrow-table';\nimport {RecordBatchReader, Table as ApacheArrowTable} from 'apache-arrow';\n// import {isIterable} from '@loaders.gl/core';\n\n/**\n */\nexport function parseArrowInBatches(\n  asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>\n): AsyncIterable<ArrowTableBatch> {\n  // Creates the appropriate RecordBatchReader subclasses from the input\n  // This will also close the underlying source in case of early termination or errors\n\n  // As an optimization, return a non-async iterator\n  /*\n  if (isIterable(readers)) {\n    function* makeArrowIterator() {\n      for (const reader of readers) {\n        for (const batch of reader) {\n          yield processBatch(batch, reader);\n        }\n        break; // only processing one stream of batches\n      }\n    }\n    const arrowIterator = makeArrowIterator();\n  }\n  */\n\n  async function* makeArrowAsyncIterator(): AsyncIterator<ArrowTableBatch> {\n    // @ts-ignore\n    const readers = RecordBatchReader.readAll(asyncIterator);\n    for await (const reader of readers) {\n      for await (const recordBatch of reader) {\n        const arrowTabledBatch: ArrowTableBatch = {\n          shape: 'arrow-table',\n          batchType: 'data',\n          data: new ApacheArrowTable([recordBatch]),\n          length: recordBatch.data.length\n        };\n        // processBatch(recordBatch);\n        yield arrowTabledBatch;\n      }\n      break; // only processing one stream of batches\n    }\n  }\n\n  return makeArrowAsyncIterator() as any; // as AsyncIterator<ArrowTableBatch>;\n}\n\n// function processBatch(batch: RecordBatch): ArrowTableBatch {\n//   const values = {};\n//   batch.schema.fields.forEach(({name}, index) => {\n//     values[name] = batch.getChildAt(index)?.toArray();\n//   });\n//   return {\n//   };\n// }\n"],"mappings":"AAEA,SAAQA,iBAAiB,EAAEC,KAAK,IAAIC,gBAAgB,QAAO,cAAc;AAKzE,OAAO,SAASC,mBAAmBA,CACjCC,aAAiE,EACjC;EAmBhC,gBAAgBC,sBAAsBA,CAAA,EAAmC;IAEvE,MAAMC,OAAO,GAAGN,iBAAiB,CAACO,OAAO,CAACH,aAAa,CAAC;IACxD,WAAW,MAAMI,MAAM,IAAIF,OAAO,EAAE;MAClC,WAAW,MAAMG,WAAW,IAAID,MAAM,EAAE;QACtC,MAAME,gBAAiC,GAAG;UACxCC,KAAK,EAAE,aAAa;UACpBC,SAAS,EAAE,MAAM;UACjBC,IAAI,EAAE,IAAIX,gBAAgB,CAAC,CAACO,WAAW,CAAC,CAAC;UACzCK,MAAM,EAAEL,WAAW,CAACI,IAAI,CAACC;QAC3B,CAAC;QAED,MAAMJ,gBAAgB;MACxB;MACA;IACF;EACF;EAEA,OAAOL,sBAAsB,CAAC,CAAC;AACjC"}
+{"version":3,"file":"parse-arrow-in-batches.js","names":["arrow","parseArrowInBatches","asyncIterator","makeArrowAsyncIterator","readers","RecordBatchReader","readAll","reader","recordBatch","arrowTabledBatch","shape","batchType","data","Table","length"],"sources":["../../src/lib/parse-arrow-in-batches.ts"],"sourcesContent":["// TODO - this import defeats the sophisticated typescript checking in ArrowJS\nimport type {ArrowTableBatch} from './arrow-table';\nimport * as arrow from 'apache-arrow';\n// import {isIterable} from '@loaders.gl/core';\n\n/**\n */\nexport function parseArrowInBatches(\n  asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>\n): AsyncIterable<ArrowTableBatch> {\n  // Creates the appropriate arrow.RecordBatchReader subclasses from the input\n  // This will also close the underlying source in case of early termination or errors\n\n  // As an optimization, return a non-async iterator\n  /*\n  if (isIterable(readers)) {\n    function* makeArrowIterator() {\n      for (const reader of readers) {\n        for (const batch of reader) {\n          yield processBatch(batch, reader);\n        }\n        break; // only processing one stream of batches\n      }\n    }\n    const arrowIterator = makeArrowIterator();\n  }\n  */\n\n  async function* makeArrowAsyncIterator(): AsyncIterator<ArrowTableBatch> {\n    // @ts-ignore\n    const readers = arrow.RecordBatchReader.readAll(asyncIterator);\n    for await (const reader of readers) {\n      for await (const recordBatch of reader) {\n        const arrowTabledBatch: ArrowTableBatch = {\n          shape: 'arrow-table',\n          batchType: 'data',\n          data: new arrow.Table([recordBatch]),\n          length: recordBatch.data.length\n        };\n        // processBatch(recordBatch);\n        yield arrowTabledBatch;\n      }\n      break; // only processing one stream of batches\n    }\n  }\n\n  return makeArrowAsyncIterator() as any; // as AsyncIterator<ArrowTableBatch>;\n}\n\n// function processBatch(batch: RecordBatch): ArrowTableBatch {\n//   const values = {};\n//   batch.schema.fields.forEach(({name}, index) => {\n//     values[name] = batch.getChildAt(index)?.toArray();\n//   });\n//   return {\n//   };\n// }\n"],"mappings":"AAEA,OAAO,KAAKA,KAAK,MAAM,cAAc;AAKrC,OAAO,SAASC,mBAAmBA,CACjCC,aAAiE,EACjC;EAmBhC,gBAAgBC,sBAAsBA,CAAA,EAAmC;IAEvE,MAAMC,OAAO,GAAGJ,KAAK,CAACK,iBAAiB,CAACC,OAAO,CAACJ,aAAa,CAAC;IAC9D,WAAW,MAAMK,MAAM,IAAIH,OAAO,EAAE;MAClC,WAAW,MAAMI,WAAW,IAAID,MAAM,EAAE;QACtC,MAAME,gBAAiC,GAAG;UACxCC,KAAK,EAAE,aAAa;UACpBC,SAAS,EAAE,MAAM;UACjBC,IAAI,EAAE,IAAIZ,KAAK,CAACa,KAAK,CAAC,CAACL,WAAW,CAAC,CAAC;UACpCM,MAAM,EAAEN,WAAW,CAACI,IAAI,CAACE;QAC3B,CAAC;QAED,MAAML,gBAAgB;MACxB;MACA;IACF;EACF;EAEA,OAAON,sBAAsB,CAAC,CAAC;AACjC"}

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

@@ -1,9 +1,9 @@
 import { convertTable } from '@loaders.gl/schema';
-import { tableFromIPC } from 'apache-arrow';
+import * as arrow from 'apache-arrow';
 import { convertApacheArrowToArrowTable, convertArrowToColumnarTable } from "../tables/convert-arrow-to-table.js";
 export default function parseArrowSync(arrayBuffer, options) {
   var _options$arrow;
-  const apacheArrowTable = tableFromIPC([new Uint8Array(arrayBuffer)]);
+  const apacheArrowTable = arrow.tableFromIPC([new Uint8Array(arrayBuffer)]);
   const arrowTable = convertApacheArrowToArrowTable(apacheArrowTable);
   const shape = (options === null || options === void 0 ? void 0 : (_options$arrow = options.arrow) === null || _options$arrow === void 0 ? void 0 : _options$arrow.shape) || 'arrow-table';
   switch (shape) {

package/dist/lib/parse-arrow-sync.js.map

@@ -1 +1 @@
-{"version":3,"file":"parse-arrow-sync.js","names":["convertTable","tableFromIPC","convertApacheArrowToArrowTable","convertArrowToColumnarTable","parseArrowSync","arrayBuffer","options","_options$arrow","apacheArrowTable","Uint8Array","arrowTable","shape","arrow","columnarTable","Error"],"sources":["../../src/lib/parse-arrow-sync.ts"],"sourcesContent":["import type {ColumnarTable, ObjectRowTable} from '@loaders.gl/schema';\nimport type {ArrowTable} from './arrow-table';\nimport {convertTable} from '@loaders.gl/schema';\nimport {tableFromIPC} from 'apache-arrow';\nimport type {ArrowLoaderOptions} from '../arrow-loader';\nimport {\n  convertApacheArrowToArrowTable,\n  convertArrowToColumnarTable\n} from '../tables/convert-arrow-to-table';\n\n// Parses arrow to a columnar table\nexport default function parseArrowSync(\n  arrayBuffer,\n  options?: ArrowLoaderOptions\n): ArrowTable | ColumnarTable | ObjectRowTable {\n  const apacheArrowTable = tableFromIPC([new Uint8Array(arrayBuffer)]);\n  const arrowTable = convertApacheArrowToArrowTable(apacheArrowTable);\n\n  const shape = options?.arrow?.shape || 'arrow-table';\n  switch (shape) {\n    case 'arrow-table':\n      return arrowTable;\n\n    case 'columnar-table':\n      return convertArrowToColumnarTable(arrowTable);\n\n    case 'object-row-table':\n      const columnarTable = convertArrowToColumnarTable(arrowTable);\n      return convertTable(columnarTable, 'object-row-table');\n\n    default:\n      // TODO\n      throw new Error(shape);\n  }\n}\n"],"mappings":"AAEA,SAAQA,YAAY,QAAO,oBAAoB;AAC/C,SAAQC,YAAY,QAAO,cAAc;AAAC,SAGxCC,8BAA8B,EAC9BC,2BAA2B;AAI7B,eAAe,SAASC,cAAcA,CACpCC,WAAW,EACXC,OAA4B,EACiB;EAAA,IAAAC,cAAA;EAC7C,MAAMC,gBAAgB,GAAGP,YAAY,CAAC,CAAC,IAAIQ,UAAU,CAACJ,WAAW,CAAC,CAAC,CAAC;EACpE,MAAMK,UAAU,GAAGR,8BAA8B,CAACM,gBAAgB,CAAC;EAEnE,MAAMG,KAAK,GAAG,CAAAL,OAAO,aAAPA,OAAO,wBAAAC,cAAA,GAAPD,OAAO,CAAEM,KAAK,cAAAL,cAAA,uBAAdA,cAAA,CAAgBI,KAAK,KAAI,aAAa;EACpD,QAAQA,KAAK;IACX,KAAK,aAAa;MAChB,OAAOD,UAAU;IAEnB,KAAK,gBAAgB;MACnB,OAAOP,2BAA2B,CAACO,UAAU,CAAC;IAEhD,KAAK,kBAAkB;MACrB,MAAMG,aAAa,GAAGV,2BAA2B,CAACO,UAAU,CAAC;MAC7D,OAAOV,YAAY,CAACa,aAAa,EAAE,kBAAkB,CAAC;IAExD;MAEE,MAAM,IAAIC,KAAK,CAACH,KAAK,CAAC;EAC1B;AACF"}
+{"version":3,"file":"parse-arrow-sync.js","names":["convertTable","arrow","convertApacheArrowToArrowTable","convertArrowToColumnarTable","parseArrowSync","arrayBuffer","options","_options$arrow","apacheArrowTable","tableFromIPC","Uint8Array","arrowTable","shape","columnarTable","Error"],"sources":["../../src/lib/parse-arrow-sync.ts"],"sourcesContent":["import type {ColumnarTable, ObjectRowTable} from '@loaders.gl/schema';\nimport type {ArrowTable} from './arrow-table';\nimport {convertTable} from '@loaders.gl/schema';\nimport * as arrow from 'apache-arrow';\nimport type {ArrowLoaderOptions} from '../arrow-loader';\nimport {\n  convertApacheArrowToArrowTable,\n  convertArrowToColumnarTable\n} from '../tables/convert-arrow-to-table';\n\n// Parses arrow to a columnar table\nexport default function parseArrowSync(\n  arrayBuffer,\n  options?: ArrowLoaderOptions\n): ArrowTable | ColumnarTable | ObjectRowTable {\n  const apacheArrowTable = arrow.tableFromIPC([new Uint8Array(arrayBuffer)]);\n  const arrowTable = convertApacheArrowToArrowTable(apacheArrowTable);\n\n  const shape = options?.arrow?.shape || 'arrow-table';\n  switch (shape) {\n    case 'arrow-table':\n      return arrowTable;\n\n    case 'columnar-table':\n      return convertArrowToColumnarTable(arrowTable);\n\n    case 'object-row-table':\n      const columnarTable = convertArrowToColumnarTable(arrowTable);\n      return convertTable(columnarTable, 'object-row-table');\n\n    default:\n      // TODO\n      throw new Error(shape);\n  }\n}\n"],"mappings":"AAEA,SAAQA,YAAY,QAAO,oBAAoB;AAC/C,OAAO,KAAKC,KAAK,MAAM,cAAc;AAAC,SAGpCC,8BAA8B,EAC9BC,2BAA2B;AAI7B,eAAe,SAASC,cAAcA,CACpCC,WAAW,EACXC,OAA4B,EACiB;EAAA,IAAAC,cAAA;EAC7C,MAAMC,gBAAgB,GAAGP,KAAK,CAACQ,YAAY,CAAC,CAAC,IAAIC,UAAU,CAACL,WAAW,CAAC,CAAC,CAAC;EAC1E,MAAMM,UAAU,GAAGT,8BAA8B,CAACM,gBAAgB,CAAC;EAEnE,MAAMI,KAAK,GAAG,CAAAN,OAAO,aAAPA,OAAO,wBAAAC,cAAA,GAAPD,OAAO,CAAEL,KAAK,cAAAM,cAAA,uBAAdA,cAAA,CAAgBK,KAAK,KAAI,aAAa;EACpD,QAAQA,KAAK;IACX,KAAK,aAAa;MAChB,OAAOD,UAAU;IAEnB,KAAK,gBAAgB;MACnB,OAAOR,2BAA2B,CAACQ,UAAU,CAAC;IAEhD,KAAK,kBAAkB;MACrB,MAAME,aAAa,GAAGV,2BAA2B,CAACQ,UAAU,CAAC;MAC7D,OAAOX,YAAY,CAACa,aAAa,EAAE,kBAAkB,CAAC;IAExD;MAEE,MAAM,IAAIC,KAAK,CAACF,KAAK,CAAC;EAC1B;AACF"}

package/dist/schema/arrow-type-utils.d.ts

@@ -1,5 +1,5 @@
 import type { TypedArray } from '@loaders.gl/schema';
-import { DataType } from 'apache-arrow';
+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 declare function getArrowType(array: TypedArray): DataType;
+export declare function getArrowType(array: TypedArray): arrow.DataType;
 //# sourceMappingURL=arrow-type-utils.d.ts.map

package/dist/schema/arrow-type-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"arrow-type-utils.d.ts","sourceRoot":"","sources":["../../src/schema/arrow-type-utils.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,oBAAoB,CAAC;AACnD,OAAO,EACL,QAAQ,EAiBT,MAAM,cAAc,CAAC;AAGtB,oHAAoH;AACpH,wBAAgB,YAAY,CAAC,KAAK,EAAE,UAAU,GAAG,QAAQ,CAqBxD"}
+{"version":3,"file":"arrow-type-utils.d.ts","sourceRoot":"","sources":["../../src/schema/arrow-type-utils.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,oBAAoB,CAAC;AACnD,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAEtC,oHAAoH;AACpH,wBAAgB,YAAY,CAAC,KAAK,EAAE,UAAU,GAAG,KAAK,CAAC,QAAQ,CAqB9D"}

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

@@ -1,22 +1,22 @@
-import { Float32, Float64, Int16, Int32, Int8, Uint16, Uint32, Uint8 } from 'apache-arrow';
+import * as arrow from 'apache-arrow';
 export function getArrowType(array) {
   switch (array.constructor) {
     case Int8Array:
-      return new Int8();
+      return new arrow.Int8();
     case Uint8Array:
-      return new Uint8();
+      return new arrow.Uint8();
     case Int16Array:
-      return new Int16();
+      return new arrow.Int16();
     case Uint16Array:
-      return new Uint16();
+      return new arrow.Uint16();
     case Int32Array:
-      return new Int32();
+      return new arrow.Int32();
     case Uint32Array:
-      return new Uint32();
+      return new arrow.Uint32();
     case Float32Array:
-      return new Float32();
+      return new arrow.Float32();
     case Float64Array:
-      return new Float64();
+      return new arrow.Float64();
     default:
       throw new Error('array type not supported');
   }

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

@@ -1 +1 @@
-{"version":3,"file":"arrow-type-utils.js","names":["Float32","Float64","Int16","Int32","Int8","Uint16","Uint32","Uint8","getArrowType","array","constructor","Int8Array","Uint8Array","Int16Array","Uint16Array","Int32Array","Uint32Array","Float32Array","Float64Array","Error"],"sources":["../../src/schema/arrow-type-utils.ts"],"sourcesContent":["// loaders.gl, MIT license\n// Copyright (c) vis.gl contributors\n\nimport type {TypedArray} from '@loaders.gl/schema';\nimport {\n  DataType,\n  Float32,\n  Float64,\n  Int16,\n  Int32,\n  Int8,\n  Uint16,\n  Uint32,\n  Uint8\n  // Int8Vector,\n  // Uint8Vector,\n  // Int16Vector,\n  // Uint16Vector,\n  // Int32Vector,\n  // Uint32Vector,\n  // Float32Vector,\n  // Float64Vector\n} from 'apache-arrow';\n// import {AbstractVector} from 'apache-arrow/vector';\n\n/** Return an Apache Arrow Type instance that corresponds to the type of the elements in the supplied Typed Array */\nexport function getArrowType(array: TypedArray): DataType {\n  switch (array.constructor) {\n    case Int8Array:\n      return new Int8();\n    case Uint8Array:\n      return new Uint8();\n    case Int16Array:\n      return new Int16();\n    case Uint16Array:\n      return new Uint16();\n    case Int32Array:\n      return new Int32();\n    case Uint32Array:\n      return new Uint32();\n    case Float32Array:\n      return new Float32();\n    case Float64Array:\n      return new Float64();\n    default:\n      throw new Error('array type not supported');\n  }\n}\n\n/*\nexport function getArrowVector(array: TypedArray): AbstractVector {\n  switch (array.constructor) {\n    case Int8Array:\n      return Int8Vector.from(array);\n    case Uint8Array:\n      return Uint8Vector.from(array);\n    case Int16Array:\n      return Int16Vector.from(array);\n    case Uint16Array:\n      return Uint16Vector.from(array);\n    case Int32Array:\n      return Int32Vector.from(array);\n    case Uint32Array:\n      return Uint32Vector.from(array);\n    case Float32Array:\n      return Float32Vector.from(array);\n    case Float64Array:\n      return Float64Vector.from(array);\n    default:\n      throw new Error('array type not supported');\n  }\n}\n*/\n"],"mappings":"AAIA,SAEEA,OAAO,EACPC,OAAO,EACPC,KAAK,EACLC,KAAK,EACLC,IAAI,EACJC,MAAM,EACNC,MAAM,EACNC,KAAK,QASA,cAAc;AAIrB,OAAO,SAASC,YAAYA,CAACC,KAAiB,EAAY;EACxD,QAAQA,KAAK,CAACC,WAAW;IACvB,KAAKC,SAAS;MACZ,OAAO,IAAIP,IAAI,CAAC,CAAC;IACnB,KAAKQ,UAAU;MACb,OAAO,IAAIL,KAAK,CAAC,CAAC;IACpB,KAAKM,UAAU;MACb,OAAO,IAAIX,KAAK,CAAC,CAAC;IACpB,KAAKY,WAAW;MACd,OAAO,IAAIT,MAAM,CAAC,CAAC;IACrB,KAAKU,UAAU;MACb,OAAO,IAAIZ,KAAK,CAAC,CAAC;IACpB,KAAKa,WAAW;MACd,OAAO,IAAIV,MAAM,CAAC,CAAC;IACrB,KAAKW,YAAY;MACf,OAAO,IAAIjB,OAAO,CAAC,CAAC;IACtB,KAAKkB,YAAY;MACf,OAAO,IAAIjB,OAAO,CAAC,CAAC;IACtB;MACE,MAAM,IAAIkB,KAAK,CAAC,0BAA0B,CAAC;EAC/C;AACF"}
+{"version":3,"file":"arrow-type-utils.js","names":["arrow","getArrowType","array","constructor","Int8Array","Int8","Uint8Array","Uint8","Int16Array","Int16","Uint16Array","Uint16","Int32Array","Int32","Uint32Array","Uint32","Float32Array","Float32","Float64Array","Float64","Error"],"sources":["../../src/schema/arrow-type-utils.ts"],"sourcesContent":["// loaders.gl, MIT license\n// Copyright (c) vis.gl contributors\n\nimport type {TypedArray} from '@loaders.gl/schema';\nimport * as arrow from 'apache-arrow';\n\n/** Return an Apache Arrow Type instance that corresponds to the type of the elements in the supplied Typed Array */\nexport function getArrowType(array: TypedArray): arrow.DataType {\n  switch (array.constructor) {\n    case Int8Array:\n      return new arrow.Int8();\n    case Uint8Array:\n      return new arrow.Uint8();\n    case Int16Array:\n      return new arrow.Int16();\n    case Uint16Array:\n      return new arrow.Uint16();\n    case Int32Array:\n      return new arrow.Int32();\n    case Uint32Array:\n      return new arrow.Uint32();\n    case Float32Array:\n      return new arrow.Float32();\n    case Float64Array:\n      return new arrow.Float64();\n    default:\n      throw new Error('array type not supported');\n  }\n}\n\n/*\nexport function getArrowVector(array: TypedArray): AbstractVector {\n  switch (array.constructor) {\n    case Int8Array:\n      return Int8Vector.from(array);\n    case Uint8Array:\n      return Uint8Vector.from(array);\n    case Int16Array:\n      return Int16Vector.from(array);\n    case Uint16Array:\n      return Uint16Vector.from(array);\n    case Int32Array:\n      return Int32Vector.from(array);\n    case Uint32Array:\n      return Uint32Vector.from(array);\n    case Float32Array:\n      return Float32Vector.from(array);\n    case Float64Array:\n      return Float64Vector.from(array);\n    default:\n      throw new Error('array type not supported');\n  }\n}\n*/\n"],"mappings":"AAIA,OAAO,KAAKA,KAAK,MAAM,cAAc;AAGrC,OAAO,SAASC,YAAYA,CAACC,KAAiB,EAAkB;EAC9D,QAAQA,KAAK,CAACC,WAAW;IACvB,KAAKC,SAAS;MACZ,OAAO,IAAIJ,KAAK,CAACK,IAAI,CAAC,CAAC;IACzB,KAAKC,UAAU;MACb,OAAO,IAAIN,KAAK,CAACO,KAAK,CAAC,CAAC;IAC1B,KAAKC,UAAU;MACb,OAAO,IAAIR,KAAK,CAACS,KAAK,CAAC,CAAC;IAC1B,KAAKC,WAAW;MACd,OAAO,IAAIV,KAAK,CAACW,MAAM,CAAC,CAAC;IAC3B,KAAKC,UAAU;MACb,OAAO,IAAIZ,KAAK,CAACa,KAAK,CAAC,CAAC;IAC1B,KAAKC,WAAW;MACd,OAAO,IAAId,KAAK,CAACe,MAAM,CAAC,CAAC;IAC3B,KAAKC,YAAY;MACf,OAAO,IAAIhB,KAAK,CAACiB,OAAO,CAAC,CAAC;IAC5B,KAAKC,YAAY;MACf,OAAO,IAAIlB,KAAK,CAACmB,OAAO,CAAC,CAAC;IAC5B;MACE,MAAM,IAAIC,KAAK,CAAC,0BAA0B,CAAC;EAC/C;AACF"}

package/dist/schema/convert-arrow-schema.d.ts

@@ -1,19 +1,19 @@
 import type { DataType, Field, Schema, SchemaMetadata } from '@loaders.gl/schema';
-import { Field as ArrowField, Schema as ArrowSchema, DataType as ArrowDataType } from 'apache-arrow';
+import * as arrow from 'apache-arrow';
 /** Convert Apache Arrow Schema (class instance) to a serialized Schema (plain data) */
-export declare function serializeArrowSchema(arrowSchema: ArrowSchema): Schema;
+export declare function serializeArrowSchema(arrowSchema: arrow.Schema): Schema;
 /** Convert a serialized Schema (plain data) to an Apache Arrow Schema (class instance) */
-export declare function deserializeArrowSchema(schema: Schema): ArrowSchema;
+export declare function deserializeArrowSchema(schema: Schema): arrow.Schema;
 /** Convert Apache Arrow Schema metadata (Map<string, string>) to serialized metadata (Record<string, string> */
 export declare function serializeArrowMetadata(arrowMetadata: Map<string, string>): SchemaMetadata;
 /** Convert serialized metadata (Record<string, string> to Apache Arrow Schema metadata (Map<string, string>) to */
 export declare function deserializeArrowMetadata(metadata?: SchemaMetadata): Map<string, string>;
 /** Convert Apache Arrow Field (class instance) to serialized Field (plain data) */
-export declare function serializeArrowField(field: ArrowField): Field;
+export declare function serializeArrowField(field: arrow.Field): Field;
 /** Convert a serialized Field (plain data) to an Apache Arrow Field (class instance)*/
-export declare function deserializeArrowField(field: Field): ArrowField;
+export declare function deserializeArrowField(field: Field): arrow.Field;
 /** Converts a serializable loaders.gl data type to hydrated arrow data type */
-export declare function serializeArrowType(arrowType: ArrowDataType): DataType;
+export declare function serializeArrowType(arrowType: arrow.DataType): DataType;
 /** Converts a serializable loaders.gl data type to hydrated arrow data type */
-export declare function deserializeArrowType(dataType: DataType): ArrowDataType;
+export declare function deserializeArrowType(dataType: DataType): arrow.DataType;
 //# sourceMappingURL=convert-arrow-schema.d.ts.map

package/dist/schema/convert-arrow-schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"convert-arrow-schema.d.ts","sourceRoot":"","sources":["../../src/schema/convert-arrow-schema.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,cAAc,EAAC,MAAM,oBAAoB,CAAC;AAChF,OAAO,EACL,KAAK,IAAI,UAAU,EACnB,MAAM,IAAI,WAAW,EACrB,QAAQ,IAAI,aAAa,EAyC1B,MAAM,cAAc,CAAC;AAEtB,uFAAuF;AACvF,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,WAAW,GAAG,MAAM,CAKrE;AAED,0FAA0F;AAC1F,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,CAKlE;AAED,gHAAgH;AAChH,wBAAgB,sBAAsB,CAAC,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,cAAc,CAEzF;AAED,mHAAmH;AACnH,wBAAgB,wBAAwB,CAAC,QAAQ,CAAC,EAAE,cAAc,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAEvF;AAED,mFAAmF;AACnF,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,GAAG,KAAK,CAO5D;AAED,uFAAuF;AACvF,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,KAAK,GAAG,UAAU,CAO9D;AAED,+EAA+E;AAE/E,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,aAAa,GAAG,QAAQ,CAmIrE;AAED,+EAA+E;AAE/E,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,GAAG,aAAa,CA2EtE"}
+{"version":3,"file":"convert-arrow-schema.d.ts","sourceRoot":"","sources":["../../src/schema/convert-arrow-schema.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,cAAc,EAAC,MAAM,oBAAoB,CAAC;AAChF,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAEtC,uFAAuF;AACvF,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAKtE;AAED,0FAA0F;AAC1F,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK,CAAC,MAAM,CAKnE;AAED,gHAAgH;AAChH,wBAAgB,sBAAsB,CAAC,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,cAAc,CAEzF;AAED,mHAAmH;AACnH,wBAAgB,wBAAwB,CAAC,QAAQ,CAAC,EAAE,cAAc,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAEvF;AAED,mFAAmF;AACnF,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,GAAG,KAAK,CAO7D;AAED,uFAAuF;AACvF,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAAC,KAAK,CAO/D;AAED,+EAA+E;AAE/E,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,KAAK,CAAC,QAAQ,GAAG,QAAQ,CAmItE;AAED,+EAA+E;AAE/E,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,GAAG,KAAK,CAAC,QAAQ,CA2EvE"}

package/dist/schema/convert-arrow-schema.js

@@ -1,4 +1,4 @@
-import { Field as ArrowField, Schema as ArrowSchema, Null, Binary, Bool, Int, Int8, Int16, Int32, Int64, Uint8, Uint16, Uint32, Uint64, Float, Float16, Float32, Float64, Precision, Utf8, DateUnit, DateDay, DateMillisecond, Time, TimeMillisecond, TimeSecond, Timestamp, TimestampSecond, TimestampMillisecond, TimestampMicrosecond, TimestampNanosecond, Interval, IntervalUnit, IntervalDayTime, IntervalYearMonth, FixedSizeList, Struct, TimeUnit, TimeMicrosecond, TimeNanosecond, List } from 'apache-arrow';
+import * as arrow from 'apache-arrow';
 export function serializeArrowSchema(arrowSchema) {
   return {
     fields: arrowSchema.fields.map(arrowField => serializeArrowField(arrowField)),
@@ -6,7 +6,7 @@ export function serializeArrowSchema(arrowSchema) {
   };
 }
 export function deserializeArrowSchema(schema) {
-  return new ArrowSchema(schema.fields.map(field => deserializeArrowField(field)), deserializeArrowMetadata(schema.metadata));
+  return new arrow.Schema(schema.fields.map(field => deserializeArrowField(field)), deserializeArrowMetadata(schema.metadata));
 }
 export function serializeArrowMetadata(arrowMetadata) {
   return Object.fromEntries(arrowMetadata);
@@ -23,128 +23,128 @@ export function serializeArrowField(field) {
   };
 }
 export function deserializeArrowField(field) {
-  return new ArrowField(field.name, deserializeArrowType(field.type), field.nullable, deserializeArrowMetadata(field.metadata));
+  return new arrow.Field(field.name, deserializeArrowType(field.type), field.nullable, deserializeArrowMetadata(field.metadata));
 }
 export function serializeArrowType(arrowType) {
   switch (arrowType.constructor) {
-    case Null:
+    case arrow.Null:
       return 'null';
-    case Binary:
+    case arrow.Binary:
       return 'binary';
-    case Bool:
+    case arrow.Bool:
       return 'bool';
-    case Int:
+    case arrow.Int:
       const intType = arrowType;
       return `${intType.isSigned ? 'u' : ''}int${intType.bitWidth}`;
-    case Int8:
+    case arrow.Int8:
       return 'int8';
-    case Int16:
+    case arrow.Int16:
       return 'int16';
-    case Int32:
+    case arrow.Int32:
       return 'int32';
-    case Int64:
+    case arrow.Int64:
       return 'int64';
-    case Uint8:
+    case arrow.Uint8:
       return 'uint8';
-    case Uint16:
+    case arrow.Uint16:
       return 'uint16';
-    case Uint32:
+    case arrow.Uint32:
       return 'uint32';
-    case Uint64:
+    case arrow.Uint64:
       return 'uint64';
-    case Float:
+    case arrow.Float:
       const precision = arrowType.precision;
       switch (precision) {
-        case Precision.HALF:
+        case arrow.Precision.HALF:
           return 'float16';
-        case Precision.SINGLE:
+        case arrow.Precision.SINGLE:
           return 'float32';
-        case Precision.DOUBLE:
+        case arrow.Precision.DOUBLE:
           return 'float64';
         default:
           return 'float16';
       }
-    case Float16:
+    case arrow.Float16:
       return 'float16';
-    case Float32:
+    case arrow.Float32:
       return 'float32';
-    case Float64:
+    case arrow.Float64:
       return 'float64';
-    case Utf8:
+    case arrow.Utf8:
       return 'utf8';
     case Date:
       const dateUnit = arrowType.unit;
-      return dateUnit === DateUnit.DAY ? 'date-day' : 'date-millisecond';
-    case DateDay:
+      return dateUnit === arrow.DateUnit.DAY ? 'date-day' : 'date-millisecond';
+    case arrow.DateDay:
       return 'date-day';
-    case DateMillisecond:
+    case arrow.DateMillisecond:
       return 'date-millisecond';
-    case Time:
+    case arrow.Time:
       const timeUnit = arrowType.unit;
       switch (timeUnit) {
-        case TimeUnit.SECOND:
+        case arrow.TimeUnit.SECOND:
           return 'time-second';
-        case TimeUnit.MILLISECOND:
+        case arrow.TimeUnit.MILLISECOND:
           return 'time-millisecond';
-        case TimeUnit.MICROSECOND:
+        case arrow.TimeUnit.MICROSECOND:
           return 'time-microsecond';
-        case TimeUnit.NANOSECOND:
+        case arrow.TimeUnit.NANOSECOND:
           return 'time-nanosecond';
         default:
           return 'time-second';
       }
-    case TimeMillisecond:
+    case arrow.TimeMillisecond:
       return 'time-millisecond';
-    case TimeSecond:
+    case arrow.TimeSecond:
       return 'time-second';
-    case TimeMicrosecond:
+    case arrow.TimeMicrosecond:
       return 'time-microsecond';
-    case TimeNanosecond:
+    case arrow.TimeNanosecond:
       return 'time-nanosecond';
-    case Timestamp:
+    case arrow.Timestamp:
       const timeStampUnit = arrowType.unit;
       switch (timeStampUnit) {
-        case TimeUnit.SECOND:
+        case arrow.TimeUnit.SECOND:
           return 'timestamp-second';
-        case TimeUnit.MILLISECOND:
+        case arrow.TimeUnit.MILLISECOND:
           return 'timestamp-millisecond';
-        case TimeUnit.MICROSECOND:
+        case arrow.TimeUnit.MICROSECOND:
           return 'timestamp-microsecond';
-        case TimeUnit.NANOSECOND:
+        case arrow.TimeUnit.NANOSECOND:
           return 'timestamp-nanosecond';
         default:
           return 'timestamp-second';
       }
-    case TimestampSecond:
+    case arrow.TimestampSecond:
       return 'timestamp-second';
-    case TimestampMillisecond:
+    case arrow.TimestampMillisecond:
       return 'timestamp-millisecond';
-    case TimestampMicrosecond:
+    case arrow.TimestampMicrosecond:
       return 'timestamp-microsecond';
-    case TimestampNanosecond:
+    case arrow.TimestampNanosecond:
       return 'timestamp-nanosecond';
-    case Interval:
+    case arrow.Interval:
       const intervalUnit = arrowType.unit;
       switch (intervalUnit) {
-        case IntervalUnit.DAY_TIME:
+        case arrow.IntervalUnit.DAY_TIME:
           return 'interval-daytime';
-        case IntervalUnit.YEAR_MONTH:
+        case arrow.IntervalUnit.YEAR_MONTH:
           return 'interval-yearmonth';
         default:
           return 'interval-daytime';
       }
-    case IntervalDayTime:
+    case arrow.IntervalDayTime:
       return 'interval-daytime';
-    case IntervalYearMonth:
+    case arrow.IntervalYearMonth:
       return 'interval-yearmonth';
-    case List:
+    case arrow.List:
       const listType = arrowType;
       const listField = listType.valueField;
       return {
         type: 'list',
         children: [serializeArrowField(listField)]
       };
-    case FixedSizeList:
+    case arrow.FixedSizeList:
       return {
         type: 'fixed-size-list',
         listSize: arrowType.listSize,
@@ -159,72 +159,72 @@ export function deserializeArrowType(dataType) {
     switch (dataType.type) {
       case 'list':
         const field = deserializeArrowField(dataType.children[0]);
-        return new List(field);
+        return new arrow.List(field);
       case 'fixed-size-list':
         const child = deserializeArrowField(dataType.children[0]);
-        return new FixedSizeList(dataType.listSize, child);
+        return new arrow.FixedSizeList(dataType.listSize, child);
       case 'struct':
         const children = dataType.children.map(arrowField => deserializeArrowField(arrowField));
-        return new Struct(children);
+        return new arrow.Struct(children);
       default:
         throw new Error('array type not supported');
     }
   }
   switch (dataType) {
     case 'null':
-      return new Null();
+      return new arrow.Null();
     case 'binary':
-      return new Binary();
+      return new arrow.Binary();
     case 'bool':
-      return new Bool();
+      return new arrow.Bool();
     case 'int8':
-      return new Int8();
+      return new arrow.Int8();
     case 'int16':
-      return new Int16();
+      return new arrow.Int16();
     case 'int32':
-      return new Int32();
+      return new arrow.Int32();
     case 'int64':
-      return new Int64();
+      return new arrow.Int64();
     case 'uint8':
-      return new Uint8();
+      return new arrow.Uint8();
     case 'uint16':
-      return new Uint16();
+      return new arrow.Uint16();
     case 'uint32':
-      return new Uint32();
+      return new arrow.Uint32();
     case 'uint64':
-      return new Uint64();
+      return new arrow.Uint64();
     case 'float16':
-      return new Float16();
+      return new arrow.Float16();
     case 'float32':
-      return new Float32();
+      return new arrow.Float32();
     case 'float64':
-      return new Float64();
+      return new arrow.Float64();
     case 'utf8':
-      return new Utf8();
+      return new arrow.Utf8();
     case 'date-day':
-      return new DateDay();
+      return new arrow.DateDay();
     case 'date-millisecond':
-      return new DateMillisecond();
+      return new arrow.DateMillisecond();
     case 'time-second':
-      return new TimeSecond();
+      return new arrow.TimeSecond();
     case 'time-millisecond':
-      return new TimeMillisecond();
+      return new arrow.TimeMillisecond();
     case 'time-microsecond':
-      return new TimeMicrosecond();
+      return new arrow.TimeMicrosecond();
     case 'time-nanosecond':
-      return new TimeNanosecond();
+      return new arrow.TimeNanosecond();
     case 'timestamp-second':
-      return new TimestampSecond();
+      return new arrow.TimestampSecond();
     case 'timestamp-millisecond':
-      return new TimestampMillisecond();
+      return new arrow.TimestampMillisecond();
     case 'timestamp-microsecond':
-      return new TimestampMicrosecond();
+      return new arrow.TimestampMicrosecond();
     case 'timestamp-nanosecond':
-      return new TimestampNanosecond();
+      return new arrow.TimestampNanosecond();
     case 'interval-daytime':
-      return new IntervalDayTime();
+      return new arrow.IntervalDayTime();
     case 'interval-yearmonth':
-      return new IntervalYearMonth();
+      return new arrow.IntervalYearMonth();
     default:
       throw new Error('array type not supported');
   }