@loaders.gl/arrow 4.0.0 → 4.0.1

package/dist/index.js.map

@@ -1 +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"}
+{"version":3,"file":"index.js","names":["TableBatchBuilder","ArrowLoader","ArrowWorkerLoader","parseSync","parseArrowInBatches","ArrowTableBatchAggregator","ArrowBatch","getArrowType","serializeArrowSchema","deserializeArrowSchema","serializeArrowMetadata","deserializeArrowMetadata","serializeArrowField","deserializeArrowField","serializeArrowType","deserializeArrowType","VECTOR_TYPES","ArrowWriter","parse","arraybuffer","options","parseInBatches","getBinaryGeometriesFromArrow","parseGeometryFromArrow"],"sources":["../src/index.ts"],"sourcesContent":["// loaders.gl, MIT license\n// Copyright (c) vis.gl contributors\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// Make the ArrowBatch type available\nTableBatchBuilder.ArrowBatch = ArrowTableBatchAggregator;\n\n// TYPES\n\nexport {getArrowType} from './schema/arrow-type-utils';\n\n// SCHEMA\n\nexport {\n  serializeArrowSchema,\n  deserializeArrowSchema,\n  serializeArrowMetadata,\n  deserializeArrowMetadata,\n  serializeArrowField,\n  deserializeArrowField,\n  serializeArrowType,\n  deserializeArrowType\n} from './schema/convert-arrow-schema';\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\n// Arrow Utils\nexport type {GeoArrowEncoding} from '@loaders.gl/gis';\n// getGeometryColumnsFromArrowTable,\n// getGeoArrowEncoding\n\nexport type {BinaryDataFromGeoArrow} from './geoarrow/convert-geoarrow-to-binary-geometry';\nexport {getBinaryGeometriesFromArrow} from './geoarrow/convert-geoarrow-to-binary-geometry';\n\nexport {parseGeometryFromArrow} from './geoarrow/convert-geoarrow-to-geojson';\n"],"mappings":"AAQA,SAAQA,iBAAiB,QAAO,oBAAoB;AAAC,SAC7CC,WAAW,IAAIC,iBAAiB;AAAA,OACjCC,SAAS;AAAA,SACRC,mBAAmB;AAAA,SAEnBC,yBAAyB;AAGjCL,iBAAiB,CAACM,UAAU,GAAGD,yBAAyB;AAAC,SAIjDE,YAAY;AAAA,SAKlBC,oBAAoB,EACpBC,sBAAsB,EACtBC,sBAAsB,EACtBC,wBAAwB,EACxBC,mBAAmB,EACnBC,qBAAqB,EACrBC,kBAAkB,EAClBC,oBAAoB;AAAA,SAKdC,YAAY;AAAA,SAIZC,WAAW;AAKnB,SAAQf,iBAAiB;AAGzB,OAAO,MAAMD,WAIZ,GAAG;EACF,GAAGC,iBAAiB;EACpBgB,KAAK,EAAE,MAAAA,CAAOC,WAAwB,EAAEC,OAA4B,KAClEjB,SAAS,CAACgB,WAAW,EAAEC,OAAO,CAAC;EACjCjB,SAAS;EACTkB,cAAc,EAAEjB;AAClB,CAAC;AAAC,SAQMkB,4BAA4B;AAAA,SAE5BC,sBAAsB"}

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

@@ -1 +1 @@
-{"version":3,"file":"parse-arrow-sync.d.ts","sourceRoot":"","sources":["../../src/lib/parse-arrow-sync.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,aAAa,EAAE,cAAc,EAAC,MAAM,oBAAoB,CAAC;AACtE,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,eAAe,CAAC;AAG9C,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,iBAAiB,CAAC;AAIxD,MAAM,CAAC,OAAO,UAAU,cAAc,CACpC,WAAW,KAAA,EACX,OAAO,CAAC,EAAE,kBAAkB,GAC3B,UAAU,GAAG,aAAa,GAAG,cAAc,CAoB7C"}
+{"version":3,"file":"parse-arrow-sync.d.ts","sourceRoot":"","sources":["../../src/lib/parse-arrow-sync.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,aAAa,EAAE,cAAc,EAAC,MAAM,oBAAoB,CAAC;AACtE,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,eAAe,CAAC;AAG9C,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,iBAAiB,CAAC;AAOxD,MAAM,CAAC,OAAO,UAAU,cAAc,CACpC,WAAW,KAAA,EACX,OAAO,CAAC,EAAE,kBAAkB,GAC3B,UAAU,GAAG,aAAa,GAAG,cAAc,CAoB7C"}

package/dist/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.js";
+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)]);

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 {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"}
+{"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"}

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

@@ -1,4 +1,5 @@
 import type { TypedArray } from '@loaders.gl/schema';
 import { DataType } 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;
 //# 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,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,EACL,QAAQ,EAiBT,MAAM,cAAc,CAAC;AAGtB,oHAAoH;AACpH,wBAAgB,YAAY,CAAC,KAAK,EAAE,UAAU,GAAG,QAAQ,CAqBxD"}

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\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;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"}
+{"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"}

package/dist/schema/{convert-schema-arrow.d.ts → convert-arrow-schema.d.ts}

@@ -1,13 +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';
+/** Convert Apache Arrow Schema (class instance) to a serialized Schema (plain data) */
 export declare function serializeArrowSchema(arrowSchema: ArrowSchema): Schema;
+/** Convert a serialized Schema (plain data) to an Apache Arrow Schema (class instance) */
 export declare function deserializeArrowSchema(schema: Schema): ArrowSchema;
+/** 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;
+/** Convert a serialized Field (plain data) to an Apache Arrow Field (class instance)*/
 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
+//# sourceMappingURL=convert-arrow-schema.d.ts.map

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

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

package/dist/schema/{convert-schema-arrow.js → convert-arrow-schema.js}

@@ -1,4 +1,4 @@
-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';
+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';
 export function serializeArrowSchema(arrowSchema) {
   return {
     fields: arrowSchema.fields.map(arrowField => serializeArrowField(arrowField)),
@@ -33,6 +33,9 @@ export function serializeArrowType(arrowType) {
       return 'binary';
     case Bool:
       return 'bool';
+    case Int:
+      const intType = arrowType;
+      return `${intType.isSigned ? 'u' : ''}int${intType.bitWidth}`;
     case Int8:
       return 'int8';
     case Int16:
@@ -49,6 +52,18 @@ export function serializeArrowType(arrowType) {
       return 'uint32';
     case Uint64:
       return 'uint64';
+    case Float:
+      const precision = arrowType.precision;
+      switch (precision) {
+        case Precision.HALF:
+          return 'float16';
+        case Precision.SINGLE:
+          return 'float32';
+        case Precision.DOUBLE:
+          return 'float64';
+        default:
+          return 'float16';
+      }
     case Float16:
       return 'float16';
     case Float32:
@@ -57,14 +72,49 @@ export function serializeArrowType(arrowType) {
       return 'float64';
     case Utf8:
       return 'utf8';
+    case Date:
+      const dateUnit = arrowType.unit;
+      return dateUnit === DateUnit.DAY ? 'date-day' : 'date-millisecond';
     case DateDay:
       return 'date-day';
     case DateMillisecond:
       return 'date-millisecond';
+    case Time:
+      const timeUnit = arrowType.unit;
+      switch (timeUnit) {
+        case TimeUnit.SECOND:
+          return 'time-second';
+        case TimeUnit.MILLISECOND:
+          return 'time-millisecond';
+        case TimeUnit.MICROSECOND:
+          return 'time-microsecond';
+        case TimeUnit.NANOSECOND:
+          return 'time-nanosecond';
+        default:
+          return 'time-second';
+      }
     case TimeMillisecond:
       return 'time-millisecond';
     case TimeSecond:
       return 'time-second';
+    case TimeMicrosecond:
+      return 'time-microsecond';
+    case TimeNanosecond:
+      return 'time-nanosecond';
+    case Timestamp:
+      const timeStampUnit = arrowType.unit;
+      switch (timeStampUnit) {
+        case TimeUnit.SECOND:
+          return 'timestamp-second';
+        case TimeUnit.MILLISECOND:
+          return 'timestamp-millisecond';
+        case TimeUnit.MICROSECOND:
+          return 'timestamp-microsecond';
+        case TimeUnit.NANOSECOND:
+          return 'timestamp-nanosecond';
+        default:
+          return 'timestamp-second';
+      }
     case TimestampSecond:
       return 'timestamp-second';
     case TimestampMillisecond:
@@ -73,10 +123,27 @@ export function serializeArrowType(arrowType) {
       return 'timestamp-microsecond';
     case TimestampNanosecond:
       return 'timestamp-nanosecond';
+    case Interval:
+      const intervalUnit = arrowType.unit;
+      switch (intervalUnit) {
+        case IntervalUnit.DAY_TIME:
+          return 'interval-daytime';
+        case IntervalUnit.YEAR_MONTH:
+          return 'interval-yearmonth';
+        default:
+          return 'interval-daytime';
+      }
     case IntervalDayTime:
       return 'interval-daytime';
     case IntervalYearMonth:
       return 'interval-yearmonth';
+    case List:
+      const listType = arrowType;
+      const listField = listType.valueField;
+      return {
+        type: 'list',
+        children: [serializeArrowField(listField)]
+      };
     case FixedSizeList:
       return {
         type: 'fixed-size-list',
@@ -90,6 +157,9 @@ export function serializeArrowType(arrowType) {
 export function deserializeArrowType(dataType) {
   if (typeof dataType === 'object') {
     switch (dataType.type) {
+      case 'list':
+        const field = deserializeArrowField(dataType.children[0]);
+        return new List(field);
       case 'fixed-size-list':
         const child = deserializeArrowField(dataType.children[0]);
         return new FixedSizeList(dataType.listSize, child);
@@ -135,10 +205,14 @@ export function deserializeArrowType(dataType) {
       return new DateDay();
     case 'date-millisecond':
       return new DateMillisecond();
-    case 'time-millisecond':
-      return new TimeMillisecond();
     case 'time-second':
       return new TimeSecond();
+    case 'time-millisecond':
+      return new TimeMillisecond();
+    case 'time-microsecond':
+      return new TimeMicrosecond();
+    case 'time-nanosecond':
+      return new TimeNanosecond();
     case 'timestamp-second':
       return new TimestampSecond();
     case 'timestamp-millisecond':
@@ -155,4 +229,4 @@ export function deserializeArrowType(dataType) {
       throw new Error('array type not supported');
   }
 }
-//# sourceMappingURL=convert-schema-arrow.js.map
+//# sourceMappingURL=convert-arrow-schema.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"convert-arrow-schema.js","names":["Field","ArrowField","Schema","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","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","intType","isSigned","bitWidth","precision","HALF","SINGLE","DOUBLE","Date","dateUnit","unit","DAY","timeUnit","SECOND","MILLISECOND","MICROSECOND","NANOSECOND","timeStampUnit","intervalUnit","DAY_TIME","YEAR_MONTH","listType","listField","valueField","children","listSize","Error","dataType","child"],"sources":["../../src/schema/convert-arrow-schema.ts"],"sourcesContent":["// loaders.gl, MIT license\n// Copyright (c) vis.gl contributors\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  Precision,\n  Utf8,\n  Date_,\n  DateUnit,\n  DateDay,\n  DateMillisecond,\n  Time,\n  TimeMillisecond,\n  TimeSecond,\n  Timestamp,\n  TimestampSecond,\n  TimestampMillisecond,\n  TimestampMicrosecond,\n  TimestampNanosecond,\n  Interval,\n  IntervalUnit,\n  IntervalDayTime,\n  IntervalYearMonth,\n  FixedSizeList,\n  Struct,\n  TimeUnit,\n  TimeMicrosecond,\n  TimeNanosecond,\n  List\n} from 'apache-arrow';\n\n/** Convert Apache Arrow Schema (class instance) to a serialized Schema (plain data) */\nexport function serializeArrowSchema(arrowSchema: ArrowSchema): Schema {\n  return {\n    fields: arrowSchema.fields.map((arrowField) => serializeArrowField(arrowField)),\n    metadata: serializeArrowMetadata(arrowSchema.metadata)\n  };\n}\n\n/** Convert a serialized Schema (plain data) to an Apache Arrow Schema (class instance) */\nexport function deserializeArrowSchema(schema: Schema): ArrowSchema {\n  return new ArrowSchema(\n    schema.fields.map((field) => deserializeArrowField(field)),\n    deserializeArrowMetadata(schema.metadata)\n  );\n}\n\n/** Convert Apache Arrow Schema metadata (Map<string, string>) to serialized metadata (Record<string, string> */\nexport function serializeArrowMetadata(arrowMetadata: Map<string, string>): SchemaMetadata {\n  return Object.fromEntries(arrowMetadata);\n}\n\n/** Convert serialized metadata (Record<string, string> to Apache Arrow Schema metadata (Map<string, string>) to */\nexport function deserializeArrowMetadata(metadata?: SchemaMetadata): Map<string, string> {\n  return metadata ? new Map(Object.entries(metadata)) : new Map<string, string>();\n}\n\n/** Convert Apache Arrow Field (class instance) to serialized Field (plain data) */\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\n/** Convert a serialized Field (plain data) to an Apache Arrow Field (class instance)*/\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:\n      const intType = arrowType as Int;\n      return `${intType.isSigned ? 'u' : ''}int${intType.bitWidth}`;\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:\n      const precision = (arrowType as Float).precision;\n      // return `float(precision + 1) * 16`;\n      switch (precision) {\n        case Precision.HALF:\n          return 'float16';\n        case Precision.SINGLE:\n          return 'float32';\n        case Precision.DOUBLE:\n          return 'float64';\n        default:\n          return 'float16';\n      }\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:\n      const dateUnit = (arrowType as Date_).unit;\n      return dateUnit === DateUnit.DAY ? 'date-day' : 'date-millisecond';\n    case DateDay:\n      return 'date-day';\n    case DateMillisecond:\n      return 'date-millisecond';\n    case Time:\n      const timeUnit = (arrowType as Time).unit;\n      switch (timeUnit) {\n        case TimeUnit.SECOND:\n          return 'time-second';\n        case TimeUnit.MILLISECOND:\n          return 'time-millisecond';\n        case TimeUnit.MICROSECOND:\n          return 'time-microsecond';\n        case TimeUnit.NANOSECOND:\n          return 'time-nanosecond';\n        default:\n          return 'time-second';\n      }\n    case TimeMillisecond:\n      return 'time-millisecond';\n    case TimeSecond:\n      return 'time-second';\n    case TimeMicrosecond:\n      return 'time-microsecond';\n    case TimeNanosecond:\n      return 'time-nanosecond';\n    case Timestamp:\n      const timeStampUnit = (arrowType as Timestamp).unit;\n      switch (timeStampUnit) {\n        case TimeUnit.SECOND:\n          return 'timestamp-second';\n        case TimeUnit.MILLISECOND:\n          return 'timestamp-millisecond';\n        case TimeUnit.MICROSECOND:\n          return 'timestamp-microsecond';\n        case TimeUnit.NANOSECOND:\n          return 'timestamp-nanosecond';\n        default:\n          return 'timestamp-second';\n      }\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:\n      const intervalUnit = (arrowType as Interval).unit;\n      switch (intervalUnit) {\n        case IntervalUnit.DAY_TIME:\n          return 'interval-daytime';\n        case IntervalUnit.YEAR_MONTH:\n          return 'interval-yearmonth';\n        default:\n          return 'interval-daytime';\n      }\n    case IntervalDayTime:\n      return 'interval-daytime';\n    case IntervalYearMonth:\n      return 'interval-yearmonth';\n    case List:\n      const listType = arrowType as List;\n      const listField = listType.valueField;\n      return {\n        type: 'list',\n        children: [serializeArrowField(listField)]\n      };\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 'list':\n        const field = deserializeArrowField(dataType.children[0]);\n        return new List(field);\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 '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 '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-day':\n      return new DateDay();\n    case 'date-millisecond':\n      return new DateMillisecond();\n    case 'time-second':\n      return new TimeSecond();\n    case 'time-millisecond':\n      return new TimeMillisecond();\n    case 'time-microsecond':\n      return new TimeMicrosecond();\n    case 'time-nanosecond':\n      return new TimeNanosecond();\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-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":"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"}

package/dist/{lib/convert-table.d.ts → tables/convert-arrow-to-table.d.ts}

@@ -1,6 +1,6 @@
 import type { ColumnarTable, ObjectRowTable } from '@loaders.gl/schema';
 import type { Table as ApacheArrowTable } from 'apache-arrow';
-import type { ArrowTable } from './arrow-table';
+import type { ArrowTable } from '../lib/arrow-table';
 /**
  * Wrap an apache arrow table in a loaders.gl table wrapper.
  * From this additional conversions are available.
@@ -18,4 +18,4 @@ export declare function convertArrowToColumnarTable(table: ArrowTable): Columnar
  * @note - should be part of schema module
  */
 export declare function convertColumnarToRowFormatTable(columnarTable: ColumnarTable): ObjectRowTable;
-//# sourceMappingURL=convert-table.d.ts.map
+//# sourceMappingURL=convert-arrow-to-table.d.ts.map

package/dist/tables/convert-arrow-to-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-arrow-to-table.d.ts","sourceRoot":"","sources":["../../src/tables/convert-arrow-to-table.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,aAAa,EAAE,cAAc,EAAC,MAAM,oBAAoB,CAAC;AACtE,OAAO,KAAK,EAAC,KAAK,IAAI,gBAAgB,EAAC,MAAM,cAAc,CAAC;AAC5D,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,oBAAoB,CAAC;AAEnD;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAAC,UAAU,EAAE,gBAAgB,GAAG,UAAU,CAKvF;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,UAAU,GAAG,aAAa,CAkB5E;AAED;;;GAGG;AACH,wBAAgB,+BAA+B,CAAC,aAAa,EAAE,aAAa,GAAG,cAAc,CAmB5F"}

package/dist/{lib/convert-table.js → tables/convert-arrow-to-table.js}

@@ -34,4 +34,4 @@ export function convertColumnarToRowFormatTable(columnarTable) {
     data: rowFormatTable
   };
 }
-//# sourceMappingURL=convert-table.js.map
+//# sourceMappingURL=convert-arrow-to-table.js.map

package/dist/tables/convert-arrow-to-table.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-arrow-to-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/tables/convert-arrow-to-table.ts"],"sourcesContent":["// loaders.gl, MIT license\n// Copyright (c) vis.gl contributors\n\nimport type {ColumnarTable, ObjectRowTable} from '@loaders.gl/schema';\nimport type {Table as ApacheArrowTable} from 'apache-arrow';\nimport type {ArrowTable} from '../lib/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":"AAaA,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/{schema → tables}/convert-table-to-arrow.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"convert-table-to-arrow.d.ts","sourceRoot":"","sources":["../../src/schema/convert-table-to-arrow.ts"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwCE"}
+{"version":3,"file":"convert-table-to-arrow.d.ts","sourceRoot":"","sources":["../../src/tables/convert-table-to-arrow.ts"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwCE"}

package/dist/{schema → tables}/convert-table-to-arrow.js.map

@@ -1 +1 @@
-{"version":3,"file":"convert-table-to-arrow.js","names":[],"sources":["../../src/schema/convert-table-to-arrow.ts"],"sourcesContent":["// loaders.gl, MIT license\n// Copyright (c) vis.gl contributors\n\n// import {\n//   Table as ApacheArrowTable,\n//   Schema as ApacheArrowSchema,\n//   RecordBatch,\n//   FixedSizeList,\n//   Field,\n//   Data,\n//   FixedSizeListVector\n// } from 'apache-arrow/Arrow.dom';\n// import {AbstractVector} from 'apache-arrow/vector';\n\n// import {Table} from '../../types/category-table';\n// import {getArrowType, getArrowVector} from './arrow-type-utils';\n// import {makeMeshAttributeMetadata} from './deduce-mesh-schema';\n// import {getTableLength, getTableNumCols} from './table-accessors';\n\n/**\n * * Convert a loaders.gl Mesh to an Apache Arrow Table\n * @param mesh\n * @param metadata\n * @param batchSize\n * @returns\n *\nexport function convertTableToArrow(table: Table, options?: {batchSize?: number}): ArrowTable {\n  const vectors: AbstractVector[] = [];\n  const fields: Field[] = [];\n\n  const length = getTableLength(table);\n  const batchSize = options?.batchSize || length;\n\n  const recordBatches: RecordBatch[] = [];\n  for (let i = 0; i < length; i += batchSize) {\n    for (let columnIndex = 0; columnIndex < getTableNumCols(table); ++columnIndex) {\n      const field_ = table.schema.fields[columnIndex];\n      const column = getTableColumnAt(table, columnIndex, i, batchSize);\n      const type = getArrowType(column);\n      const vector = getArrowVector(column);\n      const listType = new FixedSizeList(size, new Field('value', type));\n      const field = new Field(field_.name, listType, false, makeMeshAttributeMetadata(attribute));\n      const data = new Data(listType, 0, value.length / size, 0, undefined, [vector]);\n      const listVector = new FixedSizeListVector(data);\n      vectors.push(listVector);\n      fields.push(field);\n    }\n\n  for (const attributeKey in table.columns) {\n    const attribute = mesh.attributes[attributeKey];\n    const {value, size = 1} = attribute;\n  }\n\n  const schema = new ApacheArrowSchema(fields, table?.schema?.metadata || new Map<string, string>());\n  const recordBatch = new RecordBatch(schema, vectors[0].length, vectors);\n  const apacheArrowTable = new ApacheArrowTable(schema, recordBatch);\n\n  return apacheArrowTable;\n}\n*/\n"],"mappings":""}
+{"version":3,"file":"convert-table-to-arrow.js","names":[],"sources":["../../src/tables/convert-table-to-arrow.ts"],"sourcesContent":["// loaders.gl, MIT license\n// Copyright (c) vis.gl contributors\n\n// import {\n//   Table as ApacheArrowTable,\n//   Schema as ApacheArrowSchema,\n//   RecordBatch,\n//   FixedSizeList,\n//   Field,\n//   Data,\n//   FixedSizeListVector\n// } from 'apache-arrow/Arrow.dom';\n// import {AbstractVector} from 'apache-arrow/vector';\n\n// import {Table} from '../../types/category-table';\n// import {getArrowType, getArrowVector} from './arrow-type-utils';\n// import {makeMeshAttributeMetadata} from './deduce-mesh-schema';\n// import {getTableLength, getTableNumCols} from './table-accessors';\n\n/**\n * * Convert a loaders.gl Mesh to an Apache Arrow Table\n * @param mesh\n * @param metadata\n * @param batchSize\n * @returns\n *\nexport function convertTableToArrow(table: Table, options?: {batchSize?: number}): ArrowTable {\n  const vectors: AbstractVector[] = [];\n  const fields: Field[] = [];\n\n  const length = getTableLength(table);\n  const batchSize = options?.batchSize || length;\n\n  const recordBatches: RecordBatch[] = [];\n  for (let i = 0; i < length; i += batchSize) {\n    for (let columnIndex = 0; columnIndex < getTableNumCols(table); ++columnIndex) {\n      const field_ = table.schema.fields[columnIndex];\n      const column = getTableColumnAt(table, columnIndex, i, batchSize);\n      const type = getArrowType(column);\n      const vector = getArrowVector(column);\n      const listType = new FixedSizeList(size, new Field('value', type));\n      const field = new Field(field_.name, listType, false, makeMeshAttributeMetadata(attribute));\n      const data = new Data(listType, 0, value.length / size, 0, undefined, [vector]);\n      const listVector = new FixedSizeListVector(data);\n      vectors.push(listVector);\n      fields.push(field);\n    }\n\n  for (const attributeKey in table.columns) {\n    const attribute = mesh.attributes[attributeKey];\n    const {value, size = 1} = attribute;\n  }\n\n  const schema = new ApacheArrowSchema(fields, table?.schema?.metadata || new Map<string, string>());\n  const recordBatch = new RecordBatch(schema, vectors[0].length, vectors);\n  const apacheArrowTable = new ApacheArrowTable(schema, recordBatch);\n\n  return apacheArrowTable;\n}\n*/\n"],"mappings":""}

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,KAAK,aAAa,GAAG,SAAS,GAAG,UAAU,GAAG,UAAU,GAAG,WAAW,GAAG,UAAU,GAAG,WAAW,CAAC;AAElG,KAAK,eAAe,GAAG,YAAY,GAAG,YAAY,CAAC;AAEnD,KAAK,UAAU,GAAG,aAAa,GAAG,eAAe,CAAC;AAElD,MAAM,MAAM,YAAY,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,UAAU,CAAC;AAEnD,oBAAY,YAAY;IACtB,KAAK,IAAA;IACL,IAAI,IAAA;CACL"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAGA,KAAK,aAAa,GAAG,SAAS,GAAG,UAAU,GAAG,UAAU,GAAG,WAAW,GAAG,UAAU,GAAG,WAAW,CAAC;AAElG,KAAK,eAAe,GAAG,YAAY,GAAG,YAAY,CAAC;AAEnD,KAAK,UAAU,GAAG,aAAa,GAAG,eAAe,CAAC;AAElD,MAAM,MAAM,YAAY,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,UAAU,CAAC;AAEnD,oBAAY,YAAY;IACtB,KAAK,IAAA;IACL,IAAI,IAAA;CACL"}

package/dist/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","names":["VECTOR_TYPES"],"sources":["../src/types.ts"],"sourcesContent":["type TypedIntArray = Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array;\n\ntype TypedFloatArray = Float32Array | Float64Array;\n\ntype TypedArray = TypedIntArray | TypedFloatArray;\n\nexport type AnyArrayType = Array<any> | TypedArray;\n\nexport enum VECTOR_TYPES {\n  FLOAT,\n  DATE\n}\n"],"mappings":"AAQA,WAAYA,YAAY,aAAZA,YAAY;EAAZA,YAAY,CAAZA,YAAY;EAAZA,YAAY,CAAZA,YAAY;EAAA,OAAZA,YAAY;AAAA"}
+{"version":3,"file":"types.js","names":["VECTOR_TYPES"],"sources":["../src/types.ts"],"sourcesContent":["// loaders.gl, MIT license\n// Copyright (c) vis.gl contributors\n\ntype TypedIntArray = Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array;\n\ntype TypedFloatArray = Float32Array | Float64Array;\n\ntype TypedArray = TypedIntArray | TypedFloatArray;\n\nexport type AnyArrayType = Array<any> | TypedArray;\n\nexport enum VECTOR_TYPES {\n  FLOAT,\n  DATE\n}\n"],"mappings":"AAWA,WAAYA,YAAY,aAAZA,YAAY;EAAZA,YAAY,CAAZA,YAAY;EAAZA,YAAY,CAAZA,YAAY;EAAA,OAAZA,YAAY;AAAA"}

package/dist/workers/arrow-worker.js.map

@@ -1 +1 @@
-{"version":3,"file":"arrow-worker.js","names":["createLoaderWorker","ArrowLoader"],"sources":["../../src/workers/arrow-worker.ts"],"sourcesContent":["import {createLoaderWorker} from '@loaders.gl/loader-utils';\nimport {ArrowLoader} from '../index';\n\ncreateLoaderWorker(ArrowLoader);\n"],"mappings":"AAAA,SAAQA,kBAAkB,QAAO,0BAA0B;AAAC,SACpDC,WAAW;AAEnBD,kBAAkB,CAACC,WAAW,CAAC"}
+{"version":3,"file":"arrow-worker.js","names":["createLoaderWorker","ArrowLoader"],"sources":["../../src/workers/arrow-worker.ts"],"sourcesContent":["// loaders.gl, MIT license\n// Copyright (c) vis.gl contributors\n\nimport {createLoaderWorker} from '@loaders.gl/loader-utils';\nimport {ArrowLoader} from '../index';\n\ncreateLoaderWorker(ArrowLoader);\n"],"mappings":"AAGA,SAAQA,kBAAkB,QAAO,0BAA0B;AAAC,SACpDC,WAAW;AAEnBD,kBAAkB,CAACC,WAAW,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/arrow",
-  "version": "4.0.0",
+  "version": "4.0.1",
   "description": "Simple columnar table loader for the Apache Arrow format",
   "license": "MIT",
   "type": "module",
@@ -46,9 +46,10 @@
     "build-worker2": "esbuild src/workers/arrow-worker.ts --bundle --outfile=dist/arrow-worker.js --platform=browser --external:{stream}"
   },
   "dependencies": {
-    "@loaders.gl/loader-utils": "4.0.0",
-    "@loaders.gl/schema": "4.0.0",
+    "@loaders.gl/gis": "4.0.1",
+    "@loaders.gl/loader-utils": "4.0.1",
+    "@loaders.gl/schema": "4.0.1",
     "apache-arrow": "^13.0.0"
   },
-  "gitHead": "9b4211dc0ecd4134a1638ac0a29c5ea9008fd971"
+  "gitHead": "765e5a26a6bf3f2cc02cabffc4a1e3665ec92a53"
 }

package/src/arrow-loader.ts

@@ -1,5 +1,6 @@
 // loaders.gl, MIT license
 // Copyright (c) vis.gl contributors
+
 import type {Loader, LoaderOptions} from '@loaders.gl/loader-utils';
 import type {ArrowTable} from './lib/arrow-table';
 

package/src/arrow-writer.ts

@@ -1,4 +1,5 @@
 // import type {} from '@loaders.gl/loader-utils';
+
 import type {Writer, WriterOptions} from '@loaders.gl/loader-utils';
 import {ColumnarTable} from './lib/encode-arrow';
 import {encodeArrowSync} from './lib/encode-arrow';