@loaders.gl/arrow 4.0.4 → 4.1.0-alpha.2

package/src/geoarrow/{convert-geoarrow-to-geojson.ts → convert-geoarrow-to-geojson-geometry.ts}

@@ -1,81 +1,95 @@
 // loaders.gl, MIT license
 // Copyright (c) vis.gl contributors
 
-import * as arrow from 'apache-arrow';
+// import * as arrow from 'apache-arrow';
 import {
-  Feature,
   MultiPolygon,
   Position,
   Polygon,
   MultiPoint,
   Point,
   MultiLineString,
-  LineString
+  LineString,
+  Geometry,
+  BinaryGeometry
 } from '@loaders.gl/schema';
-import type {GeoArrowEncoding} from '@loaders.gl/gis';
-
-type RawArrowFeature = {
-  data: arrow.Vector;
-  encoding?: GeoArrowEncoding;
-};
+import {binaryToGeometry, type GeoArrowEncoding} from '@loaders.gl/gis';
+import {WKBLoader, WKTLoader} from '@loaders.gl/wkt';
 
 /**
  * parse geometry from arrow data that is returned from processArrowData()
- * NOTE: this function could be duplicated with the binaryToFeature() in deck.gl,
- * it is currently only used for picking because currently deck.gl returns only the index of the feature
- * So the following functions could be deprecated once deck.gl returns the feature directly for binary geojson layer
+ * NOTE: this function could be deduplicated with the binaryToFeature() in deck.gl,
+ * it is currently used for deck.gl picking because currently deck.gl returns only the index of the feature
  *
- * @param rawData the raw geometry data returned from processArrowData, which is an object with two properties: encoding and data
- * @see processArrowData
+ * @param data data extraced from arrow vector representing a geometry
+ * @param encoding the geoarrow encoding of the geometry column
  * @returns Feature or null
  */
-export function parseGeometryFromArrow(rawData: RawArrowFeature): Feature | null {
-  const encoding = rawData.encoding?.toLowerCase() as typeof rawData.encoding;
-  const data = rawData.data;
-  if (!encoding || !data) {
+export function parseGeometryFromArrow(
+  arrowCellValue: any,
+  encoding?: GeoArrowEncoding
+): Geometry | null {
+  // sanity
+  encoding = encoding?.toLowerCase() as GeoArrowEncoding;
+  if (!encoding || !arrowCellValue) {
     return null;
   }
 
-  let geometry;
+  let geometry: Geometry;
 
   switch (encoding) {
     case 'geoarrow.multipolygon':
-      geometry = arrowMultiPolygonToFeature(data);
+      geometry = arrowMultiPolygonToFeature(arrowCellValue);
       break;
     case 'geoarrow.polygon':
-      geometry = arrowPolygonToFeature(data);
+      geometry = arrowPolygonToFeature(arrowCellValue);
       break;
     case 'geoarrow.multipoint':
-      geometry = arrowMultiPointToFeature(data);
+      geometry = arrowMultiPointToFeature(arrowCellValue);
       break;
     case 'geoarrow.point':
-      geometry = arrowPointToFeature(data);
+      geometry = arrowPointToFeature(arrowCellValue);
       break;
     case 'geoarrow.multilinestring':
-      geometry = arrowMultiLineStringToFeature(data);
+      geometry = arrowMultiLineStringToFeature(arrowCellValue);
       break;
     case 'geoarrow.linestring':
-      geometry = arrowLineStringToFeature(data);
+      geometry = arrowLineStringToFeature(arrowCellValue);
       break;
     case 'geoarrow.wkb':
-      throw Error(`GeoArrow encoding not supported ${encoding}`);
+      geometry = arrowWKBToFeature(arrowCellValue);
+      break;
     case 'geoarrow.wkt':
-      throw Error(`GeoArrow encoding not supported ${encoding}`);
+      geometry = arrowWKTToFeature(arrowCellValue);
+      break;
     default: {
       throw Error(`GeoArrow encoding not supported ${encoding}`);
     }
   }
-  return {
-    type: 'Feature',
-    geometry,
-    properties: {}
-  };
+
+  return geometry;
+}
+
+function arrowWKBToFeature(arrowCellValue: any) {
+  // The actual WKB array buffer starts from byteOffset and ends at byteOffset + byteLength
+  const arrayBuffer: ArrayBuffer = arrowCellValue.buffer.slice(
+    arrowCellValue.byteOffset,
+    arrowCellValue.byteOffset + arrowCellValue.byteLength
+  );
+  const binaryGeometry = WKBLoader.parseSync?.(arrayBuffer)! as BinaryGeometry;
+  const geometry = binaryToGeometry(binaryGeometry);
+  return geometry;
+}
+
+function arrowWKTToFeature(arrowCellValue: any) {
+  const string: string = arrowCellValue;
+  return WKTLoader.parseTextSync?.(string)!;
 }
 
 /**
  * convert Arrow MultiPolygon to geojson Feature
  */
-function arrowMultiPolygonToFeature(arrowMultiPolygon: arrow.Vector): MultiPolygon {
+function arrowMultiPolygonToFeature(arrowMultiPolygon: any): MultiPolygon {
   const multiPolygon: Position[][][] = [];
   for (let m = 0; m < arrowMultiPolygon.length; m++) {
     const arrowPolygon = arrowMultiPolygon.get(m);
@@ -102,7 +116,7 @@ function arrowMultiPolygonToFeature(arrowMultiPolygon: arrow.Vector): MultiPolyg
 /**
  * convert Arrow Polygon to geojson Feature
  */
-function arrowPolygonToFeature(arrowPolygon: arrow.Vector): Polygon {
+function arrowPolygonToFeature(arrowPolygon: any): Polygon {
   const polygon: Position[][] = [];
   for (let i = 0; arrowPolygon && i < arrowPolygon.length; i++) {
     const arrowRing = arrowPolygon.get(i);
@@ -124,7 +138,7 @@ function arrowPolygonToFeature(arrowPolygon: arrow.Vector): Polygon {
 /**
  * convert Arrow MultiPoint to geojson MultiPoint
  */
-function arrowMultiPointToFeature(arrowMultiPoint: arrow.Vector): MultiPoint {
+function arrowMultiPointToFeature(arrowMultiPoint: any): MultiPoint {
   const multiPoint: Position[] = [];
   for (let i = 0; arrowMultiPoint && i < arrowMultiPoint.length; i++) {
     const arrowPoint = arrowMultiPoint.get(i);
@@ -133,29 +147,27 @@ function arrowMultiPointToFeature(arrowMultiPoint: arrow.Vector): MultiPoint {
       multiPoint.push(coord);
     }
   }
-  const geometry: MultiPoint = {
+  return {
     type: 'MultiPoint',
     coordinates: multiPoint
   };
-  return geometry;
 }
 
 /**
  * convert Arrow Point to geojson Point
  */
-function arrowPointToFeature(arrowPoint: arrow.Vector): Point {
+function arrowPointToFeature(arrowPoint: any): Point {
   const point: Position = Array.from(arrowPoint);
-  const geometry: Point = {
+  return {
     type: 'Point',
     coordinates: point
   };
-  return geometry;
 }
 
 /**
  * convert Arrow MultiLineString to geojson MultiLineString
  */
-function arrowMultiLineStringToFeature(arrowMultiLineString: arrow.Vector): MultiLineString {
+function arrowMultiLineStringToFeature(arrowMultiLineString: any): MultiLineString {
   const multiLineString: Position[][] = [];
   for (let i = 0; arrowMultiLineString && i < arrowMultiLineString.length; i++) {
     const arrowLineString = arrowMultiLineString.get(i);
@@ -169,17 +181,16 @@ function arrowMultiLineStringToFeature(arrowMultiLineString: arrow.Vector): Mult
     }
     multiLineString.push(lineString);
   }
-  const geometry: MultiLineString = {
+  return {
     type: 'MultiLineString',
     coordinates: multiLineString
   };
-  return geometry;
 }
 
 /**
  * convert Arrow LineString to geojson LineString
  */
-function arrowLineStringToFeature(arrowLineString: arrow.Vector): LineString {
+function arrowLineStringToFeature(arrowLineString: any): LineString {
   const lineString: Position[] = [];
   for (let i = 0; arrowLineString && i < arrowLineString.length; i++) {
     const arrowCoord = arrowLineString.get(i);
@@ -188,9 +199,8 @@ function arrowLineStringToFeature(arrowLineString: arrow.Vector): LineString {
       lineString.push(coords);
     }
   }
-  const geometry: LineString = {
+  return {
     type: 'LineString',
     coordinates: lineString
   };
-  return geometry;
 }

package/src/geoarrow-loader.ts

@@ -8,10 +8,6 @@ import type {ArrowTable, ArrowTableBatch} from './lib/arrow-table';
 import {parseGeoArrowSync} from './parsers/parse-geoarrow-sync';
 import {parseGeoArrowInBatches} from './parsers/parse-geoarrow-in-batches';
 
-// __VERSION__ is injected by babel-plugin-version-inline
-// @ts-ignore TS2304: Cannot find name '__VERSION__'.
-const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
-
 export type GeoArrowLoaderOptions = LoaderOptions & {
   arrow?: {
     shape: 'arrow-table' | 'binary-geometry';

package/src/index.ts

@@ -52,7 +52,7 @@ export type {
   BinaryGeometriesFromArrowOptions
 } from './geoarrow/convert-geoarrow-to-binary-geometry';
 export {
-  BINARY_GEOMETRY_TEMPLATE,
+  getBinaryGeometryTemplate,
   getBinaryGeometriesFromArrow,
   getTriangleIndices,
   getMeanCentersFromBinaryGeometries
@@ -60,10 +60,16 @@ export {
 
 export {updateBoundsFromGeoArrowSamples} from './geoarrow/get-arrow-bounds';
 
-export {parseGeometryFromArrow} from './geoarrow/convert-geoarrow-to-geojson';
+export {parseGeometryFromArrow} from './geoarrow/convert-geoarrow-to-geojson-geometry';
 
 export {convertArrowToGeoJSONTable} from './tables/convert-arrow-to-geojson-table';
 
 // EXPERIMENTAL WORKER
+export {hardClone} from './workers/hard-clone';
 
-export {TriangulationWorker, triangulateOnWorker} from './triangulate-on-worker';
+export type {ParseGeoArrowInput, ParseGeoArrowResult} from './triangulate-on-worker';
+export {
+  TriangulationWorker,
+  triangulateOnWorker,
+  parseGeoArrowOnWorker
+} from './triangulate-on-worker';

package/src/parsers/parse-arrow-sync.ts

@@ -6,6 +6,7 @@ import type {ArrowTable} from '../lib/arrow-table';
 import {convertTable} from '@loaders.gl/schema';
 import * as arrow from 'apache-arrow';
 import {convertArrowToColumnarTable} from '../tables/convert-arrow-to-columnar-table';
+import {serializeArrowSchema} from '../schema/convert-arrow-schema';
 
 // Parses arrow to a columnar table
 export function parseArrowSync(
@@ -13,7 +14,11 @@ export function parseArrowSync(
   options?: {shape?: 'arrow-table' | 'columnar-table' | 'object-row-table' | 'array-row-table'}
 ): ArrowTable | ColumnarTable | ObjectRowTable | ArrayRowTable {
   const apacheArrowTable = arrow.tableFromIPC([new Uint8Array(arrayBuffer)]);
-  const arrowTable: ArrowTable = {shape: 'arrow-table', data: apacheArrowTable};
+  const arrowTable: ArrowTable = {
+    shape: 'arrow-table',
+    schema: serializeArrowSchema(apacheArrowTable.schema),
+    data: apacheArrowTable
+  };
 
   const shape = options?.shape || 'arrow-table';
   switch (shape) {

package/src/tables/convert-arrow-to-columnar-table.ts

@@ -24,6 +24,7 @@ export function convertArrowToColumnarTable(table: ArrowTable): ColumnarTable {
 
   return {
     shape: 'columnar-table',
+    schema: table.schema,
     data: columnarTable
   };
 }

package/src/tables/convert-arrow-to-geojson-table.ts

@@ -2,7 +2,7 @@
 // Copyright (c) vis.gl contributors
 
 import type {Feature, GeoJSONTable} from '@loaders.gl/schema';
-import type * as arrow from 'apache-arrow';
+import * as arrow from 'apache-arrow';
 import type {ArrowTable} from '../lib/arrow-table';
 import {serializeArrowSchema, parseGeometryFromArrow} from '@loaders.gl/arrow';
 import {getGeometryColumnsFromSchema} from '@loaders.gl/gis';
@@ -16,6 +16,7 @@ import {getGeometryColumnsFromSchema} from '@loaders.gl/gis';
 export function convertApacheArrowToArrowTable(arrowTable: arrow.Table): ArrowTable {
   return {
     shape: 'arrow-table',
+    schema: serializeArrowSchema(arrowTable.schema),
     data: arrowTable
   };
 }
@@ -34,21 +35,31 @@ export function convertArrowToGeoJSONTable(table: ArrowTable): GeoJSONTable {
 
   const features: Feature[] = [];
 
-  for (let row = 0; row < arrowTable.numRows; row++) {
-    // get first geometry from arrow geometry column
-    const arrowGeometry = arrowTable.getChild('geometry')?.get(row);
-    const arrowGeometryObject = {encoding, data: arrowGeometry};
+  // Remove geometry columns
+  const propertyColumnNames = arrowTable.schema.fields
+    .map((field) => field.name)
+    // TODO - this deletes all geometry columns
+    .filter((name) => !(name in geometryColumns));
+  const propertiesTable = arrowTable.select(propertyColumnNames);
+
+  const arrowGeometryColumn = arrowTable.getChild('geometry');
 
+  for (let row = 0; row < arrowTable.numRows; row++) {
+    // get the geometry value from arrow geometry column
+    // Note that type can vary
+    const arrowGeometry = arrowGeometryColumn?.get(row);
     // parse arrow geometry to geojson feature
-    const feature = parseGeometryFromArrow(arrowGeometryObject);
+    const feature = parseGeometryFromArrow(arrowGeometry, encoding);
     if (feature) {
-      features.push(feature);
+      const properties = propertiesTable.get(row)?.toJSON() || {};
+      features.push({type: 'Feature', geometry: feature, properties});
     }
   }
 
   return {
     shape: 'geojson-table',
     type: 'FeatureCollection',
+    schema: table.schema,
     features
   };
 }

package/src/tables/convert-columnar-to-row-table.ts

@@ -24,6 +24,7 @@ export function convertColumnarToRowFormatTable(columnarTable: ColumnarTable): O
 
   return {
     shape: 'object-row-table',
+    schema: columnarTable.schema,
     data: rowFormatTable
   };
 }

package/src/triangulate-on-worker.ts

@@ -1,19 +1,52 @@
 // loaders.gl, MIT license
 // Copyright (c) vis.gl contributors
 
+import * as arrow from 'apache-arrow';
 import type {WorkerOptions} from '@loaders.gl/worker-utils';
 import {processOnWorker} from '@loaders.gl/worker-utils';
+import {BinaryDataFromGeoArrow, GeoArrowEncoding} from '@loaders.gl/arrow';
 
 // __VERSION__ is injected by babel-plugin-version-inline
 // @ts-ignore TS2304: Cannot find name '__VERSION__'.
 const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
 
-export type TriangulationWorkerInput = TriangulateInput | {operation: 'test'; data: any};
-export type TriangulationWorkerOutput = TriangulateResult | {operation: 'test'; data: any};
+export type TriangulationWorkerInput =
+  | ({operation: 'triangulate'} & TriangulateInput)
+  | ParseGeoArrowInput
+  | {operation: 'test'; data: any};
+
+export type TriangulationWorkerOutput =
+  | ({operation: 'triangulate'} & TriangulateResult)
+  | ({operation: 'parse-geoarrow'} & ParseGeoArrowResult)
+  | {operation: 'test'; data: any};
+
+type GeoArrowChunkData = {
+  type: arrow.DataType;
+  offset: number;
+  length: number;
+  nullCount: number;
+  buffers: any;
+  children: arrow.Data[];
+  dictionary?: arrow.Vector;
+};
+
+export type ParseGeoArrowInput = {
+  operation: 'parse-geoarrow';
+  chunkData: GeoArrowChunkData;
+  chunkIndex: number;
+  chunkOffset: number;
+  geometryEncoding: GeoArrowEncoding;
+  calculateMeanCenters: boolean;
+  triangle: boolean;
+};
+
+export type ParseGeoArrowResult = {
+  chunkIndex: number;
+  binaryDataFromGeoArrow: BinaryDataFromGeoArrow | null;
+};
 
 /** Input data for operation: 'triangulate' */
 export type TriangulateInput = {
-  operation: 'triangulate';
   polygonIndices: Uint16Array;
   primitivePolygonIndices: Int32Array;
   flatCoordinateArray: Float64Array;
@@ -22,7 +55,7 @@ export type TriangulateInput = {
 
 /** Result type for operation: 'triangulate' */
 export type TriangulateResult = TriangulateInput & {
-  triangleIndices: Uint32Array;
+  triangleIndices?: Uint32Array;
 };
 
 /**
@@ -37,11 +70,21 @@ export const TriangulationWorker = {
 };
 
 /**
- * Provide type safety
+ * Triangulate a set of polygons on worker, type safe API
  */
 export function triangulateOnWorker(
-  data: TriangulationWorkerInput,
+  data: TriangulateInput,
+  options: WorkerOptions = {}
+): Promise<TriangulateResult> {
+  return processOnWorker(TriangulationWorker, {...data, operation: 'triangulate'}, options);
+}
+
+/**
+ * Parse GeoArrow geometry colum on worker, type safe API
+ */
+export function parseGeoArrowOnWorker(
+  data: ParseGeoArrowInput,
   options: WorkerOptions = {}
-): Promise<TriangulationWorkerOutput> {
-  return processOnWorker(TriangulationWorker, data, options);
+): Promise<ParseGeoArrowResult> {
+  return processOnWorker(TriangulationWorker, {...data, operation: 'parse-geoarrow'}, options);
 }

package/src/workers/hard-clone.ts

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

package/src/workers/triangulation-worker.ts

@@ -1,12 +1,19 @@
 // loaders.gl, MIT license
 // Copyright (c) vis.gl contributors
 
+import * as arrow from 'apache-arrow';
 import {createWorker} from '@loaders.gl/worker-utils';
-import {getTriangleIndices} from '../geoarrow/convert-geoarrow-to-binary-geometry';
+import {
+  getTriangleIndices,
+  getBinaryGeometriesFromArrow,
+  BinaryDataFromGeoArrow
+} from '../geoarrow/convert-geoarrow-to-binary-geometry';
 import type {
   TriangulationWorkerInput,
   TriangulateInput,
-  TriangulateResult
+  TriangulateResult,
+  ParseGeoArrowInput,
+  ParseGeoArrowResult
 } from '../triangulate-on-worker';
 
 createWorker(async (data, options = {}) => {
@@ -17,6 +24,8 @@ createWorker(async (data, options = {}) => {
       return input;
     case 'triangulate':
       return triangulateBatch(data);
+    case 'parse-geoarrow':
+      return parseGeoArrowBatch(data);
     default:
       throw new Error(
         `TriangulationWorker: Unsupported operation ${operation}. Expected 'triangulate'`
@@ -35,5 +44,50 @@ function triangulateBatch(data: TriangulateInput): TriangulateResult {
     data.flatCoordinateArray,
     data.nDim
   );
-  return {...data, triangleIndices};
+  return {...data, ...(triangleIndices ? {triangleIndices} : {})};
+}
+
+/**
+ * Reading the arrow file into memory is very fast. Parsing the geoarrow column is slow, and blocking the main thread.
+ * To address this issue, we can move the parsing job from main thread to parallel web workers.
+ * Each web worker will parse one chunk/batch of geoarrow column, and return binary geometries to main thread.
+ * The app on the main thread will render the binary geometries and the parsing will not block the main thread.
+ *
+ * @param data
+ * @returns
+ */
+function parseGeoArrowBatch(data: ParseGeoArrowInput): ParseGeoArrowResult {
+  let binaryDataFromGeoArrow: BinaryDataFromGeoArrow | null = null;
+  const {chunkData, chunkIndex, chunkOffset, geometryEncoding, calculateMeanCenters, triangle} =
+    data;
+  // rebuild chunkData that is only for geoarrow column
+  const arrowData = new arrow.Data(
+    chunkData.type,
+    chunkData.offset,
+    chunkData.length,
+    chunkData.nullCount,
+    chunkData.buffers,
+    chunkData.children,
+    chunkData.dictionary
+  );
+  // rebuild geometry column with chunkData
+  const geometryColumn = arrow.makeVector(arrowData);
+  if (geometryColumn) {
+    // NOTE: for a rebuild arrow.Vector, there is only one chunk, so chunkIndex is always 0
+    const options = {calculateMeanCenters, triangle, chunkIndex: 0, chunkOffset};
+    binaryDataFromGeoArrow = getBinaryGeometriesFromArrow(
+      geometryColumn,
+      geometryEncoding,
+      options
+    );
+    // NOTE: here binaryGeometry will be copied to main thread
+    return {
+      binaryDataFromGeoArrow,
+      chunkIndex
+    };
+  }
+  return {
+    binaryDataFromGeoArrow,
+    chunkIndex
+  };
 }