@loaders.gl/arrow 4.0.3 → 4.0.5

package/dist/workers/arrow-worker.js

@@ -1,4 +1,4 @@
 import { createLoaderWorker } from '@loaders.gl/loader-utils';
-import { ArrowLoader } from "../index.js";
+import { ArrowLoader } from "../arrow-loader.js";
 createLoaderWorker(ArrowLoader);
 //# sourceMappingURL=arrow-worker.js.map

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

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

package/dist/workers/triangulation-worker-node.d.ts

@@ -0,0 +1,2 @@
+import './triangulation-worker';
+//# sourceMappingURL=triangulation-worker-node.d.ts.map

package/dist/workers/triangulation-worker-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"triangulation-worker-node.d.ts","sourceRoot":"","sources":["../../src/workers/triangulation-worker-node.ts"],"names":[],"mappings":"AAGA,OAAO,wBAAwB,CAAC"}

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

@@ -0,0 +1,2 @@
+import "./triangulation-worker.js";
+//# sourceMappingURL=triangulation-worker-node.js.map

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

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

package/dist/workers/triangulation-worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=triangulation-worker.d.ts.map

package/dist/workers/triangulation-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"triangulation-worker.d.ts","sourceRoot":"","sources":["../../src/workers/triangulation-worker.ts"],"names":[],"mappings":""}

package/dist/workers/triangulation-worker.js

@@ -0,0 +1,24 @@
+import { createWorker } from '@loaders.gl/worker-utils';
+import { getTriangleIndices } from "../geoarrow/convert-geoarrow-to-binary-geometry.js";
+createWorker(async function (data) {
+  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  const input = data;
+  const operation = input === null || input === void 0 ? void 0 : input.operation;
+  switch (operation) {
+    case 'test':
+      return input;
+    case 'triangulate':
+      return triangulateBatch(data);
+    default:
+      throw new Error(`TriangulationWorker: Unsupported operation ${operation}. Expected 'triangulate'`);
+  }
+});
+function triangulateBatch(data) {
+  console.error('TriangulationWorker: tessellating batch', data);
+  const triangleIndices = getTriangleIndices(data.polygonIndices, data.primitivePolygonIndices, data.flatCoordinateArray, data.nDim);
+  return {
+    ...data,
+    triangleIndices
+  };
+}
+//# sourceMappingURL=triangulation-worker.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"triangulation-worker.js","names":["createWorker","getTriangleIndices","data","options","arguments","length","undefined","input","operation","triangulateBatch","Error","console","error","triangleIndices","polygonIndices","primitivePolygonIndices","flatCoordinateArray","nDim"],"sources":["../../src/workers/triangulation-worker.ts"],"sourcesContent":["// loaders.gl, MIT license\n// Copyright (c) vis.gl contributors\n\nimport {createWorker} from '@loaders.gl/worker-utils';\nimport {getTriangleIndices} from '../geoarrow/convert-geoarrow-to-binary-geometry';\nimport type {\n  TriangulationWorkerInput,\n  TriangulateInput,\n  TriangulateResult\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    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  console.error('TriangulationWorker: tessellating batch', data);\n  const triangleIndices = getTriangleIndices(\n    data.polygonIndices,\n    data.primitivePolygonIndices,\n    data.flatCoordinateArray,\n    data.nDim\n  );\n  return {...data, triangleIndices};\n}\n"],"mappings":"AAGA,SAAQA,YAAY,QAAO,0BAA0B;AAAC,SAC9CC,kBAAkB;AAO1BD,YAAY,CAAC,gBAAOE,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;MACE,MAAM,IAAIQ,KAAK,CACZ,8CAA6CF,SAAU,0BAC1D,CAAC;EACL;AACF,CAAC,CAAC;AAEF,SAASC,gBAAgBA,CAACP,IAAsB,EAAqB;EAInES,OAAO,CAACC,KAAK,CAAC,yCAAyC,EAAEV,IAAI,CAAC;EAC9D,MAAMW,eAAe,GAAGZ,kBAAkB,CACxCC,IAAI,CAACY,cAAc,EACnBZ,IAAI,CAACa,uBAAuB,EAC5Bb,IAAI,CAACc,mBAAmB,EACxBd,IAAI,CAACe,IACP,CAAC;EACD,OAAO;IAAC,GAAGf,IAAI;IAAEW;EAAe,CAAC;AACnC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/arrow",
-  "version": "4.0.3",
+  "version": "4.0.5",
   "description": "Simple columnar table loader for the Apache Arrow format",
   "license": "MIT",
   "type": "module",
@@ -39,17 +39,19 @@
     "fs": false
   },
   "scripts": {
-    "pre-build": "npm run build-worker && npm run build-bundle && npm run build-bundle -- --env=dev",
+    "pre-build": "npm run build-worker && npm run build-bundle && npm run build-bundle -- --env=dev && npm run build-triangulation-worker",
     "build-bundle": "ocular-bundle ./src/index.ts",
-    "build-worker": "esbuild src/workers/arrow-worker.ts --bundle --outfile=dist/arrow-worker.js  --platform=browser --external:{stream} --define:__VERSION__=\\\"$npm_package_version\\\"",
+    "build-triangulation-worker": "esbuild src/workers/triangulation-worker.ts --bundle --outfile=dist/triangulation-worker.js  --platform=browser --external:{stream} --define:__VERSION__=\\\"$npm_package_version\\\"",
     "pre-build2": "cp fixed-package.json ../../node_modules/apache-arrow/package.json && npm run build-bundle && npm run build-worker",
+    "build-worker": "esbuild src/workers/arrow-worker.ts --bundle --outfile=dist/arrow-worker.js  --platform=browser --external:{stream} --define:__VERSION__=\\\"$npm_package_version\\\"",
     "build-worker2": "esbuild src/workers/arrow-worker.ts --bundle --outfile=dist/arrow-worker.js --platform=browser --external:{stream}"
   },
   "dependencies": {
-    "@loaders.gl/gis": "4.0.3",
-    "@loaders.gl/loader-utils": "4.0.3",
-    "@loaders.gl/schema": "4.0.3",
+    "@loaders.gl/gis": "4.0.5",
+    "@loaders.gl/loader-utils": "4.0.5",
+    "@loaders.gl/schema": "4.0.5",
+    "@math.gl/polygon": "4.0.0",
     "apache-arrow": "^13.0.0"
   },
-  "gitHead": "03c871839b36c997249dabae1844df53a35d3760"
+  "gitHead": "9cc48b95bdad8842ebfd9a19f487c534f32526e9"
 }

package/src/arrow-loader.ts

@@ -1,8 +1,16 @@
 // loaders.gl, MIT license
 // Copyright (c) vis.gl contributors
 
-import type {Loader, LoaderOptions} from '@loaders.gl/loader-utils';
+import type {Loader, LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';
+import type {
+  ArrayRowTable,
+  ArrowTableBatch,
+  ColumnarTable,
+  ObjectRowTable
+} from '@loaders.gl/schema';
 import type {ArrowTable} from './lib/arrow-table';
+import {parseArrowSync} from './parsers/parse-arrow-sync';
+import {parseArrowInBatches} from './parsers/parse-arrow-in-batches';
 
 // __VERSION__ is injected by babel-plugin-version-inline
 // @ts-ignore TS2304: Cannot find name '__VERSION__'.
@@ -10,12 +18,12 @@ const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
 
 export type ArrowLoaderOptions = LoaderOptions & {
   arrow?: {
-    shape: 'arrow-table' | 'columnar-table' | 'row-table' | 'array-row-table' | 'object-row-table';
+    shape: 'arrow-table' | 'columnar-table' | 'array-row-table' | 'object-row-table';
   };
 };
 
 /** ArrowJS table loader */
-export const ArrowLoader: Loader<ArrowTable, never, ArrowLoaderOptions> = {
+export const ArrowWorkerLoader: Loader<ArrowTable, never, ArrowLoaderOptions> = {
   name: 'Apache Arrow',
   id: 'arrow',
   module: 'arrow',
@@ -36,3 +44,17 @@ export const ArrowLoader: Loader<ArrowTable, never, ArrowLoaderOptions> = {
     }
   }
 };
+
+/** ArrowJS table loader */
+export const ArrowLoader: LoaderWithParser<
+  ArrowTable | ColumnarTable | ObjectRowTable | ArrayRowTable,
+  ArrowTableBatch,
+  ArrowLoaderOptions
+> = {
+  ...ArrowWorkerLoader,
+  parse: async (arraybuffer: ArrayBuffer, options?: ArrowLoaderOptions) =>
+    parseArrowSync(arraybuffer, options?.arrow),
+  parseSync: (arraybuffer: ArrayBuffer, options?: ArrowLoaderOptions) =>
+    parseArrowSync(arraybuffer, options?.arrow),
+  parseInBatches: parseArrowInBatches
+};

package/src/geoarrow/convert-geoarrow-to-binary-geometry.ts

@@ -2,28 +2,49 @@
 // Copyright (c) vis.gl contributors
 
 import * as arrow from 'apache-arrow';
+import {earcut} from '@math.gl/polygon';
 import {BinaryFeatureCollection as BinaryFeatures} from '@loaders.gl/schema';
 import {GeoArrowEncoding} from '@loaders.gl/gis';
 import {updateBoundsFromGeoArrowSamples} from './get-arrow-bounds';
+import {TypedArray} from '@loaders.gl/loader-utils';
 
 /**
  * Binary data from geoarrow column and can be used by e.g. deck.gl GeojsonLayer
  */
 export type BinaryDataFromGeoArrow = {
+  /** Binary format geometries, an array of BinaryFeatureCollection */
   binaryGeometries: BinaryFeatures[];
+  /** Boundary of the binary geometries */
   bounds: [number, number, number, number];
+  /** Feature types of the binary geometries */
   featureTypes: {polygon: boolean; point: boolean; line: boolean};
+  /** (Optional) mean centers of the binary geometries for e.g. polygon filtering */
+  meanCenters?: number[][];
 };
 
+/**
+ * Binary geometry content returned from getBinaryGeometriesFromChunk
+ */
 type BinaryGeometryContent = {
+  // Array of Point feature indexes by vertex
   featureIds: Uint32Array;
+  /** Flat coordinate array of e.g. x, y or x,y,z */
   flatCoordinateArray: Float64Array;
+  /** Dimention of each position */
   nDim: number;
+  /** Array of geometry offsets: the start index of primitive geometry */
   geomOffset: Int32Array;
+  /** Array of geometry indicies: the start index of each geometry */
   geometryIndicies: Uint16Array;
+  /** (Optional) indices of triangels returned from polygon tessellation (Polygon only) */
+  triangles?: Uint32Array;
+  /** (Optional) array of mean center of each geometry */
+  meanCenters?: Float64Array;
 };
 
-// binary geometry template, see deck.gl BinaryGeometry
+/**
+ * binary geometry template, see deck.gl BinaryGeometry
+ */
 export const BINARY_GEOMETRY_TEMPLATE = {
   globalFeatureIds: {value: new Uint32Array(0), size: 1},
   positions: {value: new Float32Array(0), size: 2},
@@ -32,16 +53,25 @@ export const BINARY_GEOMETRY_TEMPLATE = {
   featureIds: {value: new Uint32Array(0), size: 1}
 };
 
+export type BinaryGeometriesFromArrowOptions = {
+  /** option to specify which chunk to get binary geometries from, for progressive rendering */
+  chunkIndex?: number;
+  /** option to get mean centers from geometries, for polygon filtering */
+  meanCenter?: boolean;
+};
+
 /**
  * get binary geometries from geoarrow column
  *
  * @param geoColumn the geoarrow column, e.g. arrowTable.getChildAt(geoColumnIndex)
  * @param geoEncoding the geo encoding of the geoarrow column, e.g. getGeoArrowEncoding(arrowTable.schema, geoColumnName)
+ * @param options options for getting binary geometries {meanCenter: boolean}
  * @returns BinaryDataFromGeoArrow
  */
 export function getBinaryGeometriesFromArrow(
   geoColumn: arrow.Vector,
-  geoEncoding: GeoArrowEncoding
+  geoEncoding: GeoArrowEncoding,
+  options?: BinaryGeometriesFromArrowOptions
 ): BinaryDataFromGeoArrow {
   const featureTypes = {
     polygon: geoEncoding === 'geoarrow.multipolygon' || geoEncoding === 'geoarrow.polygon',
@@ -49,16 +79,14 @@ export function getBinaryGeometriesFromArrow(
     line: geoEncoding === 'geoarrow.multilinestring' || geoEncoding === 'geoarrow.linestring'
   };
 
-  const chunks = geoColumn.data;
+  const chunks = options?.chunkIndex ? [geoColumn.data[options?.chunkIndex]] : geoColumn.data;
   let bounds: [number, number, number, number] = [Infinity, Infinity, -Infinity, -Infinity];
   let globalFeatureIdOffset = 0;
   const binaryGeometries: BinaryFeatures[] = [];
 
   chunks.forEach((chunk) => {
-    const {featureIds, flatCoordinateArray, nDim, geomOffset} = getBinaryGeometriesFromChunk(
-      chunk,
-      geoEncoding
-    );
+    const {featureIds, flatCoordinateArray, nDim, geomOffset, triangles} =
+      getBinaryGeometriesFromChunk(chunk, geoEncoding);
 
     const globalFeatureIds = new Uint32Array(featureIds.length);
     for (let i = 0; i < featureIds.length; i++) {
@@ -79,7 +107,6 @@ export function getBinaryGeometriesFromArrow(
 
     // TODO: check if chunks are sequentially accessed
     globalFeatureIdOffset += chunk.length;
-
     // NOTE: deck.gl defines the BinaryFeatures structure must have points, lines, polygons even if they are empty
     binaryGeometries.push({
       shape: 'binary-feature-collection',
@@ -99,22 +126,111 @@ export function getBinaryGeometriesFromArrow(
         ...BINARY_GEOMETRY_TEMPLATE,
         ...(featureTypes.polygon ? binaryContent : {}),
         polygonIndices: {
-          // TODO why deck.gl's tessellatePolygon performance is not good when using geometryIndicies
-          // even when there is no hole in any polygon
+          // use geomOffset as polygonIndices same as primitivePolygonIndices since we are using earcut to get triangule indices
           value: featureTypes.polygon ? geomOffset : new Uint16Array(0),
           size: 1
         },
         primitivePolygonIndices: {
           value: featureTypes.polygon ? geomOffset : new Uint16Array(0),
           size: 1
-        }
+        },
+        ...(triangles ? {triangles: {value: triangles, size: 1}} : {})
       }
     });
 
     bounds = updateBoundsFromGeoArrowSamples(flatCoordinateArray, nDim, bounds);
   });
 
-  return {binaryGeometries, bounds, featureTypes};
+  return {
+    binaryGeometries,
+    bounds,
+    featureTypes,
+    ...(options?.meanCenter
+      ? {meanCenters: getMeanCentersFromBinaryGeometries(binaryGeometries)}
+      : {})
+  };
+}
+
+/**
+ * Get mean centers from binary geometries
+ * @param binaryGeometries binary geometries from geoarrow column, an array of BinaryFeatureCollection
+ * @returns mean centers of the binary geometries
+ */
+export function getMeanCentersFromBinaryGeometries(binaryGeometries: BinaryFeatures[]): number[][] {
+  const globalMeanCenters: number[][] = [];
+  binaryGeometries.forEach((binaryGeometry: BinaryFeatures) => {
+    let binaryGeometryType: string | null = null;
+    if (binaryGeometry.points && binaryGeometry.points.positions.value.length > 0) {
+      binaryGeometryType = 'points';
+    } else if (binaryGeometry.lines && binaryGeometry.lines.positions.value.length > 0) {
+      binaryGeometryType = 'lines';
+    } else if (binaryGeometry.polygons && binaryGeometry.polygons.positions.value.length > 0) {
+      binaryGeometryType = 'polygons';
+    }
+
+    const binaryContent = binaryGeometryType ? binaryGeometry[binaryGeometryType] : null;
+    if (binaryContent && binaryGeometryType !== null) {
+      const featureIds = binaryContent.featureIds.value;
+      const flatCoordinateArray = binaryContent.positions.value;
+      const nDim = binaryContent.positions.size;
+      const primitivePolygonIndices = binaryContent.primitivePolygonIndices?.value;
+
+      const meanCenters = getMeanCentersFromGeometry(
+        featureIds,
+        flatCoordinateArray,
+        nDim,
+        binaryGeometryType,
+        primitivePolygonIndices
+      );
+      meanCenters.forEach((center) => {
+        globalMeanCenters.push(center);
+      });
+    }
+  });
+  return globalMeanCenters;
+}
+
+/**
+ * Get mean centers from raw coordinates and feature ids
+ * @param featureIds Array of feature ids indexes by vertex
+ * @param flatCoordinateArray  Array of vertex, e.g. x, y or x, y, z, positions
+ * @param nDim number of dimensions per position
+ * @returns - mean centers of each polygon
+ */
+function getMeanCentersFromGeometry(
+  featureIds: TypedArray,
+  flatCoordinateArray: TypedArray,
+  nDim: number,
+  geometryType: string,
+  primitivePolygonIndices?: TypedArray
+) {
+  const meanCenters: number[][] = [];
+  const vertexCount = flatCoordinateArray.length;
+  let vertexIndex = 0;
+  while (vertexIndex < vertexCount) {
+    const featureId = featureIds[vertexIndex / nDim];
+    const center = [0, 0];
+    let vertexCountInFeature = 0;
+    while (vertexIndex < vertexCount && featureIds[vertexIndex / nDim] === featureId) {
+      if (
+        geometryType === 'polygons' &&
+        primitivePolygonIndices &&
+        primitivePolygonIndices.indexOf(vertexIndex / nDim) >= 0
+      ) {
+        // skip the first point since it is the same as the last point in each ring for polygons
+        vertexIndex += nDim;
+      } else {
+        center[0] += flatCoordinateArray[vertexIndex];
+        center[1] += flatCoordinateArray[vertexIndex + 1];
+        vertexIndex += nDim;
+        vertexCountInFeature++;
+      }
+    }
+    center[0] /= vertexCountInFeature;
+    center[1] /= vertexCountInFeature;
+    meanCenters.push(center);
+  }
+  return meanCenters;
 }
 
 /**
@@ -142,6 +258,53 @@ function getBinaryGeometriesFromChunk(
   }
 }
 
+/**
+ * get triangle indices. Allows deck.gl to skip performing costly triangulation on main thread.
+ * @param polygonIndices Indices within positions of the start of each simple Polygon
+ * @param primitivePolygonIndices Indices within positions of the start of each primitive Polygon/ring
+ * @param flatCoordinateArray Array of x, y or x, y, z positions
+ * @param nDim - number of dimensions per position
+ * @returns
+ */
+export function getTriangleIndices(
+  polygonIndices: Uint16Array,
+  primitivePolygonIndices: Int32Array,
+  flatCoordinateArray: Float64Array,
+  nDim: number
+): Uint32Array {
+  let primitiveIndex = 0;
+  const triangles: number[] = [];
+  // loop polygonIndices to get triangles
+  for (let i = 0; i < polygonIndices.length - 1; i++) {
+    const startIdx = polygonIndices[i];
+    const endIdx = polygonIndices[i + 1];
+    // get subarray of flatCoordinateArray
+    const slicedFlatCoords = flatCoordinateArray.subarray(startIdx * nDim, endIdx * nDim);
+    // get holeIndices for earcut
+    const holeIndices: number[] = [];
+    while (primitivePolygonIndices[primitiveIndex] < endIdx) {
+      if (primitivePolygonIndices[primitiveIndex] > startIdx) {
+        holeIndices.push(primitivePolygonIndices[primitiveIndex] - startIdx);
+      }
+      primitiveIndex++;
+    }
+    const triangleIndices = earcut(
+      slicedFlatCoords,
+      holeIndices.length > 0 ? holeIndices : undefined,
+      nDim
+    );
+    for (let j = 0; j < triangleIndices.length; j++) {
+      triangles.push(triangleIndices[j] + startIdx);
+    }
+  }
+  // convert traingles to Uint32Array
+  const trianglesUint32 = new Uint32Array(triangles.length);
+  for (let i = 0; i < triangles.length; i++) {
+    trianglesUint32[i] = triangles[i];
+  }
+  return trianglesUint32;
+}
+
 /**
  * get binary polygons from geoarrow polygon column
  * @param chunk one chunk of geoarrow polygon column
@@ -178,12 +341,14 @@ function getBinaryPolygonsFromChunk(chunk: arrow.Data, geoEncoding: string): Bin
     }
   }
 
+  const triangles = getTriangleIndices(geometryIndicies, geomOffset, flatCoordinateArray, nDim);
   return {
     featureIds,
     flatCoordinateArray,
     nDim,
     geomOffset,
-    geometryIndicies
+    geometryIndicies,
+    triangles
   };
 }
 
@@ -209,11 +374,23 @@ function getBinaryLinesFromChunk(chunk: arrow.Data, geoEncoding: string): Binary
 
   const numOfVertices = flatCoordinateArray.length / nDim;
   const featureIds = new Uint32Array(numOfVertices);
-  for (let i = 0; i < chunk.length; i++) {
-    const startIdx = geomOffset[i];
-    const endIdx = geomOffset[i + 1];
-    for (let j = startIdx; j < endIdx; j++) {
-      featureIds[j] = i;
+
+  if (isMultiLineString) {
+    const partData = chunk.valueOffsets;
+    for (let i = 0; i < partData.length - 1; i++) {
+      const startIdx = geomOffset[partData[i]];
+      const endIdx = geomOffset[partData[i + 1]];
+      for (let j = startIdx; j < endIdx; j++) {
+        featureIds[j] = i;
+      }
+    }
+  } else {
+    for (let i = 0; i < chunk.length; i++) {
+      const startIdx = geomOffset[i];
+      const endIdx = geomOffset[i + 1];
+      for (let j = startIdx; j < endIdx; j++) {
+        featureIds[j] = i;
+      }
     }
   }
 
@@ -248,8 +425,20 @@ function getBinaryPointsFromChunk(chunk: arrow.Data, geoEncoding: string): Binar
 
   const numOfVertices = flatCoordinateArray.length / nDim;
   const featureIds = new Uint32Array(numOfVertices);
-  for (let i = 0; i < chunk.length; i++) {
-    featureIds[i] = i;
+
+  if (isMultiPoint) {
+    const partData = chunk.valueOffsets;
+    for (let i = 0; i < partData.length - 1; i++) {
+      const startIdx = partData[i];
+      const endIdx = partData[i + 1];
+      for (let j = startIdx; j < endIdx; j++) {
+        featureIds[j] = i;
+      }
+    }
+  } else {
+    for (let i = 0; i < chunk.length; i++) {
+      featureIds[i] = i;
+    }
   }
 
   return {

package/src/geoarrow/convert-geoarrow-to-geojson.ts

@@ -15,8 +15,8 @@ import {
 import type {GeoArrowEncoding} from '@loaders.gl/gis';
 
 type RawArrowFeature = {
+  data: arrow.Vector;
   encoding?: GeoArrowEncoding;
-  data: any;
 };
 
 /**
@@ -30,7 +30,7 @@ type RawArrowFeature = {
  * @returns Feature or null
  */
 export function parseGeometryFromArrow(rawData: RawArrowFeature): Feature | null {
-  const encoding = rawData.encoding?.toLowerCase();
+  const encoding = rawData.encoding?.toLowerCase() as typeof rawData.encoding;
   const data = rawData.data;
   if (!encoding || !data) {
     return null;
@@ -57,6 +57,10 @@ export function parseGeometryFromArrow(rawData: RawArrowFeature): Feature | null
     case 'geoarrow.linestring':
       geometry = arrowLineStringToFeature(data);
       break;
+    case 'geoarrow.wkb':
+      throw Error(`GeoArrow encoding not supported ${encoding}`);
+    case 'geoarrow.wkt':
+      throw Error(`GeoArrow encoding not supported ${encoding}`);
     default: {
       throw Error(`GeoArrow encoding not supported ${encoding}`);
     }

package/src/geoarrow-loader.ts

@@ -0,0 +1,55 @@
+// loaders.gl, MIT license
+// Copyright (c) vis.gl contributors
+
+import type {Loader, LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';
+import {ArrowWorkerLoader} from './arrow-loader';
+import type {GeoJSONTable, GeoJSONTableBatch, BinaryGeometry} from '@loaders.gl/schema';
+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';
+  };
+};
+
+/** ArrowJS table loader */
+export const GeoArrowWorkerLoader: Loader<
+  ArrowTable | BinaryGeometry,
+  never,
+  GeoArrowLoaderOptions
+> = {
+  ...ArrowWorkerLoader,
+  options: {
+    arrow: {
+      shape: 'arrow-table'
+    }
+  }
+};
+
+/**
+ * GeoArrowLoader loads an Apache Arrow table, parses GeoArrow type extension data
+ * to convert it to a GeoJSON table or a BinaryGeometry
+ */
+export const GeoArrowLoader: LoaderWithParser<
+  ArrowTable | GeoJSONTable, // | BinaryGeometry,
+  ArrowTableBatch | GeoJSONTableBatch, // | BinaryGeometry,
+  GeoArrowLoaderOptions
+> = {
+  ...ArrowWorkerLoader,
+  options: {
+    arrow: {
+      shape: 'arrow-table'
+    }
+  },
+  parse: async (arraybuffer: ArrayBuffer, options?: GeoArrowLoaderOptions) =>
+    parseGeoArrowSync(arraybuffer, options?.arrow),
+  parseSync: (arraybuffer: ArrayBuffer, options?: GeoArrowLoaderOptions) =>
+    parseGeoArrowSync(arraybuffer, options?.arrow),
+  parseInBatches: parseGeoArrowInBatches
+};

package/src/geoarrow-writer.ts

@@ -0,0 +1,41 @@
+// import type {} from '@loaders.gl/loader-utils';
+
+import type {WriterWithEncoder, WriterOptions} from '@loaders.gl/loader-utils';
+import {GeoJSONTable, BinaryGeometry} from '@loaders.gl/schema';
+import {encodeGeoArrowSync} from './lib/encode-geoarrow';
+
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
+
+type ArrowWriterOptions = WriterOptions & {
+  arrow?: {};
+};
+
+/** Apache Arrow writer */
+export const GeoArrowWriter: WriterWithEncoder<
+  GeoJSONTable | BinaryGeometry,
+  never,
+  ArrowWriterOptions
+> = {
+  name: 'Apache Arrow',
+  id: 'arrow',
+  module: 'arrow',
+  version: VERSION,
+  extensions: ['arrow', 'feather'],
+  mimeTypes: [
+    'application/vnd.apache.arrow.file',
+    'application/vnd.apache.arrow.stream',
+    'application/octet-stream'
+  ],
+  binary: true,
+  options: {},
+  encode: async function encodeArrow(data, options?): Promise<ArrayBuffer> {
+    // @ts-expect-error
+    return encodeGeoArrowSync(data);
+  },
+  encodeSync(data, options?) {
+    // @ts-expect-error
+    return encodeGeoArrowSync(data);
+  }
+};