@loaders.gl/arrow 4.0.3 → 4.1.0-alpha.1

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

@@ -1,77 +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 = {
-  encoding?: GeoArrowEncoding;
-  data: any;
-};
+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();
-  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':
+      geometry = arrowWKBToFeature(arrowCellValue);
+      break;
+    case 'geoarrow.wkt':
+      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);
@@ -98,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);
@@ -120,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);
@@ -129,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);
@@ -165,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);
@@ -184,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

@@ -0,0 +1,51 @@
+// 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';
+
+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);
+  }
+};

package/src/index.ts

@@ -1,16 +1,8 @@
 // loaders.gl, MIT license
 // Copyright (c) vis.gl contributors
 
-import type {LoaderWithParser} from '@loaders.gl/loader-utils';
 import type {ArrowLoaderOptions} from './arrow-loader';
-import type {ArrowTableBatch, ColumnarTable, ObjectRowTable} from '@loaders.gl/schema';
-import type {ArrowTable} from './lib/arrow-table';
-
 import {TableBatchBuilder} from '@loaders.gl/schema';
-import {ArrowLoader as ArrowWorkerLoader} from './arrow-loader';
-import parseSync from './lib/parse-arrow-sync';
-import {parseArrowInBatches} from './lib/parse-arrow-in-batches';
-
 import {ArrowTableBatchAggregator} from './lib/arrow-table-batch';
 
 // Make the ArrowBatch type available
@@ -22,6 +14,21 @@ export {getArrowType} from './schema/arrow-type-utils';
 
 // SCHEMA
 
+// Types
+export type {ArrowTable, ArrowTableBatch} from './lib/arrow-table';
+export {VECTOR_TYPES} from './types';
+
+// Arrow loader / Writer
+
+export type {ArrowLoaderOptions};
+export {ArrowLoader, ArrowWorkerLoader} from './arrow-loader';
+
+export {ArrowWriter} from './arrow-writer';
+
+// Geoarrow loader
+export {GeoArrowLoader, GeoArrowWorkerLoader} from './geoarrow-loader';
+
+// Schema utils
 export {
   serializeArrowSchema,
   deserializeArrowSchema,
@@ -33,43 +40,30 @@ export {
   deserializeArrowType
 } from './schema/convert-arrow-schema';
 
-// Types
-export type {ArrowTable, ArrowTableBatch} from './lib/arrow-table';
-export {VECTOR_TYPES} from './types';
-
-// Arrow writer
-
-export {ArrowWriter} from './arrow-writer';
-
-// Arrow loader
-
-export type {ArrowLoaderOptions};
-export {ArrowWorkerLoader};
-
-/** ArrowJS table loader */
-export const ArrowLoader: LoaderWithParser<
-  ArrowTable | ColumnarTable | ObjectRowTable,
-  ArrowTableBatch,
-  ArrowLoaderOptions
-> = {
-  ...ArrowWorkerLoader,
-  parse: async (arraybuffer: ArrayBuffer, options?: ArrowLoaderOptions) =>
-    parseSync(arraybuffer, options),
-  parseSync,
-  parseInBatches: parseArrowInBatches
-};
+// EXPERIMENTAL
 
 // Arrow Utils
 export type {GeoArrowEncoding} from '@loaders.gl/gis';
 // getGeometryColumnsFromArrowTable,
 // getGeoArrowEncoding
 
-export type {BinaryDataFromGeoArrow} from './geoarrow/convert-geoarrow-to-binary-geometry';
+export type {
+  BinaryDataFromGeoArrow,
+  BinaryGeometriesFromArrowOptions
+} from './geoarrow/convert-geoarrow-to-binary-geometry';
 export {
   BINARY_GEOMETRY_TEMPLATE,
-  getBinaryGeometriesFromArrow
+  getBinaryGeometriesFromArrow,
+  getTriangleIndices,
+  getMeanCentersFromBinaryGeometries
 } from './geoarrow/convert-geoarrow-to-binary-geometry';
 
-export {parseGeometryFromArrow} from './geoarrow/convert-geoarrow-to-geojson';
-
 export {updateBoundsFromGeoArrowSamples} from './geoarrow/get-arrow-bounds';
+
+export {parseGeometryFromArrow} from './geoarrow/convert-geoarrow-to-geojson-geometry';
+
+export {convertArrowToGeoJSONTable} from './tables/convert-arrow-to-geojson-table';
+
+// EXPERIMENTAL WORKER
+
+export {TriangulationWorker, triangulateOnWorker} from './triangulate-on-worker';

package/src/lib/arrow-table-batch.ts

@@ -1,3 +1,6 @@
+// loaders.gl, MIT license
+// Copyright (c) vis.gl contributors
+
 import {ColumnarTableBatchAggregator} from '@loaders.gl/schema';
 import type {ArrowTableBatch} from './arrow-table';
 import * as arrow from 'apache-arrow';

package/src/lib/encode-arrow.ts

@@ -1,3 +1,6 @@
+// loaders.gl, MIT license
+// Copyright (c) vis.gl contributors
+
 import * as arrow from 'apache-arrow';
 import {AnyArrayType, VECTOR_TYPES} from '../types';
 

package/src/lib/encode-geoarrow.ts

@@ -0,0 +1,45 @@
+// loaders.gl, MIT license
+// Copyright (c) vis.gl contributors
+
+import * as arrow from 'apache-arrow';
+import {AnyArrayType, VECTOR_TYPES} from '../types';
+
+export type ColumnarTable = {
+  name: string;
+  array: AnyArrayType;
+  type: number;
+}[];
+
+/**
+ * Encodes set of arrays into the Apache Arrow columnar format
+ * https://arrow.apache.org/docs/format/Columnar.html#ipc-file-format
+ * @param data - columns data
+ * @param options - the writer options
+ * @returns - encoded ArrayBuffer
+ */
+export function encodeGeoArrowSync(data: ColumnarTable): ArrayBuffer {
+  const vectors: Record<string, arrow.Vector> = {};
+  for (const arrayData of data) {
+    const arrayVector = createVector(arrayData.array, arrayData.type);
+    vectors[arrayData.name] = arrayVector;
+  }
+  const table = new arrow.Table(vectors);
+  const arrowBuffer = arrow.tableToIPC(table);
+  return arrowBuffer;
+}
+
+/**
+ * Create Arrow arrow.Vector from given data and vector type
+ * @param array {import('../types').AnyArrayType} - columns data
+ * @param type {number} - the writer options
+ * @return a vector of one of vector's types defined in the Apache Arrow library
+ */
+function createVector(array, type): arrow.Vector {
+  switch (type) {
+    case VECTOR_TYPES.DATE:
+      return arrow.vectorFromArray(array);
+    case VECTOR_TYPES.FLOAT:
+    default:
+      return arrow.vectorFromArray(array);
+  }
+}

package/src/{lib → parsers}/parse-arrow-in-batches.ts

@@ -1,5 +1,7 @@
-// TODO - this import defeats the sophisticated typescript checking in ArrowJS
-import type {ArrowTableBatch} from './arrow-table';
+// loaders.gl, MIT license
+// Copyright (c) vis.gl contributors
+
+import type {ArrowTableBatch} from '../lib/arrow-table';
 import * as arrow from 'apache-arrow';
 // import {isIterable} from '@loaders.gl/core';
 

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

@@ -0,0 +1,43 @@
+// loaders.gl, MIT license
+// Copyright (c) vis.gl contributors
+
+import type {ArrayRowTable, ColumnarTable, ObjectRowTable} from '@loaders.gl/schema';
+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(
+  arrayBuffer,
+  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',
+    schema: serializeArrowSchema(apacheArrowTable.schema),
+    data: apacheArrowTable
+  };
+
+  const shape = options?.shape || 'arrow-table';
+  switch (shape) {
+    case 'arrow-table':
+      return arrowTable;
+
+    case 'columnar-table':
+      return convertArrowToColumnarTable(arrowTable);
+
+    case 'object-row-table':
+      let columnarTable = convertArrowToColumnarTable(arrowTable);
+      return convertTable(columnarTable, 'object-row-table');
+
+    case 'array-row-table':
+      columnarTable = convertArrowToColumnarTable(arrowTable);
+      return convertTable(columnarTable, 'array-row-table');
+
+    default:
+      // TODO
+      throw new Error(shape);
+  }
+}

package/src/parsers/parse-geoarrow-in-batches.ts

@@ -0,0 +1,15 @@
+// loaders.gl, MIT license
+// Copyright (c) vis.gl contributors
+
+import type {GeoJSONTableBatch} from '@loaders.gl/schema';
+import type {ArrowTableBatch} from '../lib/arrow-table';
+import {parseArrowInBatches} from './parse-arrow-in-batches';
+
+/**
+ */
+export function parseGeoArrowInBatches(
+  asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>
+): AsyncIterable<ArrowTableBatch | GeoJSONTableBatch> {
+  // | BinaryGeometry
+  return parseArrowInBatches(asyncIterator);
+}

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

@@ -0,0 +1,22 @@
+// loaders.gl, MIT license
+// Copyright (c) vis.gl contributors
+
+import type {GeoJSONTable} from '@loaders.gl/schema';
+import type {ArrowTable} from '../lib/arrow-table';
+import {parseArrowSync} from './parse-arrow-sync';
+import {convertArrowToGeoJSONTable} from '../tables/convert-arrow-to-geojson-table';
+
+// Parses arrow to a columnar table
+export function parseGeoArrowSync(
+  arrayBuffer,
+  options?: {shape?: 'arrow-table' | 'geojson-table' | 'binary-geometry'}
+): ArrowTable | GeoJSONTable {
+  // | BinaryGeometry
+  const table = parseArrowSync(arrayBuffer, {shape: 'arrow-table'}) as ArrowTable;
+  switch (options?.shape) {
+    case 'geojson-table':
+      return convertArrowToGeoJSONTable(table);
+    default:
+      return table;
+  }
+}

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

@@ -0,0 +1,30 @@
+// loaders.gl, MIT license
+// Copyright (c) vis.gl contributors
+
+import type {ColumnarTable} from '@loaders.gl/schema';
+import type {ArrowTable} from '../lib/arrow-table';
+
+/**
+ * Convert an Apache Arrow table to a ColumnarTable
+ * @note Currently does not convert schema
+ */
+export function convertArrowToColumnarTable(table: ArrowTable): ColumnarTable {
+  // TODO - avoid calling `getColumn` on columns we are not interested in?
+  // Add options object?
+
+  const arrowTable = table.data;
+  const columnarTable = {};
+
+  for (const field of arrowTable.schema.fields) {
+    // This (is intended to) coalesce all record batches into a single typed array
+    const arrowColumn = arrowTable.getChild(field.name);
+    const values = arrowColumn?.toArray();
+    columnarTable[field.name] = values;
+  }
+
+  return {
+    shape: 'columnar-table',
+    schema: table.schema,
+    data: columnarTable
+  };
+}

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

@@ -0,0 +1,65 @@
+// loaders.gl, MIT license
+// Copyright (c) vis.gl contributors
+
+import type {Feature, GeoJSONTable} from '@loaders.gl/schema';
+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';
+
+/**
+ * Wrap an apache arrow table in a loaders.gl table wrapper.
+ * From this additional conversions are available.
+ * @param arrowTable
+ * @returns
+ */
+export function convertApacheArrowToArrowTable(arrowTable: arrow.Table): ArrowTable {
+  return {
+    shape: 'arrow-table',
+    schema: serializeArrowSchema(arrowTable.schema),
+    data: arrowTable
+  };
+}
+
+/**
+ * Convert an Apache Arrow table to a GeoJSONTable
+ * @note Currently does not convert schema
+ */
+export function convertArrowToGeoJSONTable(table: ArrowTable): GeoJSONTable {
+  const arrowTable = table.data;
+  const schema = serializeArrowSchema(arrowTable.schema);
+  const geometryColumns = getGeometryColumnsFromSchema(schema);
+
+  // get encoding from geometryColumns['geometry']
+  const encoding = geometryColumns.geometry.encoding;
+
+  const features: Feature[] = [];
+
+  // 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(arrowGeometry, encoding);
+    if (feature) {
+      const properties = propertiesTable.get(row)?.toJSON() || {};
+      features.push({type: 'Feature', geometry: feature, properties});
+    }
+  }
+
+  return {
+    shape: 'geojson-table',
+    type: 'FeatureCollection',
+    schema: table.schema,
+    features
+  };
+}