@loaders.gl/arrow 4.2.0-alpha.3 → 4.2.0-alpha.5

package/dist/geoarrow/get-arrow-bounds.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"get-arrow-bounds.js","names":["updateBoundsFromGeoArrowSamples","flatCoords","nDim","bounds","sampleSize","arguments","length","undefined","numberOfFeatures","sampleStep","Math","max","floor","newBounds","i","lng","lat"],"sources":["../../src/geoarrow/get-arrow-bounds.ts"],"sourcesContent":["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\n/**\n *  Update bounds from geoarrow sample data\n *\n * @param flatCoords the flattend coordinates array from one chunk of geoarrow column\n * @param nDim the number of dimensions of the coordinates\n * @param bounds the bounds to be updated\n * @param sampleSize how many samples to be used to update the bounds, default is 1000 per chunk\n * @returns the updated bounds\n */\nexport function updateBoundsFromGeoArrowSamples(\n  flatCoords: Float64Array,\n  nDim: number,\n  bounds: [number, number, number, number],\n  sampleSize: number = 100\n): [number, number, number, number] {\n  const numberOfFeatures = flatCoords.length / nDim;\n  const sampleStep = Math.max(Math.floor(numberOfFeatures / sampleSize), 1);\n\n  const newBounds: [number, number, number, number] = [...bounds];\n  for (let i = 0; i < numberOfFeatures; i += sampleStep) {\n    const lng = flatCoords[i * nDim];\n    const lat = flatCoords[i * nDim + 1];\n    if (lng < newBounds[0]) {\n      newBounds[0] = lng;\n    }\n    if (lat < newBounds[1]) {\n      newBounds[1] = lat;\n    }\n    if (lng > newBounds[2]) {\n      newBounds[2] = lng;\n    }\n    if (lat > newBounds[3]) {\n      newBounds[3] = lat;\n    }\n  }\n  return newBounds;\n}\n"],"mappings":"AAaA,OAAO,SAASA,+BAA+BA,CAC7CC,UAAwB,EACxBC,IAAY,EACZC,MAAwC,EAEN;EAAA,IADlCC,UAAkB,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,GAAG;EAExB,MAAMG,gBAAgB,GAAGP,UAAU,CAACK,MAAM,GAAGJ,IAAI;EACjD,MAAMO,UAAU,GAAGC,IAAI,CAACC,GAAG,CAACD,IAAI,CAACE,KAAK,CAACJ,gBAAgB,GAAGJ,UAAU,CAAC,EAAE,CAAC,CAAC;EAEzE,MAAMS,SAA2C,GAAG,CAAC,GAAGV,MAAM,CAAC;EAC/D,KAAK,IAAIW,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGN,gBAAgB,EAAEM,CAAC,IAAIL,UAAU,EAAE;IACrD,MAAMM,GAAG,GAAGd,UAAU,CAACa,CAAC,GAAGZ,IAAI,CAAC;IAChC,MAAMc,GAAG,GAAGf,UAAU,CAACa,CAAC,GAAGZ,IAAI,GAAG,CAAC,CAAC;IACpC,IAAIa,GAAG,GAAGF,SAAS,CAAC,CAAC,CAAC,EAAE;MACtBA,SAAS,CAAC,CAAC,CAAC,GAAGE,GAAG;IACpB;IACA,IAAIC,GAAG,GAAGH,SAAS,CAAC,CAAC,CAAC,EAAE;MACtBA,SAAS,CAAC,CAAC,CAAC,GAAGG,GAAG;IACpB;IACA,IAAID,GAAG,GAAGF,SAAS,CAAC,CAAC,CAAC,EAAE;MACtBA,SAAS,CAAC,CAAC,CAAC,GAAGE,GAAG;IACpB;IACA,IAAIC,GAAG,GAAGH,SAAS,CAAC,CAAC,CAAC,EAAE;MACtBA,SAAS,CAAC,CAAC,CAAC,GAAGG,GAAG;IACpB;EACF;EACA,OAAOH,SAAS;AAClB"}

package/dist/geoarrow-loader.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"geoarrow-loader.js","names":["ArrowWorkerLoader","parseGeoArrowSync","parseGeoArrowInBatches","GeoArrowWorkerLoader","options","arrow","shape","GeoArrowLoader","parse","arraybuffer","parseSync","parseInBatches"],"sources":["../src/geoarrow-loader.ts"],"sourcesContent":["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {Loader, LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';\nimport {ArrowWorkerLoader} from './arrow-loader';\nimport type {GeoJSONTable, GeoJSONTableBatch, BinaryGeometry} from '@loaders.gl/schema';\nimport type {ArrowTable, ArrowTableBatch} from './lib/arrow-table';\nimport {parseGeoArrowSync} from './parsers/parse-geoarrow-sync';\nimport {parseGeoArrowInBatches} from './parsers/parse-geoarrow-in-batches';\n\nexport type GeoArrowLoaderOptions = LoaderOptions & {\n  arrow?: {\n    shape: 'arrow-table' | 'binary-geometry';\n  };\n};\n\n/** ArrowJS table loader */\nexport const GeoArrowWorkerLoader: Loader<\n  ArrowTable | BinaryGeometry,\n  never,\n  GeoArrowLoaderOptions\n> = {\n  ...ArrowWorkerLoader,\n  options: {\n    arrow: {\n      shape: 'arrow-table'\n    }\n  }\n};\n\n/**\n * GeoArrowLoader loads an Apache Arrow table, parses GeoArrow type extension data\n * to convert it to a GeoJSON table or a BinaryGeometry\n */\nexport const GeoArrowLoader: LoaderWithParser<\n  ArrowTable | GeoJSONTable, // | BinaryGeometry,\n  ArrowTableBatch | GeoJSONTableBatch, // | BinaryGeometry,\n  GeoArrowLoaderOptions\n> = {\n  ...ArrowWorkerLoader,\n  options: {\n    arrow: {\n      shape: 'arrow-table'\n    }\n  },\n  parse: async (arraybuffer: ArrayBuffer, options?: GeoArrowLoaderOptions) =>\n    parseGeoArrowSync(arraybuffer, options?.arrow),\n  parseSync: (arraybuffer: ArrayBuffer, options?: GeoArrowLoaderOptions) =>\n    parseGeoArrowSync(arraybuffer, options?.arrow),\n  parseInBatches: parseGeoArrowInBatches\n};\n"],"mappings":"SAKQA,iBAAiB;AAAA,SAGjBC,iBAAiB;AAAA,SACjBC,sBAAsB;AAS9B,OAAO,MAAMC,oBAIZ,GAAG;EACF,GAAGH,iBAAiB;EACpBI,OAAO,EAAE;IACPC,KAAK,EAAE;MACLC,KAAK,EAAE;IACT;EACF;AACF,CAAC;AAMD,OAAO,MAAMC,cAIZ,GAAG;EACF,GAAGP,iBAAiB;EACpBI,OAAO,EAAE;IACPC,KAAK,EAAE;MACLC,KAAK,EAAE;IACT;EACF,CAAC;EACDE,KAAK,EAAE,MAAAA,CAAOC,WAAwB,EAAEL,OAA+B,KACrEH,iBAAiB,CAACQ,WAAW,EAAEL,OAAO,aAAPA,OAAO,uBAAPA,OAAO,CAAEC,KAAK,CAAC;EAChDK,SAAS,EAAEA,CAACD,WAAwB,EAAEL,OAA+B,KACnEH,iBAAiB,CAACQ,WAAW,EAAEL,OAAO,aAAPA,OAAO,uBAAPA,OAAO,CAAEC,KAAK,CAAC;EAChDM,cAAc,EAAET;AAClB,CAAC"}

package/dist/geoarrow-writer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"geoarrow-writer.js","names":["encodeGeoArrowSync","VERSION","GeoArrowWriter","name","id","module","version","extensions","mimeTypes","binary","options","encode","encodeArrow","data","encodeSync"],"sources":["../src/geoarrow-writer.ts"],"sourcesContent":["// import type {} from '@loaders.gl/loader-utils';\n\nimport type {WriterWithEncoder, WriterOptions} from '@loaders.gl/loader-utils';\nimport {GeoJSONTable, BinaryGeometry} from '@loaders.gl/schema';\nimport {encodeGeoArrowSync} from './lib/encode-geoarrow';\n\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\ntype ArrowWriterOptions = WriterOptions & {\n  arrow?: {};\n};\n\n/** Apache Arrow writer */\nexport const GeoArrowWriter: WriterWithEncoder<\n  GeoJSONTable | BinaryGeometry,\n  never,\n  ArrowWriterOptions\n> = {\n  name: 'Apache Arrow',\n  id: 'arrow',\n  module: 'arrow',\n  version: VERSION,\n  extensions: ['arrow', 'feather'],\n  mimeTypes: [\n    'application/vnd.apache.arrow.file',\n    'application/vnd.apache.arrow.stream',\n    'application/octet-stream'\n  ],\n  binary: true,\n  options: {},\n  encode: async function encodeArrow(data, options?): Promise<ArrayBuffer> {\n    // @ts-expect-error\n    return encodeGeoArrowSync(data);\n  },\n  encodeSync(data, options?) {\n    // @ts-expect-error\n    return encodeGeoArrowSync(data);\n  }\n};\n"],"mappings":"SAIQA,kBAAkB;AAI1B,MAAMC,OAAO,GAAG,sBAAkB,KAAK,WAAW,qBAAiB,QAAQ;AAO3E,OAAO,MAAMC,cAIZ,GAAG;EACFC,IAAI,EAAE,cAAc;EACpBC,EAAE,EAAE,OAAO;EACXC,MAAM,EAAE,OAAO;EACfC,OAAO,EAAEL,OAAO;EAChBM,UAAU,EAAE,CAAC,OAAO,EAAE,SAAS,CAAC;EAChCC,SAAS,EAAE,CACT,mCAAmC,EACnC,qCAAqC,EACrC,0BAA0B,CAC3B;EACDC,MAAM,EAAE,IAAI;EACZC,OAAO,EAAE,CAAC,CAAC;EACXC,MAAM,EAAE,eAAeC,WAAWA,CAACC,IAAI,EAAEH,OAAQ,EAAwB;IAEvE,OAAOV,kBAAkB,CAACa,IAAI,CAAC;EACjC,CAAC;EACDC,UAAUA,CAACD,IAAI,EAAEH,OAAQ,EAAE;IAEzB,OAAOV,kBAAkB,CAACa,IAAI,CAAC;EACjC;AACF,CAAC"}

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":["TableBatchBuilder","ArrowTableBatchAggregator","ArrowBatch","getArrowType","VECTOR_TYPES","ArrowLoader","ArrowWorkerLoader","ArrowWriter","GeoArrowLoader","GeoArrowWorkerLoader","serializeArrowSchema","deserializeArrowSchema","serializeArrowMetadata","deserializeArrowMetadata","serializeArrowField","deserializeArrowField","serializeArrowType","deserializeArrowType","getBinaryGeometryTemplate","getBinaryGeometriesFromArrow","getTriangleIndices","getMeanCentersFromBinaryGeometries","updateBoundsFromGeoArrowSamples","parseGeometryFromArrow","convertArrowToGeoJSONTable","hardClone","TriangulationWorker","triangulateOnWorker","parseGeoArrowOnWorker"],"sources":["../src/index.ts"],"sourcesContent":["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {ArrowLoaderOptions} from './arrow-loader';\nimport {TableBatchBuilder} from '@loaders.gl/schema';\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\n// Types\nexport type {ArrowTable, ArrowTableBatch} from './lib/arrow-table';\nexport {VECTOR_TYPES} from './types';\n\n// Arrow loader / Writer\n\nexport type {ArrowLoaderOptions};\nexport {ArrowLoader, ArrowWorkerLoader} from './arrow-loader';\n\nexport {ArrowWriter} from './arrow-writer';\n\n// Geoarrow loader\nexport {GeoArrowLoader, GeoArrowWorkerLoader} from './geoarrow-loader';\n\n// Schema utils\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// EXPERIMENTAL\n\n// Arrow Utils\nexport type {GeoArrowEncoding} from '@loaders.gl/gis';\n// getGeometryColumnsFromArrowTable,\n// getGeoArrowEncoding\n\nexport type {\n  BinaryDataFromGeoArrow,\n  BinaryGeometriesFromArrowOptions\n} from './geoarrow/convert-geoarrow-to-binary-geometry';\nexport {\n  getBinaryGeometryTemplate,\n  getBinaryGeometriesFromArrow,\n  getTriangleIndices,\n  getMeanCentersFromBinaryGeometries\n} from './geoarrow/convert-geoarrow-to-binary-geometry';\n\nexport {updateBoundsFromGeoArrowSamples} from './geoarrow/get-arrow-bounds';\n\nexport {parseGeometryFromArrow} from './geoarrow/convert-geoarrow-to-geojson-geometry';\n\nexport {convertArrowToGeoJSONTable} from './tables/convert-arrow-to-geojson-table';\n\n// EXPERIMENTAL WORKER\nexport {hardClone} from './workers/hard-clone';\n\nexport type {ParseGeoArrowInput, ParseGeoArrowResult} from './triangulate-on-worker';\nexport {\n  TriangulationWorker,\n  triangulateOnWorker,\n  parseGeoArrowOnWorker\n} from './triangulate-on-worker';\n"],"mappings":"AAKA,SAAQA,iBAAiB,QAAO,oBAAoB;AAAC,SAC7CC,yBAAyB;AAGjCD,iBAAiB,CAACE,UAAU,GAAGD,yBAAyB;AAAC,SAIjDE,YAAY;AAAA,SAMZC,YAAY;AAAA,SAKZC,WAAW,EAAEC,iBAAiB;AAAA,SAE9BC,WAAW;AAAA,SAGXC,cAAc,EAAEC,oBAAoB;AAAA,SAI1CC,oBAAoB,EACpBC,sBAAsB,EACtBC,sBAAsB,EACtBC,wBAAwB,EACxBC,mBAAmB,EACnBC,qBAAqB,EACrBC,kBAAkB,EAClBC,oBAAoB;AAAA,SAepBC,yBAAyB,EACzBC,4BAA4B,EAC5BC,kBAAkB,EAClBC,kCAAkC;AAAA,SAG5BC,+BAA+B;AAAA,SAE/BC,sBAAsB;AAAA,SAEtBC,0BAA0B;AAAA,SAG1BC,SAAS;AAAA,SAIfC,mBAAmB,EACnBC,mBAAmB,EACnBC,qBAAqB"}

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

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

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

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

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

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

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"parse-arrow-in-batches.js","names":["arrow","parseArrowInBatches","asyncIterator","options","makeArrowAsyncIterator","readers","RecordBatchReader","readAll","reader","recordBatch","_options$arrow","_options$arrow2","batchDebounceMs","undefined","Promise","resolve","_options$arrow3","setTimeout","arrowTabledBatch","shape","batchType","data","Table","length"],"sources":["../../src/parsers/parse-arrow-in-batches.ts"],"sourcesContent":["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {ArrowTableBatch} from '../lib/arrow-table';\nimport * as arrow from 'apache-arrow';\nimport {ArrowLoaderOptions} from '../arrow-loader';\n// import {isIterable} from '@loaders.gl/core';\n\n/**\n */\nexport function parseArrowInBatches(\n  asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>,\n  options?: ArrowLoaderOptions\n): AsyncIterable<ArrowTableBatch> {\n  // Creates the appropriate arrow.RecordBatchReader subclasses from the input\n  // This will also close the underlying source in case of early termination or errors\n\n  // As an optimization, return a non-async iterator\n  /*\n  if (isIterable(readers)) {\n    function* makeArrowIterator() {\n      for (const reader of readers) {\n        for (const batch of reader) {\n          yield processBatch(batch, reader);\n        }\n        break; // only processing one stream of batches\n      }\n    }\n    const arrowIterator = makeArrowIterator();\n  }\n  */\n\n  async function* makeArrowAsyncIterator(): AsyncIterator<ArrowTableBatch> {\n    // @ts-ignore\n    const readers = arrow.RecordBatchReader.readAll(asyncIterator);\n    for await (const reader of readers) {\n      for await (const recordBatch of reader) {\n        // use options.batchDebounceMs to add a delay between batches if needed (use case: incremental loading)\n        if (options?.arrow?.batchDebounceMs !== undefined && options?.arrow?.batchDebounceMs > 0) {\n          await new Promise((resolve) => setTimeout(resolve, options.arrow?.batchDebounceMs || 0));\n        }\n        const arrowTabledBatch: ArrowTableBatch = {\n          shape: 'arrow-table',\n          batchType: 'data',\n          data: new arrow.Table([recordBatch]),\n          length: recordBatch.data.length\n        };\n        // processBatch(recordBatch);\n        yield arrowTabledBatch;\n      }\n      break; // only processing one stream of batches\n    }\n  }\n\n  return makeArrowAsyncIterator() as any; // as AsyncIterator<ArrowTableBatch>;\n}\n\n// function processBatch(batch: RecordBatch): ArrowTableBatch {\n//   const values = {};\n//   batch.schema.fields.forEach(({name}, index) => {\n//     values[name] = batch.getChildAt(index)?.toArray();\n//   });\n//   return {\n//   };\n// }\n"],"mappings":"AAKA,OAAO,KAAKA,KAAK,MAAM,cAAc;AAMrC,OAAO,SAASC,mBAAmBA,CACjCC,aAAiE,EACjEC,OAA4B,EACI;EAmBhC,gBAAgBC,sBAAsBA,CAAA,EAAmC;IAEvE,MAAMC,OAAO,GAAGL,KAAK,CAACM,iBAAiB,CAACC,OAAO,CAACL,aAAa,CAAC;IAC9D,WAAW,MAAMM,MAAM,IAAIH,OAAO,EAAE;MAClC,WAAW,MAAMI,WAAW,IAAID,MAAM,EAAE;QAAA,IAAAE,cAAA,EAAAC,eAAA;QAEtC,IAAI,CAAAR,OAAO,aAAPA,OAAO,wBAAAO,cAAA,GAAPP,OAAO,CAAEH,KAAK,cAAAU,cAAA,uBAAdA,cAAA,CAAgBE,eAAe,MAAKC,SAAS,IAAI,CAAAV,OAAO,aAAPA,OAAO,wBAAAQ,eAAA,GAAPR,OAAO,CAAEH,KAAK,cAAAW,eAAA,uBAAdA,eAAA,CAAgBC,eAAe,IAAG,CAAC,EAAE;UACxF,MAAM,IAAIE,OAAO,CAAEC,OAAO;YAAA,IAAAC,eAAA;YAAA,OAAKC,UAAU,CAACF,OAAO,EAAE,EAAAC,eAAA,GAAAb,OAAO,CAACH,KAAK,cAAAgB,eAAA,uBAAbA,eAAA,CAAeJ,eAAe,KAAI,CAAC,CAAC;UAAA,EAAC;QAC1F;QACA,MAAMM,gBAAiC,GAAG;UACxCC,KAAK,EAAE,aAAa;UACpBC,SAAS,EAAE,MAAM;UACjBC,IAAI,EAAE,IAAIrB,KAAK,CAACsB,KAAK,CAAC,CAACb,WAAW,CAAC,CAAC;UACpCc,MAAM,EAAEd,WAAW,CAACY,IAAI,CAACE;QAC3B,CAAC;QAED,MAAML,gBAAgB;MACxB;MACA;IACF;EACF;EAEA,OAAOd,sBAAsB,CAAC,CAAC;AACjC"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"parse-arrow-sync.js","names":["convertTable","arrow","convertArrowToColumnarTable","serializeArrowSchema","parseArrowSync","arrayBuffer","options","apacheArrowTable","tableFromIPC","Uint8Array","arrowTable","shape","schema","data","columnarTable","Error"],"sources":["../../src/parsers/parse-arrow-sync.ts"],"sourcesContent":["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {ArrayRowTable, ColumnarTable, ObjectRowTable} from '@loaders.gl/schema';\nimport type {ArrowTable} from '../lib/arrow-table';\nimport {convertTable} from '@loaders.gl/schema';\nimport * as arrow from 'apache-arrow';\nimport {convertArrowToColumnarTable} from '../tables/convert-arrow-to-columnar-table';\nimport {serializeArrowSchema} from '../schema/convert-arrow-schema';\n\n// Parses arrow to a columnar table\nexport function parseArrowSync(\n  arrayBuffer,\n  options?: {shape?: 'arrow-table' | 'columnar-table' | 'object-row-table' | 'array-row-table'}\n): ArrowTable | ColumnarTable | ObjectRowTable | ArrayRowTable {\n  const apacheArrowTable = arrow.tableFromIPC([new Uint8Array(arrayBuffer)]);\n  const arrowTable: ArrowTable = {\n    shape: 'arrow-table',\n    schema: serializeArrowSchema(apacheArrowTable.schema),\n    data: apacheArrowTable\n  };\n\n  const shape = options?.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      let columnarTable = convertArrowToColumnarTable(arrowTable);\n      return convertTable(columnarTable, 'object-row-table');\n\n    case 'array-row-table':\n      columnarTable = convertArrowToColumnarTable(arrowTable);\n      return convertTable(columnarTable, 'array-row-table');\n\n    default:\n      // TODO\n      throw new Error(shape);\n  }\n}\n"],"mappings":"AAMA,SAAQA,YAAY,QAAO,oBAAoB;AAC/C,OAAO,KAAKC,KAAK,MAAM,cAAc;AAAC,SAC9BC,2BAA2B;AAAA,SAC3BC,oBAAoB;AAG5B,OAAO,SAASC,cAAcA,CAC5BC,WAAW,EACXC,OAA6F,EAChC;EAC7D,MAAMC,gBAAgB,GAAGN,KAAK,CAACO,YAAY,CAAC,CAAC,IAAIC,UAAU,CAACJ,WAAW,CAAC,CAAC,CAAC;EAC1E,MAAMK,UAAsB,GAAG;IAC7BC,KAAK,EAAE,aAAa;IACpBC,MAAM,EAAET,oBAAoB,CAACI,gBAAgB,CAACK,MAAM,CAAC;IACrDC,IAAI,EAAEN;EACR,CAAC;EAED,MAAMI,KAAK,GAAG,CAAAL,OAAO,aAAPA,OAAO,uBAAPA,OAAO,CAAEK,KAAK,KAAI,aAAa;EAC7C,QAAQA,KAAK;IACX,KAAK,aAAa;MAChB,OAAOD,UAAU;IAEnB,KAAK,gBAAgB;MACnB,OAAOR,2BAA2B,CAACQ,UAAU,CAAC;IAEhD,KAAK,kBAAkB;MACrB,IAAII,aAAa,GAAGZ,2BAA2B,CAACQ,UAAU,CAAC;MAC3D,OAAOV,YAAY,CAACc,aAAa,EAAE,kBAAkB,CAAC;IAExD,KAAK,iBAAiB;MACpBA,aAAa,GAAGZ,2BAA2B,CAACQ,UAAU,CAAC;MACvD,OAAOV,YAAY,CAACc,aAAa,EAAE,iBAAiB,CAAC;IAEvD;MAEE,MAAM,IAAIC,KAAK,CAACJ,KAAK,CAAC;EAC1B;AACF"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"parse-geoarrow-in-batches.js","names":["parseArrowInBatches","parseGeoArrowInBatches","asyncIterator"],"sources":["../../src/parsers/parse-geoarrow-in-batches.ts"],"sourcesContent":["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {GeoJSONTableBatch} from '@loaders.gl/schema';\nimport type {ArrowTableBatch} from '../lib/arrow-table';\nimport {parseArrowInBatches} from './parse-arrow-in-batches';\n\n/**\n */\nexport function parseGeoArrowInBatches(\n  asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>\n): AsyncIterable<ArrowTableBatch | GeoJSONTableBatch> {\n  // | BinaryGeometry\n  return parseArrowInBatches(asyncIterator);\n}\n"],"mappings":"SAMQA,mBAAmB;AAI3B,OAAO,SAASC,sBAAsBA,CACpCC,aAAiE,EACb;EAEpD,OAAOF,mBAAmB,CAACE,aAAa,CAAC;AAC3C"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"parse-geoarrow-sync.js","names":["parseArrowSync","convertArrowToGeoJSONTable","parseGeoArrowSync","arrayBuffer","options","table","shape"],"sources":["../../src/parsers/parse-geoarrow-sync.ts"],"sourcesContent":["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {GeoJSONTable} from '@loaders.gl/schema';\nimport type {ArrowTable} from '../lib/arrow-table';\nimport {parseArrowSync} from './parse-arrow-sync';\nimport {convertArrowToGeoJSONTable} from '../tables/convert-arrow-to-geojson-table';\n\n// Parses arrow to a columnar table\nexport function parseGeoArrowSync(\n  arrayBuffer,\n  options?: {shape?: 'arrow-table' | 'geojson-table' | 'binary-geometry'}\n): ArrowTable | GeoJSONTable {\n  // | BinaryGeometry\n  const table = parseArrowSync(arrayBuffer, {shape: 'arrow-table'}) as ArrowTable;\n  switch (options?.shape) {\n    case 'geojson-table':\n      return convertArrowToGeoJSONTable(table);\n    default:\n      return table;\n  }\n}\n"],"mappings":"SAMQA,cAAc;AAAA,SACdC,0BAA0B;AAGlC,OAAO,SAASC,iBAAiBA,CAC/BC,WAAW,EACXC,OAAuE,EAC5C;EAE3B,MAAMC,KAAK,GAAGL,cAAc,CAACG,WAAW,EAAE;IAACG,KAAK,EAAE;EAAa,CAAC,CAAe;EAC/E,QAAQF,OAAO,aAAPA,OAAO,uBAAPA,OAAO,CAAEE,KAAK;IACpB,KAAK,eAAe;MAClB,OAAOL,0BAA0B,CAACI,KAAK,CAAC;IAC1C;MACE,OAAOA,KAAK;EAChB;AACF"}

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"convert-arrow-schema.js","names":["arrow","serializeArrowSchema","arrowSchema","fields","map","arrowField","serializeArrowField","metadata","serializeArrowMetadata","deserializeArrowSchema","schema","Schema","field","deserializeArrowField","deserializeArrowMetadata","arrowMetadata","Object","fromEntries","Map","entries","name","type","serializeArrowType","nullable","Field","deserializeArrowType","arrowType","constructor","Null","Binary","Bool","Int","intType","isSigned","bitWidth","Int8","Int16","Int32","Int64","Uint8","Uint16","Uint32","Uint64","Float","precision","Precision","HALF","SINGLE","DOUBLE","Float16","Float32","Float64","Utf8","Decimal","decimal","scale","Date_","dateUnit","unit","DateUnit","DAY","DateDay","DateMillisecond","Time","timeUnit","TimeUnit","SECOND","MILLISECOND","MICROSECOND","NANOSECOND","TimeMillisecond","TimeSecond","TimeMicrosecond","TimeNanosecond","Timestamp","timeStampUnit","TimestampSecond","TimestampMillisecond","TimestampMicrosecond","TimestampNanosecond","Interval","intervalUnit","IntervalUnit","DAY_TIME","YEAR_MONTH","IntervalDayTime","IntervalYearMonth","Map_","mapType","keysSorted","children","List","listType","listField","valueField","FixedSizeList","fixedSizeList","listSize","Struct","structType","Error","dataType","child"],"sources":["../../src/schema/convert-arrow-schema.ts"],"sourcesContent":["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {DataType, Field, Schema, SchemaMetadata} from '@loaders.gl/schema';\nimport * as arrow from 'apache-arrow';\n\n/** Convert Apache Arrow Schema (class instance) to a serialized Schema (plain data) */\nexport function serializeArrowSchema(arrowSchema: arrow.Schema): 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): arrow.Schema {\n  return new arrow.Schema(\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: arrow.Field): 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): arrow.Field {\n  return new arrow.Field(\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: arrow.DataType): DataType {\n  switch (arrowType.constructor) {\n    case arrow.Null:\n      return 'null';\n    case arrow.Binary:\n      return 'binary';\n    case arrow.Bool:\n      return 'bool';\n    case arrow.Int:\n      const intType = arrowType as arrow.Int;\n      return `${intType.isSigned ? 'u' : ''}int${intType.bitWidth}`;\n    case arrow.Int8:\n      return 'int8';\n    case arrow.Int16:\n      return 'int16';\n    case arrow.Int32:\n      return 'int32';\n    case arrow.Int64:\n      return 'int64';\n    case arrow.Uint8:\n      return 'uint8';\n    case arrow.Uint16:\n      return 'uint16';\n    case arrow.Uint32:\n      return 'uint32';\n    case arrow.Uint64:\n      return 'uint64';\n    case arrow.Float:\n      const precision = (arrowType as arrow.Float).precision;\n      // return `float(precision + 1) * 16`;\n      switch (precision) {\n        case arrow.Precision.HALF:\n          return 'float16';\n        case arrow.Precision.SINGLE:\n          return 'float32';\n        case arrow.Precision.DOUBLE:\n          return 'float64';\n        default:\n          return 'float16';\n      }\n    case arrow.Float16:\n      return 'float16';\n    case arrow.Float32:\n      return 'float32';\n    case arrow.Float64:\n      return 'float64';\n    case arrow.Utf8:\n      return 'utf8';\n    case arrow.Decimal:\n      const decimal = arrowType as arrow.Decimal;\n      return {\n        type: 'decimal',\n        bitWidth: decimal.bitWidth,\n        precision: decimal.precision,\n        scale: decimal.scale\n      };\n    case arrow.Date_:\n      const dateUnit = (arrowType as arrow.Date_).unit;\n      return dateUnit === arrow.DateUnit.DAY ? 'date-day' : 'date-millisecond';\n    case arrow.DateDay:\n      return 'date-day';\n    case arrow.DateMillisecond:\n      return 'date-millisecond';\n    case arrow.Time:\n      const timeUnit = (arrowType as arrow.Time).unit;\n      switch (timeUnit) {\n        case arrow.TimeUnit.SECOND:\n          return 'time-second';\n        case arrow.TimeUnit.MILLISECOND:\n          return 'time-millisecond';\n        case arrow.TimeUnit.MICROSECOND:\n          return 'time-microsecond';\n        case arrow.TimeUnit.NANOSECOND:\n          return 'time-nanosecond';\n        default:\n          return 'time-second';\n      }\n    case arrow.TimeMillisecond:\n      return 'time-millisecond';\n    case arrow.TimeSecond:\n      return 'time-second';\n    case arrow.TimeMicrosecond:\n      return 'time-microsecond';\n    case arrow.TimeNanosecond:\n      return 'time-nanosecond';\n    case arrow.Timestamp:\n      const timeStampUnit = (arrowType as arrow.Timestamp).unit;\n      switch (timeStampUnit) {\n        case arrow.TimeUnit.SECOND:\n          return 'timestamp-second';\n        case arrow.TimeUnit.MILLISECOND:\n          return 'timestamp-millisecond';\n        case arrow.TimeUnit.MICROSECOND:\n          return 'timestamp-microsecond';\n        case arrow.TimeUnit.NANOSECOND:\n          return 'timestamp-nanosecond';\n        default:\n          return 'timestamp-second';\n      }\n    case arrow.TimestampSecond:\n      return 'timestamp-second';\n    case arrow.TimestampMillisecond:\n      return 'timestamp-millisecond';\n    case arrow.TimestampMicrosecond:\n      return 'timestamp-microsecond';\n    case arrow.TimestampNanosecond:\n      return 'timestamp-nanosecond';\n    case arrow.Interval:\n      const intervalUnit = (arrowType as arrow.Interval).unit;\n      switch (intervalUnit) {\n        case arrow.IntervalUnit.DAY_TIME:\n          return 'interval-daytime';\n        case arrow.IntervalUnit.YEAR_MONTH:\n          return 'interval-yearmonth';\n        default:\n          return 'interval-daytime';\n      }\n    case arrow.IntervalDayTime:\n      return 'interval-daytime';\n    case arrow.IntervalYearMonth:\n      return 'interval-yearmonth';\n    case arrow.Map_:\n      const mapType = arrowType as arrow.Map_;\n      return {\n        type: 'map',\n        keysSorted: mapType.keysSorted,\n        children: mapType.children.map((arrowField) => serializeArrowField(arrowField))\n      };\n    case arrow.List:\n      const listType = arrowType as arrow.List;\n      const listField = listType.valueField;\n      return {\n        type: 'list',\n        children: [serializeArrowField(listField)]\n      };\n    case arrow.FixedSizeList:\n      const fixedSizeList = arrowType as arrow.FixedSizeList;\n      return {\n        type: 'fixed-size-list',\n        listSize: fixedSizeList.listSize,\n        children: [serializeArrowField(fixedSizeList.children[0])]\n      };\n    case arrow.Struct:\n      const structType = arrowType as arrow.Struct;\n      return {\n        type: 'struct',\n        children: structType.children.map((arrowField) => serializeArrowField(arrowField))\n      };\n    default:\n      throw new Error(`arrow type not supported: ${arrowType.constructor.name}`);\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): arrow.DataType {\n  if (typeof dataType === 'object') {\n    switch (dataType.type) {\n      case 'decimal':\n        return new arrow.Decimal(dataType.precision, dataType.scale, dataType.bitWidth);\n      case 'map':\n        let children = dataType.children.map((arrowField) => deserializeArrowField(arrowField));\n        return new arrow.Map_(children as any, dataType.keysSorted);\n      case 'list':\n        const field = deserializeArrowField(dataType.children[0]);\n        return new arrow.List(field);\n      case 'fixed-size-list':\n        const child = deserializeArrowField(dataType.children[0]);\n        return new arrow.FixedSizeList(dataType.listSize, child);\n      case 'struct':\n        children = dataType.children.map((arrowField) => deserializeArrowField(arrowField));\n        return new arrow.Struct(children);\n      default:\n        throw new Error('array type not supported');\n    }\n  }\n\n  switch (dataType) {\n    case 'null':\n      return new arrow.Null();\n    case 'binary':\n      return new arrow.Binary();\n    case 'bool':\n      return new arrow.Bool();\n    case 'int8':\n      return new arrow.Int8();\n    case 'int16':\n      return new arrow.Int16();\n    case 'int32':\n      return new arrow.Int32();\n    case 'int64':\n      return new arrow.Int64();\n    case 'uint8':\n      return new arrow.Uint8();\n    case 'uint16':\n      return new arrow.Uint16();\n    case 'uint32':\n      return new arrow.Uint32();\n    case 'uint64':\n      return new arrow.Uint64();\n    case 'float16':\n      return new arrow.Float16();\n    case 'float32':\n      return new arrow.Float32();\n    case 'float64':\n      return new arrow.Float64();\n    case 'utf8':\n      return new arrow.Utf8();\n    case 'date-day':\n      return new arrow.DateDay();\n    case 'date-millisecond':\n      return new arrow.DateMillisecond();\n    case 'time-second':\n      return new arrow.TimeSecond();\n    case 'time-millisecond':\n      return new arrow.TimeMillisecond();\n    case 'time-microsecond':\n      return new arrow.TimeMicrosecond();\n    case 'time-nanosecond':\n      return new arrow.TimeNanosecond();\n    case 'timestamp-second':\n      return new arrow.TimestampSecond();\n    case 'timestamp-millisecond':\n      return new arrow.TimestampMillisecond();\n    case 'timestamp-microsecond':\n      return new arrow.TimestampMicrosecond();\n    case 'timestamp-nanosecond':\n      return new arrow.TimestampNanosecond();\n    case 'interval-daytime':\n      return new arrow.IntervalDayTime();\n    case 'interval-yearmonth':\n      return new arrow.IntervalYearMonth();\n    default:\n      throw new Error('array type not supported');\n  }\n}\n"],"mappings":"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"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"convert-arrow-to-columnar-table.js","names":["convertArrowToColumnarTable","table","arrowTable","data","columnarTable","field","schema","fields","arrowColumn","getChild","name","values","toArray","shape"],"sources":["../../src/tables/convert-arrow-to-columnar-table.ts"],"sourcesContent":["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {ColumnarTable} from '@loaders.gl/schema';\nimport type {ArrowTable} from '../lib/arrow-table';\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    schema: table.schema,\n    data: columnarTable\n  };\n}\n"],"mappings":"AAWA,OAAO,SAASA,2BAA2BA,CAACC,KAAiB,EAAiB;EAI5E,MAAMC,UAAU,GAAGD,KAAK,CAACE,IAAI;EAC7B,MAAMC,aAAa,GAAG,CAAC,CAAC;EAExB,KAAK,MAAMC,KAAK,IAAIH,UAAU,CAACI,MAAM,CAACC,MAAM,EAAE;IAE5C,MAAMC,WAAW,GAAGN,UAAU,CAACO,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;IACLE,KAAK,EAAE,gBAAgB;IACvBP,MAAM,EAAEL,KAAK,CAACK,MAAM;IACpBH,IAAI,EAAEC;EACR,CAAC;AACH"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"convert-arrow-to-geojson-table.js","names":["serializeArrowSchema","parseGeometryFromArrow","getGeometryColumnsFromSchema","convertApacheArrowToArrowTable","arrowTable","shape","schema","data","convertArrowToGeoJSONTable","table","geometryColumns","encoding","geometry","features","propertyColumnNames","fields","map","field","name","filter","propertiesTable","select","arrowGeometryColumn","getChild","row","numRows","arrowGeometry","get","feature","_propertiesTable$get","properties","toJSON","push","type"],"sources":["../../src/tables/convert-arrow-to-geojson-table.ts"],"sourcesContent":["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {Feature, GeoJSONTable} from '@loaders.gl/schema';\nimport * as arrow from 'apache-arrow';\nimport type {ArrowTable} from '../lib/arrow-table';\nimport {serializeArrowSchema, parseGeometryFromArrow} from '@loaders.gl/arrow';\nimport {getGeometryColumnsFromSchema} from '@loaders.gl/gis';\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: arrow.Table): ArrowTable {\n  return {\n    shape: 'arrow-table',\n    schema: serializeArrowSchema(arrowTable.schema),\n    data: arrowTable\n  };\n}\n\n/**\n * Convert an Apache Arrow table to a GeoJSONTable\n * @note Currently does not convert schema\n */\nexport function convertArrowToGeoJSONTable(table: ArrowTable): GeoJSONTable {\n  const arrowTable = table.data;\n  const schema = serializeArrowSchema(arrowTable.schema);\n  const geometryColumns = getGeometryColumnsFromSchema(schema);\n\n  // get encoding from geometryColumns['geometry']\n  const encoding = geometryColumns.geometry.encoding;\n\n  const features: Feature[] = [];\n\n  // Remove geometry columns\n  const propertyColumnNames = arrowTable.schema.fields\n    .map((field) => field.name)\n    // TODO - this deletes all geometry columns\n    .filter((name) => !(name in geometryColumns));\n  const propertiesTable = arrowTable.select(propertyColumnNames);\n\n  const arrowGeometryColumn = arrowTable.getChild('geometry');\n\n  for (let row = 0; row < arrowTable.numRows; row++) {\n    // get the geometry value from arrow geometry column\n    // Note that type can vary\n    const arrowGeometry = arrowGeometryColumn?.get(row);\n    // parse arrow geometry to geojson feature\n    const feature = parseGeometryFromArrow(arrowGeometry, encoding);\n    if (feature) {\n      const properties = propertiesTable.get(row)?.toJSON() || {};\n      features.push({type: 'Feature', geometry: feature, properties});\n    }\n  }\n\n  return {\n    shape: 'geojson-table',\n    type: 'FeatureCollection',\n    schema: table.schema,\n    features\n  };\n}\n"],"mappings":"AAOA,SAAQA,oBAAoB,EAAEC,sBAAsB,QAAO,mBAAmB;AAC9E,SAAQC,4BAA4B,QAAO,iBAAiB;AAQ5D,OAAO,SAASC,8BAA8BA,CAACC,UAAuB,EAAc;EAClF,OAAO;IACLC,KAAK,EAAE,aAAa;IACpBC,MAAM,EAAEN,oBAAoB,CAACI,UAAU,CAACE,MAAM,CAAC;IAC/CC,IAAI,EAAEH;EACR,CAAC;AACH;AAMA,OAAO,SAASI,0BAA0BA,CAACC,KAAiB,EAAgB;EAC1E,MAAML,UAAU,GAAGK,KAAK,CAACF,IAAI;EAC7B,MAAMD,MAAM,GAAGN,oBAAoB,CAACI,UAAU,CAACE,MAAM,CAAC;EACtD,MAAMI,eAAe,GAAGR,4BAA4B,CAACI,MAAM,CAAC;EAG5D,MAAMK,QAAQ,GAAGD,eAAe,CAACE,QAAQ,CAACD,QAAQ;EAElD,MAAME,QAAmB,GAAG,EAAE;EAG9B,MAAMC,mBAAmB,GAAGV,UAAU,CAACE,MAAM,CAACS,MAAM,CACjDC,GAAG,CAAEC,KAAK,IAAKA,KAAK,CAACC,IAAI,CAAC,CAE1BC,MAAM,CAAED,IAAI,IAAK,EAAEA,IAAI,IAAIR,eAAe,CAAC,CAAC;EAC/C,MAAMU,eAAe,GAAGhB,UAAU,CAACiB,MAAM,CAACP,mBAAmB,CAAC;EAE9D,MAAMQ,mBAAmB,GAAGlB,UAAU,CAACmB,QAAQ,CAAC,UAAU,CAAC;EAE3D,KAAK,IAAIC,GAAG,GAAG,CAAC,EAAEA,GAAG,GAAGpB,UAAU,CAACqB,OAAO,EAAED,GAAG,EAAE,EAAE;IAGjD,MAAME,aAAa,GAAGJ,mBAAmB,aAAnBA,mBAAmB,uBAAnBA,mBAAmB,CAAEK,GAAG,CAACH,GAAG,CAAC;IAEnD,MAAMI,OAAO,GAAG3B,sBAAsB,CAACyB,aAAa,EAAEf,QAAQ,CAAC;IAC/D,IAAIiB,OAAO,EAAE;MAAA,IAAAC,oBAAA;MACX,MAAMC,UAAU,GAAG,EAAAD,oBAAA,GAAAT,eAAe,CAACO,GAAG,CAACH,GAAG,CAAC,cAAAK,oBAAA,uBAAxBA,oBAAA,CAA0BE,MAAM,CAAC,CAAC,KAAI,CAAC,CAAC;MAC3DlB,QAAQ,CAACmB,IAAI,CAAC;QAACC,IAAI,EAAE,SAAS;QAAErB,QAAQ,EAAEgB,OAAO;QAAEE;MAAU,CAAC,CAAC;IACjE;EACF;EAEA,OAAO;IACLzB,KAAK,EAAE,eAAe;IACtB4B,IAAI,EAAE,mBAAmB;IACzB3B,MAAM,EAAEG,KAAK,CAACH,MAAM;IACpBO;EACF,CAAC;AACH"}

package/dist/tables/convert-columnar-to-row-table.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"convert-columnar-to-row-table.js","names":["convertColumnarToRowFormatTable","columnarTable","tableKeys","Object","keys","tableRowsCount","length","rowFormatTable","index","tableItem","keyIndex","fieldName","push","shape","schema","data"],"sources":["../../src/tables/convert-columnar-to-row-table.ts"],"sourcesContent":["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {ColumnarTable, ObjectRowTable} from '@loaders.gl/schema';\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    schema: columnarTable.schema,\n    data: rowFormatTable\n  };\n}\n"],"mappings":"AAUA,OAAO,SAASA,+BAA+BA,CAACC,aAA4B,EAAkB;EAC5F,MAAMC,SAAS,GAAGC,MAAM,CAACC,IAAI,CAACH,aAAa,CAAC;EAC5C,MAAMI,cAAc,GAAGJ,aAAa,CAACC,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,GAAGV,aAAa,CAACU,SAAS,CAAC,CAACH,KAAK,CAAC;IACxD;IACAD,cAAc,CAACK,IAAI,CAACH,SAAS,CAAC;EAChC;EAEA,OAAO;IACLI,KAAK,EAAE,kBAAkB;IACzBC,MAAM,EAAEb,aAAa,CAACa,MAAM;IAC5BC,IAAI,EAAER;EACR,CAAC;AACH"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"convert-table-to-arrow.js","names":[],"sources":["../../src/tables/convert-table-to-arrow.ts"],"sourcesContent":["// loaders.gl\n// SPDX-License-Identifier: MIT\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/triangulate-on-worker.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"triangulate-on-worker.js","names":["processOnWorker","VERSION","TriangulationWorker","id","name","module","version","options","triangulateOnWorker","data","arguments","length","undefined","operation","parseGeoArrowOnWorker"],"sources":["../src/triangulate-on-worker.ts"],"sourcesContent":["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport * as arrow from 'apache-arrow';\nimport type {WorkerOptions} from '@loaders.gl/worker-utils';\nimport {processOnWorker} from '@loaders.gl/worker-utils';\nimport {BinaryDataFromGeoArrow, GeoArrowEncoding} from '@loaders.gl/arrow';\n\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\nexport type TriangulationWorkerInput =\n  | ({operation: 'triangulate'} & TriangulateInput)\n  | ParseGeoArrowInput\n  | {operation: 'test'; data: any};\n\nexport type TriangulationWorkerOutput =\n  | ({operation: 'triangulate'} & TriangulateResult)\n  | ({operation: 'parse-geoarrow'} & ParseGeoArrowResult)\n  | {operation: 'test'; data: any};\n\ntype GeoArrowChunkData = {\n  type: arrow.DataType;\n  offset: number;\n  length: number;\n  nullCount: number;\n  buffers: any;\n  children: arrow.Data[];\n  dictionary?: arrow.Vector;\n};\n\nexport type ParseGeoArrowInput = {\n  operation: 'parse-geoarrow';\n  chunkData: GeoArrowChunkData;\n  chunkIndex: number;\n  chunkOffset: number;\n  geometryEncoding: GeoArrowEncoding;\n  calculateMeanCenters: boolean;\n  triangle: boolean;\n};\n\nexport type ParseGeoArrowResult = {\n  chunkIndex: number;\n  binaryDataFromGeoArrow: BinaryDataFromGeoArrow | null;\n};\n\n/** Input data for operation: 'triangulate' */\nexport type TriangulateInput = {\n  polygonIndices: Uint16Array;\n  primitivePolygonIndices: Int32Array;\n  flatCoordinateArray: Float64Array;\n  nDim: number;\n};\n\n/** Result type for operation: 'triangulate' */\nexport type TriangulateResult = TriangulateInput & {\n  triangleIndices?: Uint32Array;\n};\n\n/**\n * Worker for tessellating geometries. Normally called through triangulateOnWorker\n */\nexport const TriangulationWorker = {\n  id: 'triangulation',\n  name: 'Triangulate',\n  module: 'arrow',\n  version: VERSION,\n  options: {}\n};\n\n/**\n * Triangulate a set of polygons on worker, type safe API\n */\nexport function triangulateOnWorker(\n  data: TriangulateInput,\n  options: WorkerOptions = {}\n): Promise<TriangulateResult> {\n  return processOnWorker(TriangulationWorker, {...data, operation: 'triangulate'}, options);\n}\n\n/**\n * Parse GeoArrow geometry colum on worker, type safe API\n */\nexport function parseGeoArrowOnWorker(\n  data: ParseGeoArrowInput,\n  options: WorkerOptions = {}\n): Promise<ParseGeoArrowResult> {\n  return processOnWorker(TriangulationWorker, {...data, operation: 'parse-geoarrow'}, options);\n}\n"],"mappings":"AAMA,SAAQA,eAAe,QAAO,0BAA0B;AAKxD,MAAMC,OAAO,GAAG,sBAAkB,KAAK,WAAW,qBAAiB,QAAQ;AAqD3E,OAAO,MAAMC,mBAAmB,GAAG;EACjCC,EAAE,EAAE,eAAe;EACnBC,IAAI,EAAE,aAAa;EACnBC,MAAM,EAAE,OAAO;EACfC,OAAO,EAAEL,OAAO;EAChBM,OAAO,EAAE,CAAC;AACZ,CAAC;AAKD,OAAO,SAASC,mBAAmBA,CACjCC,IAAsB,EAEM;EAAA,IAD5BF,OAAsB,GAAAG,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,CAAC,CAAC;EAE3B,OAAOV,eAAe,CAACE,mBAAmB,EAAE;IAAC,GAAGO,IAAI;IAAEI,SAAS,EAAE;EAAa,CAAC,EAAEN,OAAO,CAAC;AAC3F;AAKA,OAAO,SAASO,qBAAqBA,CACnCL,IAAwB,EAEM;EAAA,IAD9BF,OAAsB,GAAAG,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,CAAC,CAAC;EAE3B,OAAOV,eAAe,CAACE,mBAAmB,EAAE;IAAC,GAAGO,IAAI;IAAEI,SAAS,EAAE;EAAgB,CAAC,EAAEN,OAAO,CAAC;AAC9F"}

package/dist/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","names":["VECTOR_TYPES"],"sources":["../src/types.ts"],"sourcesContent":["// loaders.gl\n// SPDX-License-Identifier: MIT\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":"AAYA,WAAYA,YAAY,aAAZA,YAAY;EAAZA,YAAY,CAAZA,YAAY;EAAZA,YAAY,CAAZA,YAAY;EAAA,OAAZA,YAAY;AAAA"}

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

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

package/dist/workers/hard-clone.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"hard-clone.js","names":["arrow","hardClone","data","force","arguments","length","undefined","Vector","map","clonedChildren","childData","children","push","clonedDictionary","dictionary","clonedBuffers","BufferType","OFFSET","cloneBuffer","buffers","DATA","VALIDITY","TYPE","Data","type","offset","_nullCount","isShared","some","bufferTypes","bufferType","isTypedArraySliced","arr","byteOffset","byteLength","buffer","slice"],"sources":["../../src/workers/hard-clone.ts"],"sourcesContent":["import * as arrow from 'apache-arrow';\nimport type {Buffers} from 'apache-arrow/data';\n\ntype TypedArray =\n  | Uint8Array\n  | Uint8ClampedArray\n  | Uint16Array\n  | Uint32Array\n  | Int8Array\n  | Int16Array\n  | Int32Array\n  | Float32Array\n  | Float64Array;\n\n/**\n * Clone an Arrow JS Data or Vector, detaching from an existing ArrayBuffer if\n * it is shared with other.\n *\n * The purpose of this function is to enable transferring a `Data` instance,\n * e.g. to a web worker, without neutering any other data.\n *\n * Any internal buffers that are a slice of a larger `ArrayBuffer` (i.e. where\n * the typed array's `byteOffset` is not `0` and where its `byteLength` does not\n * match its `array.buffer.byteLength`) are copied into new `ArrayBuffers`.\n *\n * If `force` is `true`, always clone internal buffers, even if not shared. If\n * the default, `false`, any internal buffers that are **not** a slice of a\n * larger `ArrayBuffer` will not be copied.\n */\nexport function hardClone<T extends arrow.DataType>(\n  input: arrow.Data<T>,\n  force?: boolean\n): arrow.Data<T>;\nexport function hardClone<T extends arrow.DataType>(\n  input: arrow.Vector<T>,\n  force?: boolean\n): arrow.Vector<T>;\n\nexport function hardClone<T extends arrow.DataType>(\n  data: arrow.Data<T> | arrow.Vector<T>,\n  force: boolean = false\n): arrow.Data<T> | arrow.Vector<T> {\n  // Check if `data` is an arrow.Vector\n  if ('data' in data) {\n    return new arrow.Vector(data.data.map((data) => hardClone(data, force)));\n  }\n\n  // Clone each of the children, recursively\n  const clonedChildren: arrow.Data[] = [];\n  for (const childData of data.children) {\n    clonedChildren.push(hardClone(childData, force));\n  }\n\n  // Clone the dictionary if there is one\n  let clonedDictionary: arrow.Vector | undefined;\n  if (data.dictionary !== undefined) {\n    clonedDictionary = hardClone(data.dictionary, force);\n  }\n\n  // Buffers can have up to four entries. Each of these can be `undefined` for\n  // one or more array types.\n  //\n  // - OFFSET: value offsets for variable size list types\n  // - DATA: the underlying data\n  // - VALIDITY: the null buffer. This may be empty or undefined if all elements\n  //   are non-null/valid.\n  // - TYPE: type ids for a union type.\n  const clonedBuffers: Buffers<T> = {\n    [arrow.BufferType.OFFSET]: cloneBuffer(data.buffers[arrow.BufferType.OFFSET], force),\n    [arrow.BufferType.DATA]: cloneBuffer(data.buffers[arrow.BufferType.DATA], force),\n    [arrow.BufferType.VALIDITY]: cloneBuffer(data.buffers[arrow.BufferType.VALIDITY], force),\n    [arrow.BufferType.TYPE]: cloneBuffer(data.buffers[arrow.BufferType.TYPE], force)\n  };\n\n  // Note: the data.offset is passed on so that a sliced Data instance will not\n  // be \"un-sliced\". However keep in mind that this means we're cloning the\n  // _original backing buffer_, not only the portion of the Data that was\n  // sliced.\n  return new arrow.Data(\n    data.type,\n    data.offset,\n    data.length,\n    // @ts-expect-error _nullCount is protected. We're using it here to mimic\n    // `Data.clone`\n    data._nullCount,\n    clonedBuffers,\n    clonedChildren,\n    clonedDictionary\n  );\n}\n\n/**\n * Test whether an arrow.Data instance is a slice of a larger `ArrayBuffer`.\n */\nexport function isShared<T extends arrow.DataType>(data: arrow.Data<T> | arrow.Vector<T>): boolean {\n  // Loop over arrow.Vector\n  if ('data' in data) {\n    return data.data.some((data) => isShared(data));\n  }\n\n  // Check child data\n  for (const childData of data.children) {\n    if (isShared(childData)) {\n      return true;\n    }\n  }\n\n  // Check dictionary\n  if (data.dictionary !== undefined) {\n    if (isShared(data.dictionary)) {\n      return true;\n    }\n  }\n\n  const bufferTypes = [\n    arrow.BufferType.OFFSET,\n    arrow.BufferType.DATA,\n    arrow.BufferType.VALIDITY,\n    arrow.BufferType.TYPE\n  ];\n  for (const bufferType of bufferTypes) {\n    if (data.buffers[bufferType] !== undefined && isTypedArraySliced(data.buffers[bufferType])) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\n/**\n * Returns true if the current typed array is a partial slice on a larger\n * ArrayBuffer\n */\nfunction isTypedArraySliced(arr: TypedArray): boolean {\n  return !(arr.byteOffset === 0 && arr.byteLength === arr.buffer.byteLength);\n}\n\n/**\n * If a slice of a larger ArrayBuffer, clone to a fresh `ArrayBuffer`.\n *\n * If `force` is `true`, always clone the array, even if not shared.\n */\nfunction cloneBuffer<A extends TypedArray | undefined>(arr: A, force: boolean): A {\n  // Not all buffer types are defined for every type of Arrow array. E.g.\n  // `arrow.BufferType.TYPE` is only defined for the Union type.\n  if (arr === undefined) {\n    return arr;\n  }\n\n  // The current array is not a part of a larger ArrayBuffer, don't clone it\n  if (!force && !isTypedArraySliced(arr)) {\n    return arr;\n  }\n\n  // Note: TypedArray.slice() **copies** into a new ArrayBuffer\n\n  // @ts-expect-error 'Uint8Array' is assignable to the constraint of type 'A',\n  // but 'A' could be instantiated with a different subtype of constraint\n  // 'TypedArray'\n  // We know from arr.slice that it will always return the same\n  return arr.slice();\n}\n"],"mappings":"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"}

package/dist/workers/triangulation-worker-node.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"triangulation-worker-node.js","names":[],"sources":["../../src/workers/triangulation-worker-node.ts"],"sourcesContent":["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport './triangulation-worker';\n"],"mappings":""}

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

@@ -1 +0,0 @@
-{"version":3,"file":"triangulation-worker.js","names":["arrow","createWorker","getTriangleIndices","getBinaryGeometriesFromArrow","data","options","arguments","length","undefined","input","operation","triangulateBatch","parseGeoArrowBatch","Error","triangleIndices","polygonIndices","primitivePolygonIndices","flatCoordinateArray","nDim","binaryDataFromGeoArrow","chunkData","chunkIndex","chunkOffset","geometryEncoding","calculateMeanCenters","triangle","arrowData","Data","type","offset","nullCount","buffers","children","dictionary","geometryColumn","makeVector"],"sources":["../../src/workers/triangulation-worker.ts"],"sourcesContent":["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport * as arrow from 'apache-arrow';\nimport {createWorker} from '@loaders.gl/worker-utils';\nimport {\n  getTriangleIndices,\n  getBinaryGeometriesFromArrow,\n  BinaryDataFromGeoArrow\n} from '../geoarrow/convert-geoarrow-to-binary-geometry';\nimport type {\n  TriangulationWorkerInput,\n  TriangulateInput,\n  TriangulateResult,\n  ParseGeoArrowInput,\n  ParseGeoArrowResult\n} from '../triangulate-on-worker';\n\ncreateWorker(async (data, options = {}) => {\n  const input = data as TriangulationWorkerInput;\n  const operation = input?.operation;\n  switch (operation) {\n    case 'test':\n      return input;\n    case 'triangulate':\n      return triangulateBatch(data);\n    case 'parse-geoarrow':\n      return parseGeoArrowBatch(data);\n    default:\n      throw new Error(\n        `TriangulationWorker: Unsupported operation ${operation}. Expected 'triangulate'`\n      );\n  }\n});\n\nfunction triangulateBatch(data: TriangulateInput): TriangulateResult {\n  // Parse any WKT/WKB geometries\n  // Build binary geometries\n  // Call earcut and triangulate\n  const triangleIndices = getTriangleIndices(\n    data.polygonIndices,\n    data.primitivePolygonIndices,\n    data.flatCoordinateArray,\n    data.nDim\n  );\n  return {...data, ...(triangleIndices ? {triangleIndices} : {})};\n}\n\n/**\n * Reading the arrow file into memory is very fast. Parsing the geoarrow column is slow, and blocking the main thread.\n * To address this issue, we can move the parsing job from main thread to parallel web workers.\n * Each web worker will parse one chunk/batch of geoarrow column, and return binary geometries to main thread.\n * The app on the main thread will render the binary geometries and the parsing will not block the main thread.\n *\n * @param data\n * @returns\n */\nfunction parseGeoArrowBatch(data: ParseGeoArrowInput): ParseGeoArrowResult {\n  let binaryDataFromGeoArrow: BinaryDataFromGeoArrow | null = null;\n  const {chunkData, chunkIndex, chunkOffset, geometryEncoding, calculateMeanCenters, triangle} =\n    data;\n  // rebuild chunkData that is only for geoarrow column\n  const arrowData = new arrow.Data(\n    chunkData.type,\n    chunkData.offset,\n    chunkData.length,\n    chunkData.nullCount,\n    chunkData.buffers,\n    chunkData.children,\n    chunkData.dictionary\n  );\n  // rebuild geometry column with chunkData\n  const geometryColumn = arrow.makeVector(arrowData);\n  if (geometryColumn) {\n    // NOTE: for a rebuild arrow.Vector, there is only one chunk, so chunkIndex is always 0\n    const options = {calculateMeanCenters, triangle, chunkIndex: 0, chunkOffset};\n    binaryDataFromGeoArrow = getBinaryGeometriesFromArrow(\n      geometryColumn,\n      geometryEncoding,\n      options\n    );\n    // NOTE: here binaryGeometry will be copied to main thread\n    return {\n      binaryDataFromGeoArrow,\n      chunkIndex\n    };\n  }\n  return {\n    binaryDataFromGeoArrow,\n    chunkIndex\n  };\n}\n"],"mappings":"AAIA,OAAO,KAAKA,KAAK,MAAM,cAAc;AACrC,SAAQC,YAAY,QAAO,0BAA0B;AAAC,SAEpDC,kBAAkB,EAClBC,4BAA4B;AAW9BF,YAAY,CAAC,gBAAOG,IAAI,EAAmB;EAAA,IAAjBC,OAAO,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,CAAC,CAAC;EACpC,MAAMG,KAAK,GAAGL,IAAgC;EAC9C,MAAMM,SAAS,GAAGD,KAAK,aAALA,KAAK,uBAALA,KAAK,CAAEC,SAAS;EAClC,QAAQA,SAAS;IACf,KAAK,MAAM;MACT,OAAOD,KAAK;IACd,KAAK,aAAa;MAChB,OAAOE,gBAAgB,CAACP,IAAI,CAAC;IAC/B,KAAK,gBAAgB;MACnB,OAAOQ,kBAAkB,CAACR,IAAI,CAAC;IACjC;MACE,MAAM,IAAIS,KAAK,CACZ,8CAA6CH,SAAU,0BAC1D,CAAC;EACL;AACF,CAAC,CAAC;AAEF,SAASC,gBAAgBA,CAACP,IAAsB,EAAqB;EAInE,MAAMU,eAAe,GAAGZ,kBAAkB,CACxCE,IAAI,CAACW,cAAc,EACnBX,IAAI,CAACY,uBAAuB,EAC5BZ,IAAI,CAACa,mBAAmB,EACxBb,IAAI,CAACc,IACP,CAAC;EACD,OAAO;IAAC,GAAGd,IAAI;IAAE,IAAIU,eAAe,GAAG;MAACA;IAAe,CAAC,GAAG,CAAC,CAAC;EAAC,CAAC;AACjE;AAWA,SAASF,kBAAkBA,CAACR,IAAwB,EAAuB;EACzE,IAAIe,sBAAqD,GAAG,IAAI;EAChE,MAAM;IAACC,SAAS;IAAEC,UAAU;IAAEC,WAAW;IAAEC,gBAAgB;IAAEC,oBAAoB;IAAEC;EAAQ,CAAC,GAC1FrB,IAAI;EAEN,MAAMsB,SAAS,GAAG,IAAI1B,KAAK,CAAC2B,IAAI,CAC9BP,SAAS,CAACQ,IAAI,EACdR,SAAS,CAACS,MAAM,EAChBT,SAAS,CAACb,MAAM,EAChBa,SAAS,CAACU,SAAS,EACnBV,SAAS,CAACW,OAAO,EACjBX,SAAS,CAACY,QAAQ,EAClBZ,SAAS,CAACa,UACZ,CAAC;EAED,MAAMC,cAAc,GAAGlC,KAAK,CAACmC,UAAU,CAACT,SAAS,CAAC;EAClD,IAAIQ,cAAc,EAAE;IAElB,MAAM7B,OAAO,GAAG;MAACmB,oBAAoB;MAAEC,QAAQ;MAAEJ,UAAU,EAAE,CAAC;MAAEC;IAAW,CAAC;IAC5EH,sBAAsB,GAAGhB,4BAA4B,CACnD+B,cAAc,EACdX,gBAAgB,EAChBlB,OACF,CAAC;IAED,OAAO;MACLc,sBAAsB;MACtBE;IACF,CAAC;EACH;EACA,OAAO;IACLF,sBAAsB;IACtBE;EACF,CAAC;AACH"}