@loaders.gl/arrow 4.0.0 → 4.0.2

package/dist/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -23,8 +33,20 @@ __export(src_exports, {
   ArrowLoader: () => ArrowLoader2,
   ArrowWorkerLoader: () => ArrowLoader,
   ArrowWriter: () => ArrowWriter,
+  BINARY_GEOMETRY_TEMPLATE: () => BINARY_GEOMETRY_TEMPLATE,
   VECTOR_TYPES: () => VECTOR_TYPES,
-  getArrowType: () => getArrowType
+  deserializeArrowField: () => deserializeArrowField,
+  deserializeArrowMetadata: () => deserializeArrowMetadata,
+  deserializeArrowSchema: () => deserializeArrowSchema,
+  deserializeArrowType: () => deserializeArrowType,
+  getArrowType: () => getArrowType,
+  getBinaryGeometriesFromArrow: () => getBinaryGeometriesFromArrow,
+  parseGeometryFromArrow: () => parseGeometryFromArrow,
+  serializeArrowField: () => serializeArrowField,
+  serializeArrowMetadata: () => serializeArrowMetadata,
+  serializeArrowSchema: () => serializeArrowSchema,
+  serializeArrowType: () => serializeArrowType,
+  updateBoundsFromGeoArrowSamples: () => updateBoundsFromGeoArrowSamples
 });
 module.exports = __toCommonJS(src_exports);
 var import_schema3 = require("@loaders.gl/schema");
@@ -55,9 +77,9 @@ var ArrowLoader = {
 
 // src/lib/parse-arrow-sync.ts
 var import_schema = require("@loaders.gl/schema");
-var import_apache_arrow = require("apache-arrow");
+var arrow = __toESM(require("apache-arrow"), 1);
 
-// src/lib/convert-table.ts
+// src/tables/convert-arrow-to-table.ts
 function convertApacheArrowToArrowTable(arrowTable) {
   return {
     shape: "arrow-table",
@@ -81,7 +103,7 @@ function convertArrowToColumnarTable(table) {
 // src/lib/parse-arrow-sync.ts
 function parseArrowSync(arrayBuffer, options) {
   var _a;
-  const apacheArrowTable = (0, import_apache_arrow.tableFromIPC)([new Uint8Array(arrayBuffer)]);
+  const apacheArrowTable = arrow.tableFromIPC([new Uint8Array(arrayBuffer)]);
   const arrowTable = convertApacheArrowToArrowTable(apacheArrowTable);
   const shape = ((_a = options == null ? void 0 : options.arrow) == null ? void 0 : _a.shape) || "arrow-table";
   switch (shape) {
@@ -98,16 +120,16 @@ function parseArrowSync(arrayBuffer, options) {
 }
 
 // src/lib/parse-arrow-in-batches.ts
-var import_apache_arrow2 = require("apache-arrow");
+var arrow2 = __toESM(require("apache-arrow"), 1);
 function parseArrowInBatches(asyncIterator) {
   async function* makeArrowAsyncIterator() {
-    const readers = import_apache_arrow2.RecordBatchReader.readAll(asyncIterator);
+    const readers = arrow2.RecordBatchReader.readAll(asyncIterator);
     for await (const reader of readers) {
       for await (const recordBatch of reader) {
         const arrowTabledBatch = {
           shape: "arrow-table",
           batchType: "data",
-          data: new import_apache_arrow2.Table([recordBatch]),
+          data: new arrow2.Table([recordBatch]),
           length: recordBatch.data.length
         };
         yield arrowTabledBatch;
@@ -120,7 +142,7 @@ function parseArrowInBatches(asyncIterator) {
 
 // src/lib/arrow-table-batch.ts
 var import_schema2 = require("@loaders.gl/schema");
-var import_apache_arrow3 = require("apache-arrow");
+var arrow3 = __toESM(require("apache-arrow"), 1);
 var ArrowTableBatchAggregator = class extends import_schema2.ColumnarTableBatchAggregator {
   constructor(schema, options) {
     super(schema, options);
@@ -131,17 +153,17 @@ var ArrowTableBatchAggregator = class extends import_schema2.ColumnarTableBatchA
     if (batch) {
       this.arrowSchema = this.arrowSchema || getArrowSchema(batch.schema);
       const arrowVectors = getArrowVectors(this.arrowSchema, batch.data);
-      const recordBatch = new import_apache_arrow3.RecordBatch(
+      const recordBatch = new arrow3.RecordBatch(
         this.arrowSchema,
-        (0, import_apache_arrow3.makeData)({
-          type: new import_apache_arrow3.Struct(this.arrowSchema.fields),
+        arrow3.makeData({
+          type: new arrow3.Struct(this.arrowSchema.fields),
           children: arrowVectors.map(({ data }) => data[0])
         })
       );
       return {
         shape: "arrow-table",
         batchType: "data",
-        data: new import_apache_arrow3.Table([recordBatch]),
+        data: new arrow3.Table([recordBatch]),
         length: batch.length
       };
     }
@@ -154,21 +176,21 @@ function getArrowSchema(schema) {
     const field = schema[key];
     if (field.type === Float32Array) {
       const metadata = /* @__PURE__ */ new Map();
-      const arrowField = new import_apache_arrow3.Field(field.name, new import_apache_arrow3.Float32(), field.nullable, metadata);
+      const arrowField = new arrow3.Field(field.name, new arrow3.Float32(), field.nullable, metadata);
       arrowFields.push(arrowField);
     }
   }
   if (arrowFields.length === 0) {
     throw new Error("No arrow convertible fields");
   }
-  return new import_apache_arrow3.Schema(arrowFields);
+  return new arrow3.Schema(arrowFields);
 }
 function getArrowVectors(arrowSchema, data) {
   const arrowVectors = [];
   for (const field of arrowSchema.fields) {
     const vector = data[field.name];
     if (vector instanceof Float32Array) {
-      const arrowVector = (0, import_apache_arrow3.makeVector)(vector);
+      const arrowVector = arrow3.makeVector(vector);
       arrowVectors.push(arrowVector);
     }
   }
@@ -179,25 +201,266 @@ function getArrowVectors(arrowSchema, data) {
 }
 
 // src/schema/arrow-type-utils.ts
-var import_apache_arrow4 = require("apache-arrow");
+var arrow4 = __toESM(require("apache-arrow"), 1);
 function getArrowType(array) {
   switch (array.constructor) {
     case Int8Array:
-      return new import_apache_arrow4.Int8();
+      return new arrow4.Int8();
     case Uint8Array:
-      return new import_apache_arrow4.Uint8();
+      return new arrow4.Uint8();
     case Int16Array:
-      return new import_apache_arrow4.Int16();
+      return new arrow4.Int16();
     case Uint16Array:
-      return new import_apache_arrow4.Uint16();
+      return new arrow4.Uint16();
     case Int32Array:
-      return new import_apache_arrow4.Int32();
+      return new arrow4.Int32();
     case Uint32Array:
-      return new import_apache_arrow4.Uint32();
+      return new arrow4.Uint32();
     case Float32Array:
-      return new import_apache_arrow4.Float32();
+      return new arrow4.Float32();
     case Float64Array:
-      return new import_apache_arrow4.Float64();
+      return new arrow4.Float64();
+    default:
+      throw new Error("array type not supported");
+  }
+}
+
+// src/schema/convert-arrow-schema.ts
+var arrow5 = __toESM(require("apache-arrow"), 1);
+function serializeArrowSchema(arrowSchema) {
+  return {
+    fields: arrowSchema.fields.map((arrowField) => serializeArrowField(arrowField)),
+    metadata: serializeArrowMetadata(arrowSchema.metadata)
+  };
+}
+function deserializeArrowSchema(schema) {
+  return new arrow5.Schema(
+    schema.fields.map((field) => deserializeArrowField(field)),
+    deserializeArrowMetadata(schema.metadata)
+  );
+}
+function serializeArrowMetadata(arrowMetadata) {
+  return Object.fromEntries(arrowMetadata);
+}
+function deserializeArrowMetadata(metadata) {
+  return metadata ? new Map(Object.entries(metadata)) : /* @__PURE__ */ new Map();
+}
+function serializeArrowField(field) {
+  return {
+    name: field.name,
+    type: serializeArrowType(field.type),
+    nullable: field.nullable,
+    metadata: serializeArrowMetadata(field.metadata)
+  };
+}
+function deserializeArrowField(field) {
+  return new arrow5.Field(
+    field.name,
+    deserializeArrowType(field.type),
+    field.nullable,
+    deserializeArrowMetadata(field.metadata)
+  );
+}
+function serializeArrowType(arrowType) {
+  switch (arrowType.constructor) {
+    case arrow5.Null:
+      return "null";
+    case arrow5.Binary:
+      return "binary";
+    case arrow5.Bool:
+      return "bool";
+    case arrow5.Int:
+      const intType = arrowType;
+      return `${intType.isSigned ? "u" : ""}int${intType.bitWidth}`;
+    case arrow5.Int8:
+      return "int8";
+    case arrow5.Int16:
+      return "int16";
+    case arrow5.Int32:
+      return "int32";
+    case arrow5.Int64:
+      return "int64";
+    case arrow5.Uint8:
+      return "uint8";
+    case arrow5.Uint16:
+      return "uint16";
+    case arrow5.Uint32:
+      return "uint32";
+    case arrow5.Uint64:
+      return "uint64";
+    case arrow5.Float:
+      const precision = arrowType.precision;
+      switch (precision) {
+        case arrow5.Precision.HALF:
+          return "float16";
+        case arrow5.Precision.SINGLE:
+          return "float32";
+        case arrow5.Precision.DOUBLE:
+          return "float64";
+        default:
+          return "float16";
+      }
+    case arrow5.Float16:
+      return "float16";
+    case arrow5.Float32:
+      return "float32";
+    case arrow5.Float64:
+      return "float64";
+    case arrow5.Utf8:
+      return "utf8";
+    case Date:
+      const dateUnit = arrowType.unit;
+      return dateUnit === arrow5.DateUnit.DAY ? "date-day" : "date-millisecond";
+    case arrow5.DateDay:
+      return "date-day";
+    case arrow5.DateMillisecond:
+      return "date-millisecond";
+    case arrow5.Time:
+      const timeUnit = arrowType.unit;
+      switch (timeUnit) {
+        case arrow5.TimeUnit.SECOND:
+          return "time-second";
+        case arrow5.TimeUnit.MILLISECOND:
+          return "time-millisecond";
+        case arrow5.TimeUnit.MICROSECOND:
+          return "time-microsecond";
+        case arrow5.TimeUnit.NANOSECOND:
+          return "time-nanosecond";
+        default:
+          return "time-second";
+      }
+    case arrow5.TimeMillisecond:
+      return "time-millisecond";
+    case arrow5.TimeSecond:
+      return "time-second";
+    case arrow5.TimeMicrosecond:
+      return "time-microsecond";
+    case arrow5.TimeNanosecond:
+      return "time-nanosecond";
+    case arrow5.Timestamp:
+      const timeStampUnit = arrowType.unit;
+      switch (timeStampUnit) {
+        case arrow5.TimeUnit.SECOND:
+          return "timestamp-second";
+        case arrow5.TimeUnit.MILLISECOND:
+          return "timestamp-millisecond";
+        case arrow5.TimeUnit.MICROSECOND:
+          return "timestamp-microsecond";
+        case arrow5.TimeUnit.NANOSECOND:
+          return "timestamp-nanosecond";
+        default:
+          return "timestamp-second";
+      }
+    case arrow5.TimestampSecond:
+      return "timestamp-second";
+    case arrow5.TimestampMillisecond:
+      return "timestamp-millisecond";
+    case arrow5.TimestampMicrosecond:
+      return "timestamp-microsecond";
+    case arrow5.TimestampNanosecond:
+      return "timestamp-nanosecond";
+    case arrow5.Interval:
+      const intervalUnit = arrowType.unit;
+      switch (intervalUnit) {
+        case arrow5.IntervalUnit.DAY_TIME:
+          return "interval-daytime";
+        case arrow5.IntervalUnit.YEAR_MONTH:
+          return "interval-yearmonth";
+        default:
+          return "interval-daytime";
+      }
+    case arrow5.IntervalDayTime:
+      return "interval-daytime";
+    case arrow5.IntervalYearMonth:
+      return "interval-yearmonth";
+    case arrow5.List:
+      const listType = arrowType;
+      const listField = listType.valueField;
+      return {
+        type: "list",
+        children: [serializeArrowField(listField)]
+      };
+    case arrow5.FixedSizeList:
+      return {
+        type: "fixed-size-list",
+        listSize: arrowType.listSize,
+        children: [serializeArrowField(arrowType.children[0])]
+      };
+    default:
+      throw new Error("array type not supported");
+  }
+}
+function deserializeArrowType(dataType) {
+  if (typeof dataType === "object") {
+    switch (dataType.type) {
+      case "list":
+        const field = deserializeArrowField(dataType.children[0]);
+        return new arrow5.List(field);
+      case "fixed-size-list":
+        const child = deserializeArrowField(dataType.children[0]);
+        return new arrow5.FixedSizeList(dataType.listSize, child);
+      case "struct":
+        const children = dataType.children.map((arrowField) => deserializeArrowField(arrowField));
+        return new arrow5.Struct(children);
+      default:
+        throw new Error("array type not supported");
+    }
+  }
+  switch (dataType) {
+    case "null":
+      return new arrow5.Null();
+    case "binary":
+      return new arrow5.Binary();
+    case "bool":
+      return new arrow5.Bool();
+    case "int8":
+      return new arrow5.Int8();
+    case "int16":
+      return new arrow5.Int16();
+    case "int32":
+      return new arrow5.Int32();
+    case "int64":
+      return new arrow5.Int64();
+    case "uint8":
+      return new arrow5.Uint8();
+    case "uint16":
+      return new arrow5.Uint16();
+    case "uint32":
+      return new arrow5.Uint32();
+    case "uint64":
+      return new arrow5.Uint64();
+    case "float16":
+      return new arrow5.Float16();
+    case "float32":
+      return new arrow5.Float32();
+    case "float64":
+      return new arrow5.Float64();
+    case "utf8":
+      return new arrow5.Utf8();
+    case "date-day":
+      return new arrow5.DateDay();
+    case "date-millisecond":
+      return new arrow5.DateMillisecond();
+    case "time-second":
+      return new arrow5.TimeSecond();
+    case "time-millisecond":
+      return new arrow5.TimeMillisecond();
+    case "time-microsecond":
+      return new arrow5.TimeMicrosecond();
+    case "time-nanosecond":
+      return new arrow5.TimeNanosecond();
+    case "timestamp-second":
+      return new arrow5.TimestampSecond();
+    case "timestamp-millisecond":
+      return new arrow5.TimestampMillisecond();
+    case "timestamp-microsecond":
+      return new arrow5.TimestampMicrosecond();
+    case "timestamp-nanosecond":
+      return new arrow5.TimestampNanosecond();
+    case "interval-daytime":
+      return new arrow5.IntervalDayTime();
+    case "interval-yearmonth":
+      return new arrow5.IntervalYearMonth();
     default:
       throw new Error("array type not supported");
   }
@@ -211,24 +474,24 @@ var VECTOR_TYPES = /* @__PURE__ */ ((VECTOR_TYPES2) => {
 })(VECTOR_TYPES || {});
 
 // src/lib/encode-arrow.ts
-var import_apache_arrow5 = require("apache-arrow");
+var arrow6 = __toESM(require("apache-arrow"), 1);
 function encodeArrowSync(data) {
   const vectors = {};
   for (const arrayData of data) {
     const arrayVector = createVector(arrayData.array, arrayData.type);
     vectors[arrayData.name] = arrayVector;
   }
-  const table = new import_apache_arrow5.Table(vectors);
-  const arrowBuffer = (0, import_apache_arrow5.tableToIPC)(table);
+  const table = new arrow6.Table(vectors);
+  const arrowBuffer = arrow6.tableToIPC(table);
   return arrowBuffer;
 }
 function createVector(array, type) {
   switch (type) {
     case 1 /* DATE */:
-      return (0, import_apache_arrow5.vectorFromArray)(array);
+      return arrow6.vectorFromArray(array);
     case 0 /* FLOAT */:
     default:
-      return (0, import_apache_arrow5.vectorFromArray)(array);
+      return arrow6.vectorFromArray(array);
   }
 }
 
@@ -245,12 +508,344 @@ var ArrowWriter = {
     "application/vnd.apache.arrow.stream",
     "application/octet-stream"
   ],
-  encodeSync(data, options) {
+  binary: true,
+  options: {},
+  encode: async function encodeArrow(data, options) {
     return encodeArrowSync(data);
   },
-  binary: true,
-  options: {}
+  encodeSync(data, options) {
+    return encodeArrowSync(data);
+  }
+};
+
+// src/geoarrow/get-arrow-bounds.ts
+function updateBoundsFromGeoArrowSamples(flatCoords, nDim, bounds, sampleSize = 100) {
+  const numberOfFeatures = flatCoords.length / nDim;
+  const sampleStep = Math.max(Math.floor(numberOfFeatures / sampleSize), 1);
+  const newBounds = [...bounds];
+  for (let i = 0; i < numberOfFeatures; i += sampleStep) {
+    const lng = flatCoords[i * nDim];
+    const lat = flatCoords[i * nDim + 1];
+    if (lng < newBounds[0]) {
+      newBounds[0] = lng;
+    }
+    if (lat < newBounds[1]) {
+      newBounds[1] = lat;
+    }
+    if (lng > newBounds[2]) {
+      newBounds[2] = lng;
+    }
+    if (lat > newBounds[3]) {
+      newBounds[3] = lat;
+    }
+  }
+  return newBounds;
+}
+
+// src/geoarrow/convert-geoarrow-to-binary-geometry.ts
+var BINARY_GEOMETRY_TEMPLATE = {
+  globalFeatureIds: { value: new Uint32Array(0), size: 1 },
+  positions: { value: new Float32Array(0), size: 2 },
+  properties: [],
+  numericProps: {},
+  featureIds: { value: new Uint32Array(0), size: 1 }
 };
+function getBinaryGeometriesFromArrow(geoColumn, geoEncoding) {
+  const featureTypes = {
+    polygon: geoEncoding === "geoarrow.multipolygon" || geoEncoding === "geoarrow.polygon",
+    point: geoEncoding === "geoarrow.multipoint" || geoEncoding === "geoarrow.point",
+    line: geoEncoding === "geoarrow.multilinestring" || geoEncoding === "geoarrow.linestring"
+  };
+  const chunks = geoColumn.data;
+  let bounds = [Infinity, Infinity, -Infinity, -Infinity];
+  let globalFeatureIdOffset = 0;
+  const binaryGeometries = [];
+  chunks.forEach((chunk) => {
+    const { featureIds, flatCoordinateArray, nDim, geomOffset } = getBinaryGeometriesFromChunk(
+      chunk,
+      geoEncoding
+    );
+    const numOfVertices = flatCoordinateArray.length / nDim;
+    const globalFeatureIds = new Uint32Array(numOfVertices);
+    for (let i = 0; i < numOfVertices; i++) {
+      globalFeatureIds[i] = featureIds[i] + globalFeatureIdOffset;
+    }
+    const binaryContent = {
+      globalFeatureIds: { value: globalFeatureIds, size: 1 },
+      positions: {
+        value: flatCoordinateArray,
+        size: nDim
+      },
+      featureIds: { value: featureIds, size: 1 },
+      properties: [...Array(chunk.length).keys()].map((i) => ({
+        index: i + globalFeatureIdOffset
+      }))
+    };
+    globalFeatureIdOffset += chunk.length;
+    binaryGeometries.push({
+      shape: "binary-feature-collection",
+      points: {
+        type: "Point",
+        ...BINARY_GEOMETRY_TEMPLATE,
+        ...featureTypes.point ? binaryContent : {}
+      },
+      lines: {
+        type: "LineString",
+        ...BINARY_GEOMETRY_TEMPLATE,
+        ...featureTypes.line ? binaryContent : {},
+        pathIndices: { value: featureTypes.line ? geomOffset : new Uint16Array(0), size: 1 }
+      },
+      polygons: {
+        type: "Polygon",
+        ...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
+          value: featureTypes.polygon ? geomOffset : new Uint16Array(0),
+          size: 1
+        },
+        primitivePolygonIndices: {
+          value: featureTypes.polygon ? geomOffset : new Uint16Array(0),
+          size: 1
+        }
+      }
+    });
+    bounds = updateBoundsFromGeoArrowSamples(flatCoordinateArray, nDim, bounds);
+  });
+  return { binaryGeometries, bounds, featureTypes };
+}
+function getBinaryGeometriesFromChunk(chunk, geoEncoding) {
+  switch (geoEncoding) {
+    case "geoarrow.point":
+    case "geoarrow.multipoint":
+      return getBinaryPointsFromChunk(chunk, geoEncoding);
+    case "geoarrow.linestring":
+    case "geoarrow.multilinestring":
+      return getBinaryLinesFromChunk(chunk, geoEncoding);
+    case "geoarrow.polygon":
+    case "geoarrow.multipolygon":
+      return getBinaryPolygonsFromChunk(chunk, geoEncoding);
+    default:
+      throw Error("invalid geoarrow encoding");
+  }
+}
+function getBinaryPolygonsFromChunk(chunk, geoEncoding) {
+  const isMultiPolygon = geoEncoding === "geoarrow.multipolygon";
+  const polygonData = isMultiPolygon ? chunk.children[0] : chunk;
+  const ringData = polygonData.children[0];
+  const pointData = ringData.children[0];
+  const coordData = pointData.children[0];
+  const nDim = pointData.stride;
+  const geomOffset = ringData.valueOffsets;
+  const flatCoordinateArray = coordData.values;
+  const geometryIndicies = new Uint16Array(chunk.length + 1);
+  for (let i = 0; i < chunk.length; i++) {
+    geometryIndicies[i] = geomOffset[chunk.valueOffsets[i]];
+  }
+  geometryIndicies[chunk.length] = flatCoordinateArray.length / nDim;
+  const numOfVertices = flatCoordinateArray.length / nDim;
+  const featureIds = new Uint32Array(numOfVertices);
+  for (let i = 0; i < chunk.length - 1; i++) {
+    const startIdx = geomOffset[chunk.valueOffsets[i]];
+    const endIdx = geomOffset[chunk.valueOffsets[i + 1]];
+    for (let j = startIdx; j < endIdx; j++) {
+      featureIds[j] = i;
+    }
+  }
+  return {
+    featureIds,
+    flatCoordinateArray,
+    nDim,
+    geomOffset,
+    geometryIndicies
+  };
+}
+function getBinaryLinesFromChunk(chunk, geoEncoding) {
+  const isMultiLineString = geoEncoding === "geoarrow.multilinestring";
+  const lineData = isMultiLineString ? chunk.children[0] : chunk;
+  const pointData = lineData.children[0];
+  const coordData = pointData.children[0];
+  const nDim = pointData.stride;
+  const geomOffset = lineData.valueOffsets;
+  const flatCoordinateArray = coordData.values;
+  const geometryIndicies = new Uint16Array(0);
+  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;
+    }
+  }
+  return {
+    featureIds,
+    flatCoordinateArray,
+    nDim,
+    geomOffset,
+    geometryIndicies
+  };
+}
+function getBinaryPointsFromChunk(chunk, geoEncoding) {
+  const isMultiPoint = geoEncoding === "geoarrow.multipoint";
+  const pointData = isMultiPoint ? chunk.children[0] : chunk;
+  const coordData = pointData.children[0];
+  const nDim = pointData.stride;
+  const flatCoordinateArray = coordData.values;
+  const geometryIndicies = new Uint16Array(0);
+  const geomOffset = new Int32Array(0);
+  const numOfVertices = flatCoordinateArray.length / nDim;
+  const featureIds = new Uint32Array(numOfVertices);
+  for (let i = 0; i < chunk.length; i++) {
+    featureIds[i] = i;
+  }
+  return {
+    featureIds,
+    flatCoordinateArray,
+    nDim,
+    geomOffset,
+    geometryIndicies
+  };
+}
+
+// src/geoarrow/convert-geoarrow-to-geojson.ts
+function parseGeometryFromArrow(rawData) {
+  var _a;
+  const encoding = (_a = rawData.encoding) == null ? void 0 : _a.toLowerCase();
+  const data = rawData.data;
+  if (!encoding || !data) {
+    return null;
+  }
+  let geometry;
+  switch (encoding) {
+    case "geoarrow.multipolygon":
+      geometry = arrowMultiPolygonToFeature(data);
+      break;
+    case "geoarrow.polygon":
+      geometry = arrowPolygonToFeature(data);
+      break;
+    case "geoarrow.multipoint":
+      geometry = arrowMultiPointToFeature(data);
+      break;
+    case "geoarrow.point":
+      geometry = arrowPointToFeature(data);
+      break;
+    case "geoarrow.multilinestring":
+      geometry = arrowMultiLineStringToFeature(data);
+      break;
+    case "geoarrow.linestring":
+      geometry = arrowLineStringToFeature(data);
+      break;
+    default: {
+      throw Error(`GeoArrow encoding not supported ${encoding}`);
+    }
+  }
+  return {
+    type: "Feature",
+    geometry,
+    properties: {}
+  };
+}
+function arrowMultiPolygonToFeature(arrowMultiPolygon) {
+  const multiPolygon = [];
+  for (let m = 0; m < arrowMultiPolygon.length; m++) {
+    const arrowPolygon = arrowMultiPolygon.get(m);
+    const polygon = [];
+    for (let i = 0; arrowPolygon && i < (arrowPolygon == null ? void 0 : arrowPolygon.length); i++) {
+      const arrowRing = arrowPolygon == null ? void 0 : arrowPolygon.get(i);
+      const ring = [];
+      for (let j = 0; arrowRing && j < arrowRing.length; j++) {
+        const arrowCoord = arrowRing.get(j);
+        const coord = Array.from(arrowCoord);
+        ring.push(coord);
+      }
+      polygon.push(ring);
+    }
+    multiPolygon.push(polygon);
+  }
+  const geometry = {
+    type: "MultiPolygon",
+    coordinates: multiPolygon
+  };
+  return geometry;
+}
+function arrowPolygonToFeature(arrowPolygon) {
+  const polygon = [];
+  for (let i = 0; arrowPolygon && i < arrowPolygon.length; i++) {
+    const arrowRing = arrowPolygon.get(i);
+    const ring = [];
+    for (let j = 0; arrowRing && j < arrowRing.length; j++) {
+      const arrowCoord = arrowRing.get(j);
+      const coords = Array.from(arrowCoord);
+      ring.push(coords);
+    }
+    polygon.push(ring);
+  }
+  const geometry = {
+    type: "Polygon",
+    coordinates: polygon
+  };
+  return geometry;
+}
+function arrowMultiPointToFeature(arrowMultiPoint) {
+  const multiPoint = [];
+  for (let i = 0; arrowMultiPoint && i < arrowMultiPoint.length; i++) {
+    const arrowPoint = arrowMultiPoint.get(i);
+    if (arrowPoint) {
+      const coord = Array.from(arrowPoint);
+      multiPoint.push(coord);
+    }
+  }
+  const geometry = {
+    type: "MultiPoint",
+    coordinates: multiPoint
+  };
+  return geometry;
+}
+function arrowPointToFeature(arrowPoint) {
+  const point = Array.from(arrowPoint);
+  const geometry = {
+    type: "Point",
+    coordinates: point
+  };
+  return geometry;
+}
+function arrowMultiLineStringToFeature(arrowMultiLineString) {
+  const multiLineString = [];
+  for (let i = 0; arrowMultiLineString && i < arrowMultiLineString.length; i++) {
+    const arrowLineString = arrowMultiLineString.get(i);
+    const lineString = [];
+    for (let j = 0; arrowLineString && j < arrowLineString.length; j++) {
+      const arrowCoord = arrowLineString.get(j);
+      if (arrowCoord) {
+        const coords = Array.from(arrowCoord);
+        lineString.push(coords);
+      }
+    }
+    multiLineString.push(lineString);
+  }
+  const geometry = {
+    type: "MultiLineString",
+    coordinates: multiLineString
+  };
+  return geometry;
+}
+function arrowLineStringToFeature(arrowLineString) {
+  const lineString = [];
+  for (let i = 0; arrowLineString && i < arrowLineString.length; i++) {
+    const arrowCoord = arrowLineString.get(i);
+    if (arrowCoord) {
+      const coords = Array.from(arrowCoord);
+      lineString.push(coords);
+    }
+  }
+  const geometry = {
+    type: "LineString",
+    coordinates: lineString
+  };
+  return geometry;
+}
 
 // src/index.ts
 import_schema3.TableBatchBuilder.ArrowBatch = ArrowTableBatchAggregator;