@loaders.gl/arrow 4.0.0-beta.1 → 4.0.0-beta.3

package/dist/index.cjs

@@ -0,0 +1,262 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ArrowLoader: () => ArrowLoader2,
+  ArrowWorkerLoader: () => ArrowLoader,
+  ArrowWriter: () => ArrowWriter,
+  VECTOR_TYPES: () => VECTOR_TYPES,
+  getArrowType: () => getArrowType
+});
+module.exports = __toCommonJS(src_exports);
+var import_schema3 = require("@loaders.gl/schema");
+
+// src/arrow-loader.ts
+var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+var ArrowLoader = {
+  name: "Apache Arrow",
+  id: "arrow",
+  module: "arrow",
+  version: VERSION,
+  // worker: true,
+  category: "table",
+  extensions: ["arrow", "feather"],
+  mimeTypes: [
+    "application/vnd.apache.arrow.file",
+    "application/vnd.apache.arrow.stream",
+    "application/octet-stream"
+  ],
+  binary: true,
+  tests: ["ARROW"],
+  options: {
+    arrow: {
+      shape: "columnar-table"
+    }
+  }
+};
+
+// src/lib/parse-arrow-sync.ts
+var import_schema = require("@loaders.gl/schema");
+var import_apache_arrow = require("apache-arrow");
+
+// src/lib/convert-table.ts
+function convertApacheArrowToArrowTable(arrowTable) {
+  return {
+    shape: "arrow-table",
+    data: arrowTable
+  };
+}
+function convertArrowToColumnarTable(table) {
+  const arrowTable = table.data;
+  const columnarTable = {};
+  for (const field of arrowTable.schema.fields) {
+    const arrowColumn = arrowTable.getChild(field.name);
+    const values = arrowColumn == null ? void 0 : arrowColumn.toArray();
+    columnarTable[field.name] = values;
+  }
+  return {
+    shape: "columnar-table",
+    data: columnarTable
+  };
+}
+
+// src/lib/parse-arrow-sync.ts
+function parseArrowSync(arrayBuffer, options) {
+  var _a;
+  const apacheArrowTable = (0, import_apache_arrow.tableFromIPC)([new Uint8Array(arrayBuffer)]);
+  const arrowTable = convertApacheArrowToArrowTable(apacheArrowTable);
+  const shape = ((_a = options == null ? void 0 : options.arrow) == null ? void 0 : _a.shape) || "arrow-table";
+  switch (shape) {
+    case "arrow-table":
+      return arrowTable;
+    case "columnar-table":
+      return convertArrowToColumnarTable(arrowTable);
+    case "object-row-table":
+      const columnarTable = convertArrowToColumnarTable(arrowTable);
+      return (0, import_schema.convertTable)(columnarTable, "object-row-table");
+    default:
+      throw new Error(shape);
+  }
+}
+
+// src/lib/parse-arrow-in-batches.ts
+var import_apache_arrow2 = require("apache-arrow");
+function parseArrowInBatches(asyncIterator) {
+  async function* makeArrowAsyncIterator() {
+    const readers = import_apache_arrow2.RecordBatchReader.readAll(asyncIterator);
+    for await (const reader of readers) {
+      for await (const recordBatch of reader) {
+        const arrowTabledBatch = {
+          shape: "arrow-table",
+          batchType: "data",
+          data: new import_apache_arrow2.Table([recordBatch]),
+          length: recordBatch.data.length
+        };
+        yield arrowTabledBatch;
+      }
+      break;
+    }
+  }
+  return makeArrowAsyncIterator();
+}
+
+// src/lib/arrow-table-batch.ts
+var import_schema2 = require("@loaders.gl/schema");
+var import_apache_arrow3 = require("apache-arrow");
+var ArrowTableBatchAggregator = class extends import_schema2.ColumnarTableBatchAggregator {
+  constructor(schema, options) {
+    super(schema, options);
+    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 import_apache_arrow3.RecordBatch(
+        this.arrowSchema,
+        (0, import_apache_arrow3.makeData)({
+          type: new import_apache_arrow3.Struct(this.arrowSchema.fields),
+          children: arrowVectors.map(({ data }) => data[0])
+        })
+      );
+      return {
+        shape: "arrow-table",
+        batchType: "data",
+        data: new import_apache_arrow3.Table([recordBatch]),
+        length: batch.length
+      };
+    }
+    return null;
+  }
+};
+function getArrowSchema(schema) {
+  const arrowFields = [];
+  for (const key in schema) {
+    const field = schema[key];
+    if (field.type === Float32Array) {
+      const metadata = /* @__PURE__ */ new Map();
+      const arrowField = new import_apache_arrow3.Field(field.name, new import_apache_arrow3.Float32(), field.nullable, metadata);
+      arrowFields.push(arrowField);
+    }
+  }
+  if (arrowFields.length === 0) {
+    throw new Error("No arrow convertible fields");
+  }
+  return new import_apache_arrow3.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 = (0, import_apache_arrow3.makeVector)(vector);
+      arrowVectors.push(arrowVector);
+    }
+  }
+  if (arrowSchema.fields.length !== arrowVectors.length) {
+    throw new Error("Some columns not arrow convertible");
+  }
+  return arrowVectors;
+}
+
+// src/schema/arrow-type-utils.ts
+var import_apache_arrow4 = require("apache-arrow");
+function getArrowType(array) {
+  switch (array.constructor) {
+    case Int8Array:
+      return new import_apache_arrow4.Int8();
+    case Uint8Array:
+      return new import_apache_arrow4.Uint8();
+    case Int16Array:
+      return new import_apache_arrow4.Int16();
+    case Uint16Array:
+      return new import_apache_arrow4.Uint16();
+    case Int32Array:
+      return new import_apache_arrow4.Int32();
+    case Uint32Array:
+      return new import_apache_arrow4.Uint32();
+    case Float32Array:
+      return new import_apache_arrow4.Float32();
+    case Float64Array:
+      return new import_apache_arrow4.Float64();
+    default:
+      throw new Error("array type not supported");
+  }
+}
+
+// src/types.ts
+var VECTOR_TYPES = /* @__PURE__ */ ((VECTOR_TYPES2) => {
+  VECTOR_TYPES2[VECTOR_TYPES2["FLOAT"] = 0] = "FLOAT";
+  VECTOR_TYPES2[VECTOR_TYPES2["DATE"] = 1] = "DATE";
+  return VECTOR_TYPES2;
+})(VECTOR_TYPES || {});
+
+// src/lib/encode-arrow.ts
+var import_apache_arrow5 = require("apache-arrow");
+function encodeArrowSync(data) {
+  const vectors = {};
+  for (const arrayData of data) {
+    const arrayVector = createVector(arrayData.array, arrayData.type);
+    vectors[arrayData.name] = arrayVector;
+  }
+  const table = new import_apache_arrow5.Table(vectors);
+  const arrowBuffer = (0, import_apache_arrow5.tableToIPC)(table);
+  return arrowBuffer;
+}
+function createVector(array, type) {
+  switch (type) {
+    case 1 /* DATE */:
+      return (0, import_apache_arrow5.vectorFromArray)(array);
+    case 0 /* FLOAT */:
+    default:
+      return (0, import_apache_arrow5.vectorFromArray)(array);
+  }
+}
+
+// src/arrow-writer.ts
+var VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+var ArrowWriter = {
+  name: "Apache Arrow",
+  id: "arrow",
+  module: "arrow",
+  version: VERSION2,
+  extensions: ["arrow", "feather"],
+  mimeTypes: [
+    "application/vnd.apache.arrow.file",
+    "application/vnd.apache.arrow.stream",
+    "application/octet-stream"
+  ],
+  encodeSync(data, options) {
+    return encodeArrowSync(data);
+  },
+  binary: true,
+  options: {}
+};
+
+// src/index.ts
+import_schema3.TableBatchBuilder.ArrowBatch = ArrowTableBatchAggregator;
+var ArrowLoader2 = {
+  ...ArrowLoader,
+  parse: async (arraybuffer, options) => parseArrowSync(arraybuffer, options),
+  parseSync: parseArrowSync,
+  parseInBatches: parseArrowInBatches
+};

package/dist/index.d.ts

@@ -3,6 +3,7 @@ import type { ArrowLoaderOptions } from './arrow-loader';
 import type { ArrowTableBatch, ColumnarTable, ObjectRowTable } from '@loaders.gl/schema';
 import type { ArrowTable } from './lib/arrow-table';
 import { ArrowLoader as ArrowWorkerLoader } from './arrow-loader';
+export { getArrowType } from './schema/arrow-type-utils';
 export type { ArrowTable, ArrowTableBatch } from './lib/arrow-table';
 export { VECTOR_TYPES } from './types';
 export { ArrowWriter } from './arrow-writer';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAC/D,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,gBAAgB,CAAC;AACvD,OAAO,KAAK,EAAC,eAAe,EAAE,aAAa,EAAE,cAAc,EAAC,MAAM,oBAAoB,CAAC;AACvF,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,mBAAmB,CAAC;AAGlD,OAAO,EAAC,WAAW,IAAI,iBAAiB,EAAC,MAAM,gBAAgB,CAAC;AAUhE,YAAY,EAAC,UAAU,EAAE,eAAe,EAAC,MAAM,mBAAmB,CAAC;AACnE,OAAO,EAAC,YAAY,EAAC,MAAM,SAAS,CAAC;AAIrC,OAAO,EAAC,WAAW,EAAC,MAAM,gBAAgB,CAAC;AAI3C,YAAY,EAAC,kBAAkB,EAAC,CAAC;AACjC,OAAO,EAAC,iBAAiB,EAAC,CAAC;AAE3B,2BAA2B;AAC3B,eAAO,MAAM,WAAW,EAAE,gBAAgB,CACxC,UAAU,GAAG,aAAa,GAAG,cAAc,EAC3C,eAAe,EACf,kBAAkB,CAOnB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAC/D,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,gBAAgB,CAAC;AACvD,OAAO,KAAK,EAAC,eAAe,EAAE,aAAa,EAAE,cAAc,EAAC,MAAM,oBAAoB,CAAC;AACvF,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,mBAAmB,CAAC;AAGlD,OAAO,EAAC,WAAW,IAAI,iBAAiB,EAAC,MAAM,gBAAgB,CAAC;AAQhE,OAAO,EAAC,YAAY,EAAC,MAAM,2BAA2B,CAAC;AAMvD,YAAY,EAAC,UAAU,EAAE,eAAe,EAAC,MAAM,mBAAmB,CAAC;AACnE,OAAO,EAAC,YAAY,EAAC,MAAM,SAAS,CAAC;AAIrC,OAAO,EAAC,WAAW,EAAC,MAAM,gBAAgB,CAAC;AAI3C,YAAY,EAAC,kBAAkB,EAAC,CAAC;AACjC,OAAO,EAAC,iBAAiB,EAAC,CAAC;AAE3B,2BAA2B;AAC3B,eAAO,MAAM,WAAW,EAAE,gBAAgB,CACxC,UAAU,GAAG,aAAa,GAAG,cAAc,EAC3C,eAAe,EACf,kBAAkB,CAOnB,CAAC"}

package/dist/index.js

@@ -0,0 +1,17 @@
+import { TableBatchBuilder } from '@loaders.gl/schema';
+import { ArrowLoader as ArrowWorkerLoader } from "./arrow-loader.js";
+import parseSync from "./lib/parse-arrow-sync.js";
+import { parseArrowInBatches } from "./lib/parse-arrow-in-batches.js";
+import { ArrowTableBatchAggregator } from "./lib/arrow-table-batch.js";
+export { getArrowType } from "./schema/arrow-type-utils.js";
+TableBatchBuilder.ArrowBatch = ArrowTableBatchAggregator;
+export { VECTOR_TYPES } from "./types.js";
+export { ArrowWriter } from "./arrow-writer.js";
+export { ArrowWorkerLoader };
+export const ArrowLoader = {
+  ...ArrowWorkerLoader,
+  parse: async (arraybuffer, options) => parseSync(arraybuffer, options),
+  parseSync,
+  parseInBatches: parseArrowInBatches
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["TableBatchBuilder","ArrowLoader","ArrowWorkerLoader","parseSync","parseArrowInBatches","ArrowTableBatchAggregator","getArrowType","ArrowBatch","VECTOR_TYPES","ArrowWriter","parse","arraybuffer","options","parseInBatches"],"sources":["../src/index.ts"],"sourcesContent":["// loaders.gl, MIT\n\nimport type {LoaderWithParser} from '@loaders.gl/loader-utils';\nimport type {ArrowLoaderOptions} from './arrow-loader';\nimport type {ArrowTableBatch, ColumnarTable, ObjectRowTable} from '@loaders.gl/schema';\nimport type {ArrowTable} from './lib/arrow-table';\n\nimport {TableBatchBuilder} from '@loaders.gl/schema';\nimport {ArrowLoader as ArrowWorkerLoader} from './arrow-loader';\nimport parseSync from './lib/parse-arrow-sync';\nimport {parseArrowInBatches} from './lib/parse-arrow-in-batches';\n\nimport {ArrowTableBatchAggregator} from './lib/arrow-table-batch';\n\n// SCHEMA\n\nexport {getArrowType} from './schema/arrow-type-utils';\n\n// Make the ArrowBatch type available\nTableBatchBuilder.ArrowBatch = ArrowTableBatchAggregator;\n\n// Types\nexport type {ArrowTable, ArrowTableBatch} from './lib/arrow-table';\nexport {VECTOR_TYPES} from './types';\n\n// Arrow writer\n\nexport {ArrowWriter} from './arrow-writer';\n\n// Arrow loader\n\nexport type {ArrowLoaderOptions};\nexport {ArrowWorkerLoader};\n\n/** ArrowJS table loader */\nexport const ArrowLoader: LoaderWithParser<\n  ArrowTable | ColumnarTable | ObjectRowTable,\n  ArrowTableBatch,\n  ArrowLoaderOptions\n> = {\n  ...ArrowWorkerLoader,\n  parse: async (arraybuffer: ArrayBuffer, options?: ArrowLoaderOptions) =>\n    parseSync(arraybuffer, options),\n  parseSync,\n  parseInBatches: parseArrowInBatches\n};\n"],"mappings":"AAOA,SAAQA,iBAAiB,QAAO,oBAAoB;AAAC,SAC7CC,WAAW,IAAIC,iBAAiB;AAAA,OACjCC,SAAS;AAAA,SACRC,mBAAmB;AAAA,SAEnBC,yBAAyB;AAAA,SAIzBC,YAAY;AAGpBN,iBAAiB,CAACO,UAAU,GAAGF,yBAAyB;AAAC,SAIjDG,YAAY;AAAA,SAIZC,WAAW;AAKnB,SAAQP,iBAAiB;AAGzB,OAAO,MAAMD,WAIZ,GAAG;EACF,GAAGC,iBAAiB;EACpBQ,KAAK,EAAE,MAAAA,CAAOC,WAAwB,EAAEC,OAA4B,KAClET,SAAS,CAACQ,WAAW,EAAEC,OAAO,CAAC;EACjCT,SAAS;EACTU,cAAc,EAAET;AAClB,CAAC"}

package/dist/{esm/lib → lib}/arrow-table-batch.js

@@ -1,10 +1,9 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
 import { ColumnarTableBatchAggregator } from '@loaders.gl/schema';
 import { Table as ApacheArrowTable, Schema, Field, RecordBatch, Struct, makeVector, makeData, Float32 } from 'apache-arrow';
 export class ArrowTableBatchAggregator extends ColumnarTableBatchAggregator {
   constructor(schema, options) {
     super(schema, options);
-    _defineProperty(this, "arrowSchema", void 0);
+    this.arrowSchema = void 0;
     this.arrowSchema = null;
   }
   getBatch() {

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

@@ -0,0 +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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"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"arrow-table.js","names":[],"sources":["../../src/lib/arrow-table.ts"],"sourcesContent":["// loaders.gl, MIT license\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":""}

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

@@ -0,0 +1 @@
+{"version":3,"file":"convert-table.js","names":["convertApacheArrowToArrowTable","arrowTable","shape","data","convertArrowToColumnarTable","table","columnarTable","field","schema","fields","arrowColumn","getChild","name","values","toArray","convertColumnarToRowFormatTable","tableKeys","Object","keys","tableRowsCount","length","rowFormatTable","index","tableItem","keyIndex","fieldName","push"],"sources":["../../src/lib/convert-table.ts"],"sourcesContent":["// loaders.gl, MIT license\nimport type {ColumnarTable, ObjectRowTable} from '@loaders.gl/schema';\nimport type {Table as ApacheArrowTable} from 'apache-arrow';\nimport type {ArrowTable} from './arrow-table';\n\n/**\n * Wrap an apache arrow table in a loaders.gl table wrapper.\n * From this additional conversions are available.\n * @param arrowTable\n * @returns\n */\nexport function convertApacheArrowToArrowTable(arrowTable: ApacheArrowTable): ArrowTable {\n  return {\n    shape: 'arrow-table',\n    data: arrowTable\n  };\n}\n\n/**\n * Convert an Apache Arrow table to a ColumnarTable\n * @note Currently does not convert schema\n */\nexport function convertArrowToColumnarTable(table: ArrowTable): ColumnarTable {\n  // TODO - avoid calling `getColumn` on columns we are not interested in?\n  // Add options object?\n\n  const arrowTable = table.data;\n  const columnarTable = {};\n\n  for (const field of arrowTable.schema.fields) {\n    // This (is intended to) coalesce all record batches into a single typed array\n    const arrowColumn = arrowTable.getChild(field.name);\n    const values = arrowColumn?.toArray();\n    columnarTable[field.name] = values;\n  }\n\n  return {\n    shape: 'columnar-table',\n    data: columnarTable\n  };\n}\n\n/**\n *\n * @note - should be part of schema module\n */\nexport function convertColumnarToRowFormatTable(columnarTable: ColumnarTable): ObjectRowTable {\n  const tableKeys = Object.keys(columnarTable);\n  const tableRowsCount = columnarTable[tableKeys[0]].length;\n\n  const rowFormatTable: {}[] = [];\n\n  for (let index = 0; index < tableRowsCount; index++) {\n    const tableItem = {};\n    for (let keyIndex = 0; keyIndex < tableKeys.length; keyIndex++) {\n      const fieldName = tableKeys[keyIndex];\n      tableItem[fieldName] = columnarTable[fieldName][index];\n    }\n    rowFormatTable.push(tableItem);\n  }\n\n  return {\n    shape: 'object-row-table',\n    data: rowFormatTable\n  };\n}\n"],"mappings":"AAWA,OAAO,SAASA,8BAA8BA,CAACC,UAA4B,EAAc;EACvF,OAAO;IACLC,KAAK,EAAE,aAAa;IACpBC,IAAI,EAAEF;EACR,CAAC;AACH;AAMA,OAAO,SAASG,2BAA2BA,CAACC,KAAiB,EAAiB;EAI5E,MAAMJ,UAAU,GAAGI,KAAK,CAACF,IAAI;EAC7B,MAAMG,aAAa,GAAG,CAAC,CAAC;EAExB,KAAK,MAAMC,KAAK,IAAIN,UAAU,CAACO,MAAM,CAACC,MAAM,EAAE;IAE5C,MAAMC,WAAW,GAAGT,UAAU,CAACU,QAAQ,CAACJ,KAAK,CAACK,IAAI,CAAC;IACnD,MAAMC,MAAM,GAAGH,WAAW,aAAXA,WAAW,uBAAXA,WAAW,CAAEI,OAAO,CAAC,CAAC;IACrCR,aAAa,CAACC,KAAK,CAACK,IAAI,CAAC,GAAGC,MAAM;EACpC;EAEA,OAAO;IACLX,KAAK,EAAE,gBAAgB;IACvBC,IAAI,EAAEG;EACR,CAAC;AACH;AAMA,OAAO,SAASS,+BAA+BA,CAACT,aAA4B,EAAkB;EAC5F,MAAMU,SAAS,GAAGC,MAAM,CAACC,IAAI,CAACZ,aAAa,CAAC;EAC5C,MAAMa,cAAc,GAAGb,aAAa,CAACU,SAAS,CAAC,CAAC,CAAC,CAAC,CAACI,MAAM;EAEzD,MAAMC,cAAoB,GAAG,EAAE;EAE/B,KAAK,IAAIC,KAAK,GAAG,CAAC,EAAEA,KAAK,GAAGH,cAAc,EAAEG,KAAK,EAAE,EAAE;IACnD,MAAMC,SAAS,GAAG,CAAC,CAAC;IACpB,KAAK,IAAIC,QAAQ,GAAG,CAAC,EAAEA,QAAQ,GAAGR,SAAS,CAACI,MAAM,EAAEI,QAAQ,EAAE,EAAE;MAC9D,MAAMC,SAAS,GAAGT,SAAS,CAACQ,QAAQ,CAAC;MACrCD,SAAS,CAACE,SAAS,CAAC,GAAGnB,aAAa,CAACmB,SAAS,CAAC,CAACH,KAAK,CAAC;IACxD;IACAD,cAAc,CAACK,IAAI,CAACH,SAAS,CAAC;EAChC;EAEA,OAAO;IACLrB,KAAK,EAAE,kBAAkB;IACzBC,IAAI,EAAEkB;EACR,CAAC;AACH"}

package/dist/{esm/lib → lib}/encode-arrow.js

@@ -1,5 +1,5 @@
 import { Table, tableToIPC, vectorFromArray } from 'apache-arrow';
-import { VECTOR_TYPES } from '../types';
+import { VECTOR_TYPES } from "../types.js";
 export function encodeArrowSync(data) {
   const vectors = {};
   for (const arrayData of data) {

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

@@ -0,0 +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"}

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

@@ -0,0 +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"}

package/dist/{esm/lib → lib}/parse-arrow-sync.js

@@ -1,6 +1,6 @@
 import { convertTable } from '@loaders.gl/schema';
 import { tableFromIPC } from 'apache-arrow';
-import { convertApacheArrowToArrowTable, convertArrowToColumnarTable } from './convert-table';
+import { convertApacheArrowToArrowTable, convertArrowToColumnarTable } from "./convert-table.js";
 export default function parseArrowSync(arrayBuffer, options) {
   var _options$arrow;
   const apacheArrowTable = tableFromIPC([new Uint8Array(arrayBuffer)]);

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

@@ -0,0 +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 {convertApacheArrowToArrowTable, convertArrowToColumnarTable} from './convert-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,SAElCC,8BAA8B,EAAEC,2BAA2B;AAGnE,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"}

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

@@ -0,0 +1,4 @@
+import type { TypedArray } from '@loaders.gl/schema';
+import { DataType } from 'apache-arrow';
+export declare function getArrowType(array: TypedArray): DataType;
+//# sourceMappingURL=arrow-type-utils.d.ts.map

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

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

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

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

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

@@ -0,0 +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\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\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":"AAGA,SAEEA,OAAO,EACPC,OAAO,EACPC,KAAK,EACLC,KAAK,EACLC,IAAI,EACJC,MAAM,EACNC,MAAM,EACNC,KAAK,QASA,cAAc;AAGrB,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"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"convert-schema-arrow.d.ts","sourceRoot":"","sources":["../../src/schema/convert-schema-arrow.ts"],"names":[],"mappings":"AAEA,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,EAkC1B,MAAM,cAAc,CAAC;AAEtB,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,WAAW,GAAG,MAAM,CAKrE;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,CAKlE;AAED,wBAAgB,sBAAsB,CAAC,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,cAAc,CAEzF;AAED,wBAAgB,wBAAwB,CAAC,QAAQ,CAAC,EAAE,cAAc,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAEvF;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,GAAG,KAAK,CAO5D;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,KAAK,GAAG,UAAU,CAO9D;AAED,+EAA+E;AAE/E,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,aAAa,GAAG,QAAQ,CAqErE;AAED,+EAA+E;AAE/E,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,GAAG,aAAa,CA0EtE"}

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

@@ -0,0 +1,158 @@
+import { Field as ArrowField, Schema as ArrowSchema, Null, Binary, Bool, Int8, Int16, Int32, Int64, Uint8, Uint16, Uint32, Uint64, Float16, Float32, Float64, Utf8, DateDay, DateMillisecond, TimeMillisecond, TimeSecond, TimestampSecond, TimestampMillisecond, TimestampMicrosecond, TimestampNanosecond, IntervalDayTime, IntervalYearMonth, FixedSizeList, Struct } from 'apache-arrow';
+export function serializeArrowSchema(arrowSchema) {
+  return {
+    fields: arrowSchema.fields.map(arrowField => serializeArrowField(arrowField)),
+    metadata: serializeArrowMetadata(arrowSchema.metadata)
+  };
+}
+export function deserializeArrowSchema(schema) {
+  return new ArrowSchema(schema.fields.map(field => deserializeArrowField(field)), deserializeArrowMetadata(schema.metadata));
+}
+export function serializeArrowMetadata(arrowMetadata) {
+  return Object.fromEntries(arrowMetadata);
+}
+export function deserializeArrowMetadata(metadata) {
+  return metadata ? new Map(Object.entries(metadata)) : new Map();
+}
+export function serializeArrowField(field) {
+  return {
+    name: field.name,
+    type: serializeArrowType(field.type),
+    nullable: field.nullable,
+    metadata: serializeArrowMetadata(field.metadata)
+  };
+}
+export function deserializeArrowField(field) {
+  return new ArrowField(field.name, deserializeArrowType(field.type), field.nullable, deserializeArrowMetadata(field.metadata));
+}
+export function serializeArrowType(arrowType) {
+  switch (arrowType.constructor) {
+    case Null:
+      return 'null';
+    case Binary:
+      return 'binary';
+    case Bool:
+      return 'bool';
+    case Int8:
+      return 'int8';
+    case Int16:
+      return 'int16';
+    case Int32:
+      return 'int32';
+    case Int64:
+      return 'int64';
+    case Uint8:
+      return 'uint8';
+    case Uint16:
+      return 'uint16';
+    case Uint32:
+      return 'uint32';
+    case Uint64:
+      return 'uint64';
+    case Float16:
+      return 'float16';
+    case Float32:
+      return 'float32';
+    case Float64:
+      return 'float64';
+    case Utf8:
+      return 'utf8';
+    case DateDay:
+      return 'date-day';
+    case DateMillisecond:
+      return 'date-millisecond';
+    case TimeMillisecond:
+      return 'time-millisecond';
+    case TimeSecond:
+      return 'time-second';
+    case TimestampSecond:
+      return 'timestamp-second';
+    case TimestampMillisecond:
+      return 'timestamp-millisecond';
+    case TimestampMicrosecond:
+      return 'timestamp-microsecond';
+    case TimestampNanosecond:
+      return 'timestamp-nanosecond';
+    case IntervalDayTime:
+      return 'interval-daytime';
+    case IntervalYearMonth:
+      return 'interval-yearmonth';
+    case FixedSizeList:
+      return {
+        type: 'fixed-size-list',
+        listSize: arrowType.listSize,
+        children: [serializeArrowField(arrowType.children[0])]
+      };
+    default:
+      throw new Error('array type not supported');
+  }
+}
+export function deserializeArrowType(dataType) {
+  if (typeof dataType === 'object') {
+    switch (dataType.type) {
+      case 'fixed-size-list':
+        const child = deserializeArrowField(dataType.children[0]);
+        return new FixedSizeList(dataType.listSize, child);
+      case 'struct':
+        const children = dataType.children.map(arrowField => deserializeArrowField(arrowField));
+        return new Struct(children);
+      default:
+        throw new Error('array type not supported');
+    }
+  }
+  switch (dataType) {
+    case 'null':
+      return new Null();
+    case 'binary':
+      return new Binary();
+    case 'bool':
+      return new Bool();
+    case 'int8':
+      return new Int8();
+    case 'int16':
+      return new Int16();
+    case 'int32':
+      return new Int32();
+    case 'int64':
+      return new Int64();
+    case 'uint8':
+      return new Uint8();
+    case 'uint16':
+      return new Uint16();
+    case 'uint32':
+      return new Uint32();
+    case 'uint64':
+      return new Uint64();
+    case 'float16':
+      return new Float16();
+    case 'float32':
+      return new Float32();
+    case 'float64':
+      return new Float64();
+    case 'utf8':
+      return new Utf8();
+    case 'date-day':
+      return new DateDay();
+    case 'date-millisecond':
+      return new DateMillisecond();
+    case 'time-millisecond':
+      return new TimeMillisecond();
+    case 'time-second':
+      return new TimeSecond();
+    case 'timestamp-second':
+      return new TimestampSecond();
+    case 'timestamp-millisecond':
+      return new TimestampMillisecond();
+    case 'timestamp-microsecond':
+      return new TimestampMicrosecond();
+    case 'timestamp-nanosecond':
+      return new TimestampNanosecond();
+    case 'interval-daytime':
+      return new IntervalDayTime();
+    case 'interval-yearmonth':
+      return new IntervalYearMonth();
+    default:
+      throw new Error('array type not supported');
+  }
+}
+//# sourceMappingURL=convert-schema-arrow.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"convert-schema-arrow.js","names":["Field","ArrowField","Schema","ArrowSchema","Null","Binary","Bool","Int8","Int16","Int32","Int64","Uint8","Uint16","Uint32","Uint64","Float16","Float32","Float64","Utf8","DateDay","DateMillisecond","TimeMillisecond","TimeSecond","TimestampSecond","TimestampMillisecond","TimestampMicrosecond","TimestampNanosecond","IntervalDayTime","IntervalYearMonth","FixedSizeList","Struct","serializeArrowSchema","arrowSchema","fields","map","arrowField","serializeArrowField","metadata","serializeArrowMetadata","deserializeArrowSchema","schema","field","deserializeArrowField","deserializeArrowMetadata","arrowMetadata","Object","fromEntries","Map","entries","name","type","serializeArrowType","nullable","deserializeArrowType","arrowType","constructor","listSize","children","Error","dataType","child"],"sources":["../../src/schema/convert-schema-arrow.ts"],"sourcesContent":["// loaders.gl, MIT license\n\nimport type {DataType, Field, Schema, SchemaMetadata} from '@loaders.gl/schema';\nimport {\n  Field as ArrowField,\n  Schema as ArrowSchema,\n  DataType as ArrowDataType,\n  Null,\n  Binary,\n  Bool,\n  // Int,\n  Int8,\n  Int16,\n  Int32,\n  Int64,\n  Uint8,\n  Uint16,\n  Uint32,\n  Uint64,\n  // Float,\n  Float16,\n  Float32,\n  Float64,\n  Utf8,\n  // Date,\n  DateDay,\n  DateMillisecond,\n  // Time,\n  TimeMillisecond,\n  TimeSecond,\n  // Timestamp,\n  TimestampSecond,\n  TimestampMillisecond,\n  TimestampMicrosecond,\n  TimestampNanosecond,\n  // Interval,\n  IntervalDayTime,\n  IntervalYearMonth,\n  FixedSizeList,\n  Struct\n} from 'apache-arrow';\n\nexport function serializeArrowSchema(arrowSchema: ArrowSchema): Schema {\n  return {\n    fields: arrowSchema.fields.map((arrowField) => serializeArrowField(arrowField)),\n    metadata: serializeArrowMetadata(arrowSchema.metadata)\n  };\n}\n\nexport function deserializeArrowSchema(schema: Schema): ArrowSchema {\n  return new ArrowSchema(\n    schema.fields.map((field) => deserializeArrowField(field)),\n    deserializeArrowMetadata(schema.metadata)\n  );\n}\n\nexport function serializeArrowMetadata(arrowMetadata: Map<string, string>): SchemaMetadata {\n  return Object.fromEntries(arrowMetadata);\n}\n\nexport function deserializeArrowMetadata(metadata?: SchemaMetadata): Map<string, string> {\n  return metadata ? new Map(Object.entries(metadata)) : new Map<string, string>();\n}\n\nexport function serializeArrowField(field: ArrowField): Field {\n  return {\n    name: field.name,\n    type: serializeArrowType(field.type),\n    nullable: field.nullable,\n    metadata: serializeArrowMetadata(field.metadata)\n  };\n}\n\nexport function deserializeArrowField(field: Field): ArrowField {\n  return new ArrowField(\n    field.name,\n    deserializeArrowType(field.type),\n    field.nullable,\n    deserializeArrowMetadata(field.metadata)\n  );\n}\n\n/** Converts a serializable loaders.gl data type to hydrated arrow data type */\n// eslint-disable-next-line complexity\nexport function serializeArrowType(arrowType: ArrowDataType): DataType {\n  switch (arrowType.constructor) {\n    case Null:\n      return 'null';\n    case Binary:\n      return 'binary';\n    case Bool:\n      return 'bool';\n    // case Int: return 'int';\n    case Int8:\n      return 'int8';\n    case Int16:\n      return 'int16';\n    case Int32:\n      return 'int32';\n    case Int64:\n      return 'int64';\n    case Uint8:\n      return 'uint8';\n    case Uint16:\n      return 'uint16';\n    case Uint32:\n      return 'uint32';\n    case Uint64:\n      return 'uint64';\n    // case Float: return 'float';\n    case Float16:\n      return 'float16';\n    case Float32:\n      return 'float32';\n    case Float64:\n      return 'float64';\n    case Utf8:\n      return 'utf8';\n    // case Date: return 'date';\n    case DateDay:\n      return 'date-day';\n    case DateMillisecond:\n      return 'date-millisecond';\n    // case Time: return 'time';\n    case TimeMillisecond:\n      return 'time-millisecond';\n    case TimeSecond:\n      return 'time-second';\n    // case Timestamp: return 'timestamp';\n    case TimestampSecond:\n      return 'timestamp-second';\n    case TimestampMillisecond:\n      return 'timestamp-millisecond';\n    case TimestampMicrosecond:\n      return 'timestamp-microsecond';\n    case TimestampNanosecond:\n      return 'timestamp-nanosecond';\n    // case Interval: return 'interval';\n    case IntervalDayTime:\n      return 'interval-daytime';\n    case IntervalYearMonth:\n      return 'interval-yearmonth';\n    case FixedSizeList:\n      return {\n        type: 'fixed-size-list',\n        listSize: (arrowType as FixedSizeList).listSize,\n        children: [serializeArrowField((arrowType as FixedSizeList).children[0])]\n      };\n    // case Struct:\n    //   return {type: 'struct', children: (arrowType as Struct).children};\n    default:\n      throw new Error('array type not supported');\n  }\n}\n\n/** Converts a serializable loaders.gl data type to hydrated arrow data type */\n// eslint-disable-next-line complexity\nexport function deserializeArrowType(dataType: DataType): ArrowDataType {\n  if (typeof dataType === 'object') {\n    switch (dataType.type) {\n      case 'fixed-size-list':\n        const child = deserializeArrowField(dataType.children[0]);\n        return new FixedSizeList(dataType.listSize, child);\n      case 'struct':\n        const children = dataType.children.map((arrowField) => deserializeArrowField(arrowField));\n        return new Struct(children);\n      default:\n        throw new Error('array type not supported');\n    }\n  }\n\n  switch (dataType) {\n    case 'null':\n      return new Null();\n    case 'binary':\n      return new Binary();\n    case 'bool':\n      return new Bool();\n    // case 'int': return new Int();\n    case 'int8':\n      return new Int8();\n    case 'int16':\n      return new Int16();\n    case 'int32':\n      return new Int32();\n    case 'int64':\n      return new Int64();\n    case 'uint8':\n      return new Uint8();\n    case 'uint16':\n      return new Uint16();\n    case 'uint32':\n      return new Uint32();\n    case 'uint64':\n      return new Uint64();\n    // case 'float': return new Float();\n    case 'float16':\n      return new Float16();\n    case 'float32':\n      return new Float32();\n    case 'float64':\n      return new Float64();\n    case 'utf8':\n      return new Utf8();\n    // case 'date': return new Date();\n    case 'date-day':\n      return new DateDay();\n    case 'date-millisecond':\n      return new DateMillisecond();\n    // case 'time': return new Time();\n    case 'time-millisecond':\n      return new TimeMillisecond();\n    case 'time-second':\n      return new TimeSecond();\n    // case 'timestamp': return new Timestamp();\n    case 'timestamp-second':\n      return new TimestampSecond();\n    case 'timestamp-millisecond':\n      return new TimestampMillisecond();\n    case 'timestamp-microsecond':\n      return new TimestampMicrosecond();\n    case 'timestamp-nanosecond':\n      return new TimestampNanosecond();\n    // case 'interval': return new Interval();\n    case 'interval-daytime':\n      return new IntervalDayTime();\n    case 'interval-yearmonth':\n      return new IntervalYearMonth();\n    default:\n      throw new Error('array type not supported');\n  }\n}\n"],"mappings":"AAGA,SACEA,KAAK,IAAIC,UAAU,EACnBC,MAAM,IAAIC,WAAW,EAErBC,IAAI,EACJC,MAAM,EACNC,IAAI,EAEJC,IAAI,EACJC,KAAK,EACLC,KAAK,EACLC,KAAK,EACLC,KAAK,EACLC,MAAM,EACNC,MAAM,EACNC,MAAM,EAENC,OAAO,EACPC,OAAO,EACPC,OAAO,EACPC,IAAI,EAEJC,OAAO,EACPC,eAAe,EAEfC,eAAe,EACfC,UAAU,EAEVC,eAAe,EACfC,oBAAoB,EACpBC,oBAAoB,EACpBC,mBAAmB,EAEnBC,eAAe,EACfC,iBAAiB,EACjBC,aAAa,EACbC,MAAM,QACD,cAAc;AAErB,OAAO,SAASC,oBAAoBA,CAACC,WAAwB,EAAU;EACrE,OAAO;IACLC,MAAM,EAAED,WAAW,CAACC,MAAM,CAACC,GAAG,CAAEC,UAAU,IAAKC,mBAAmB,CAACD,UAAU,CAAC,CAAC;IAC/EE,QAAQ,EAAEC,sBAAsB,CAACN,WAAW,CAACK,QAAQ;EACvD,CAAC;AACH;AAEA,OAAO,SAASE,sBAAsBA,CAACC,MAAc,EAAe;EAClE,OAAO,IAAIrC,WAAW,CACpBqC,MAAM,CAACP,MAAM,CAACC,GAAG,CAAEO,KAAK,IAAKC,qBAAqB,CAACD,KAAK,CAAC,CAAC,EAC1DE,wBAAwB,CAACH,MAAM,CAACH,QAAQ,CAC1C,CAAC;AACH;AAEA,OAAO,SAASC,sBAAsBA,CAACM,aAAkC,EAAkB;EACzF,OAAOC,MAAM,CAACC,WAAW,CAACF,aAAa,CAAC;AAC1C;AAEA,OAAO,SAASD,wBAAwBA,CAACN,QAAyB,EAAuB;EACvF,OAAOA,QAAQ,GAAG,IAAIU,GAAG,CAACF,MAAM,CAACG,OAAO,CAACX,QAAQ,CAAC,CAAC,GAAG,IAAIU,GAAG,CAAiB,CAAC;AACjF;AAEA,OAAO,SAASX,mBAAmBA,CAACK,KAAiB,EAAS;EAC5D,OAAO;IACLQ,IAAI,EAAER,KAAK,CAACQ,IAAI;IAChBC,IAAI,EAAEC,kBAAkB,CAACV,KAAK,CAACS,IAAI,CAAC;IACpCE,QAAQ,EAAEX,KAAK,CAACW,QAAQ;IACxBf,QAAQ,EAAEC,sBAAsB,CAACG,KAAK,CAACJ,QAAQ;EACjD,CAAC;AACH;AAEA,OAAO,SAASK,qBAAqBA,CAACD,KAAY,EAAc;EAC9D,OAAO,IAAIxC,UAAU,CACnBwC,KAAK,CAACQ,IAAI,EACVI,oBAAoB,CAACZ,KAAK,CAACS,IAAI,CAAC,EAChCT,KAAK,CAACW,QAAQ,EACdT,wBAAwB,CAACF,KAAK,CAACJ,QAAQ,CACzC,CAAC;AACH;AAIA,OAAO,SAASc,kBAAkBA,CAACG,SAAwB,EAAY;EACrE,QAAQA,SAAS,CAACC,WAAW;IAC3B,KAAKnD,IAAI;MACP,OAAO,MAAM;IACf,KAAKC,MAAM;MACT,OAAO,QAAQ;IACjB,KAAKC,IAAI;MACP,OAAO,MAAM;IAEf,KAAKC,IAAI;MACP,OAAO,MAAM;IACf,KAAKC,KAAK;MACR,OAAO,OAAO;IAChB,KAAKC,KAAK;MACR,OAAO,OAAO;IAChB,KAAKC,KAAK;MACR,OAAO,OAAO;IAChB,KAAKC,KAAK;MACR,OAAO,OAAO;IAChB,KAAKC,MAAM;MACT,OAAO,QAAQ;IACjB,KAAKC,MAAM;MACT,OAAO,QAAQ;IACjB,KAAKC,MAAM;MACT,OAAO,QAAQ;IAEjB,KAAKC,OAAO;MACV,OAAO,SAAS;IAClB,KAAKC,OAAO;MACV,OAAO,SAAS;IAClB,KAAKC,OAAO;MACV,OAAO,SAAS;IAClB,KAAKC,IAAI;MACP,OAAO,MAAM;IAEf,KAAKC,OAAO;MACV,OAAO,UAAU;IACnB,KAAKC,eAAe;MAClB,OAAO,kBAAkB;IAE3B,KAAKC,eAAe;MAClB,OAAO,kBAAkB;IAC3B,KAAKC,UAAU;MACb,OAAO,aAAa;IAEtB,KAAKC,eAAe;MAClB,OAAO,kBAAkB;IAC3B,KAAKC,oBAAoB;MACvB,OAAO,uBAAuB;IAChC,KAAKC,oBAAoB;MACvB,OAAO,uBAAuB;IAChC,KAAKC,mBAAmB;MACtB,OAAO,sBAAsB;IAE/B,KAAKC,eAAe;MAClB,OAAO,kBAAkB;IAC3B,KAAKC,iBAAiB;MACpB,OAAO,oBAAoB;IAC7B,KAAKC,aAAa;MAChB,OAAO;QACLqB,IAAI,EAAE,iBAAiB;QACvBM,QAAQ,EAAGF,SAAS,CAAmBE,QAAQ;QAC/CC,QAAQ,EAAE,CAACrB,mBAAmB,CAAEkB,SAAS,CAAmBG,QAAQ,CAAC,CAAC,CAAC,CAAC;MAC1E,CAAC;IAGH;MACE,MAAM,IAAIC,KAAK,CAAC,0BAA0B,CAAC;EAC/C;AACF;AAIA,OAAO,SAASL,oBAAoBA,CAACM,QAAkB,EAAiB;EACtE,IAAI,OAAOA,QAAQ,KAAK,QAAQ,EAAE;IAChC,QAAQA,QAAQ,CAACT,IAAI;MACnB,KAAK,iBAAiB;QACpB,MAAMU,KAAK,GAAGlB,qBAAqB,CAACiB,QAAQ,CAACF,QAAQ,CAAC,CAAC,CAAC,CAAC;QACzD,OAAO,IAAI5B,aAAa,CAAC8B,QAAQ,CAACH,QAAQ,EAAEI,KAAK,CAAC;MACpD,KAAK,QAAQ;QACX,MAAMH,QAAQ,GAAGE,QAAQ,CAACF,QAAQ,CAACvB,GAAG,CAAEC,UAAU,IAAKO,qBAAqB,CAACP,UAAU,CAAC,CAAC;QACzF,OAAO,IAAIL,MAAM,CAAC2B,QAAQ,CAAC;MAC7B;QACE,MAAM,IAAIC,KAAK,CAAC,0BAA0B,CAAC;IAC/C;EACF;EAEA,QAAQC,QAAQ;IACd,KAAK,MAAM;MACT,OAAO,IAAIvD,IAAI,CAAC,CAAC;IACnB,KAAK,QAAQ;MACX,OAAO,IAAIC,MAAM,CAAC,CAAC;IACrB,KAAK,MAAM;MACT,OAAO,IAAIC,IAAI,CAAC,CAAC;IAEnB,KAAK,MAAM;MACT,OAAO,IAAIC,IAAI,CAAC,CAAC;IACnB,KAAK,OAAO;MACV,OAAO,IAAIC,KAAK,CAAC,CAAC;IACpB,KAAK,OAAO;MACV,OAAO,IAAIC,KAAK,CAAC,CAAC;IACpB,KAAK,OAAO;MACV,OAAO,IAAIC,KAAK,CAAC,CAAC;IACpB,KAAK,OAAO;MACV,OAAO,IAAIC,KAAK,CAAC,CAAC;IACpB,KAAK,QAAQ;MACX,OAAO,IAAIC,MAAM,CAAC,CAAC;IACrB,KAAK,QAAQ;MACX,OAAO,IAAIC,MAAM,CAAC,CAAC;IACrB,KAAK,QAAQ;MACX,OAAO,IAAIC,MAAM,CAAC,CAAC;IAErB,KAAK,SAAS;MACZ,OAAO,IAAIC,OAAO,CAAC,CAAC;IACtB,KAAK,SAAS;MACZ,OAAO,IAAIC,OAAO,CAAC,CAAC;IACtB,KAAK,SAAS;MACZ,OAAO,IAAIC,OAAO,CAAC,CAAC;IACtB,KAAK,MAAM;MACT,OAAO,IAAIC,IAAI,CAAC,CAAC;IAEnB,KAAK,UAAU;MACb,OAAO,IAAIC,OAAO,CAAC,CAAC;IACtB,KAAK,kBAAkB;MACrB,OAAO,IAAIC,eAAe,CAAC,CAAC;IAE9B,KAAK,kBAAkB;MACrB,OAAO,IAAIC,eAAe,CAAC,CAAC;IAC9B,KAAK,aAAa;MAChB,OAAO,IAAIC,UAAU,CAAC,CAAC;IAEzB,KAAK,kBAAkB;MACrB,OAAO,IAAIC,eAAe,CAAC,CAAC;IAC9B,KAAK,uBAAuB;MAC1B,OAAO,IAAIC,oBAAoB,CAAC,CAAC;IACnC,KAAK,uBAAuB;MAC1B,OAAO,IAAIC,oBAAoB,CAAC,CAAC;IACnC,KAAK,sBAAsB;MACzB,OAAO,IAAIC,mBAAmB,CAAC,CAAC;IAElC,KAAK,kBAAkB;MACrB,OAAO,IAAIC,eAAe,CAAC,CAAC;IAC9B,KAAK,oBAAoB;MACvB,OAAO,IAAIC,iBAAiB,CAAC,CAAC;IAChC;MACE,MAAM,IAAI8B,KAAK,CAAC,0BAA0B,CAAC;EAC/C;AACF"}