@loaders.gl/arrow 4.0.1 → 4.0.3

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,6 +33,7 @@ __export(src_exports, {
   ArrowLoader: () => ArrowLoader2,
   ArrowWorkerLoader: () => ArrowLoader,
   ArrowWriter: () => ArrowWriter,
+  BINARY_GEOMETRY_TEMPLATE: () => BINARY_GEOMETRY_TEMPLATE,
   VECTOR_TYPES: () => VECTOR_TYPES,
   deserializeArrowField: () => deserializeArrowField,
   deserializeArrowMetadata: () => deserializeArrowMetadata,
@@ -34,7 +45,8 @@ __export(src_exports, {
   serializeArrowField: () => serializeArrowField,
   serializeArrowMetadata: () => serializeArrowMetadata,
   serializeArrowSchema: () => serializeArrowSchema,
-  serializeArrowType: () => serializeArrowType
+  serializeArrowType: () => serializeArrowType,
+  updateBoundsFromGeoArrowSamples: () => updateBoundsFromGeoArrowSamples
 });
 module.exports = __toCommonJS(src_exports);
 var import_schema3 = require("@loaders.gl/schema");
@@ -65,7 +77,7 @@ 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/tables/convert-arrow-to-table.ts
 function convertApacheArrowToArrowTable(arrowTable) {
@@ -91,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) {
@@ -108,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;
@@ -130,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);
@@ -141,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
       };
     }
@@ -164,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);
     }
   }
@@ -189,32 +201,32 @@ 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 import_apache_arrow5 = require("apache-arrow");
+var arrow5 = __toESM(require("apache-arrow"), 1);
 function serializeArrowSchema(arrowSchema) {
   return {
     fields: arrowSchema.fields.map((arrowField) => serializeArrowField(arrowField)),
@@ -222,7 +234,7 @@ function serializeArrowSchema(arrowSchema) {
   };
 }
 function deserializeArrowSchema(schema) {
-  return new import_apache_arrow5.Schema(
+  return new arrow5.Schema(
     schema.fields.map((field) => deserializeArrowField(field)),
     deserializeArrowMetadata(schema.metadata)
   );
@@ -242,7 +254,7 @@ function serializeArrowField(field) {
   };
 }
 function deserializeArrowField(field) {
-  return new import_apache_arrow5.Field(
+  return new arrow5.Field(
     field.name,
     deserializeArrowType(field.type),
     field.nullable,
@@ -251,204 +263,231 @@ function deserializeArrowField(field) {
 }
 function serializeArrowType(arrowType) {
   switch (arrowType.constructor) {
-    case import_apache_arrow5.Null:
+    case arrow5.Null:
       return "null";
-    case import_apache_arrow5.Binary:
+    case arrow5.Binary:
       return "binary";
-    case import_apache_arrow5.Bool:
+    case arrow5.Bool:
       return "bool";
-    case import_apache_arrow5.Int:
+    case arrow5.Int:
       const intType = arrowType;
       return `${intType.isSigned ? "u" : ""}int${intType.bitWidth}`;
-    case import_apache_arrow5.Int8:
+    case arrow5.Int8:
       return "int8";
-    case import_apache_arrow5.Int16:
+    case arrow5.Int16:
       return "int16";
-    case import_apache_arrow5.Int32:
+    case arrow5.Int32:
       return "int32";
-    case import_apache_arrow5.Int64:
+    case arrow5.Int64:
       return "int64";
-    case import_apache_arrow5.Uint8:
+    case arrow5.Uint8:
       return "uint8";
-    case import_apache_arrow5.Uint16:
+    case arrow5.Uint16:
       return "uint16";
-    case import_apache_arrow5.Uint32:
+    case arrow5.Uint32:
       return "uint32";
-    case import_apache_arrow5.Uint64:
+    case arrow5.Uint64:
       return "uint64";
-    case import_apache_arrow5.Float:
+    case arrow5.Float:
       const precision = arrowType.precision;
       switch (precision) {
-        case import_apache_arrow5.Precision.HALF:
+        case arrow5.Precision.HALF:
           return "float16";
-        case import_apache_arrow5.Precision.SINGLE:
+        case arrow5.Precision.SINGLE:
           return "float32";
-        case import_apache_arrow5.Precision.DOUBLE:
+        case arrow5.Precision.DOUBLE:
           return "float64";
         default:
           return "float16";
       }
-    case import_apache_arrow5.Float16:
+    case arrow5.Float16:
       return "float16";
-    case import_apache_arrow5.Float32:
+    case arrow5.Float32:
       return "float32";
-    case import_apache_arrow5.Float64:
+    case arrow5.Float64:
       return "float64";
-    case import_apache_arrow5.Utf8:
+    case arrow5.Utf8:
       return "utf8";
-    case Date:
+    case arrow5.Decimal:
+      const decimal = arrowType;
+      return {
+        type: "decimal",
+        bitWidth: decimal.bitWidth,
+        precision: decimal.precision,
+        scale: decimal.scale
+      };
+    case arrow5.Date_:
       const dateUnit = arrowType.unit;
-      return dateUnit === import_apache_arrow5.DateUnit.DAY ? "date-day" : "date-millisecond";
-    case import_apache_arrow5.DateDay:
+      return dateUnit === arrow5.DateUnit.DAY ? "date-day" : "date-millisecond";
+    case arrow5.DateDay:
       return "date-day";
-    case import_apache_arrow5.DateMillisecond:
+    case arrow5.DateMillisecond:
       return "date-millisecond";
-    case import_apache_arrow5.Time:
+    case arrow5.Time:
       const timeUnit = arrowType.unit;
       switch (timeUnit) {
-        case import_apache_arrow5.TimeUnit.SECOND:
+        case arrow5.TimeUnit.SECOND:
           return "time-second";
-        case import_apache_arrow5.TimeUnit.MILLISECOND:
+        case arrow5.TimeUnit.MILLISECOND:
           return "time-millisecond";
-        case import_apache_arrow5.TimeUnit.MICROSECOND:
+        case arrow5.TimeUnit.MICROSECOND:
           return "time-microsecond";
-        case import_apache_arrow5.TimeUnit.NANOSECOND:
+        case arrow5.TimeUnit.NANOSECOND:
           return "time-nanosecond";
         default:
           return "time-second";
       }
-    case import_apache_arrow5.TimeMillisecond:
+    case arrow5.TimeMillisecond:
       return "time-millisecond";
-    case import_apache_arrow5.TimeSecond:
+    case arrow5.TimeSecond:
       return "time-second";
-    case import_apache_arrow5.TimeMicrosecond:
+    case arrow5.TimeMicrosecond:
       return "time-microsecond";
-    case import_apache_arrow5.TimeNanosecond:
+    case arrow5.TimeNanosecond:
       return "time-nanosecond";
-    case import_apache_arrow5.Timestamp:
+    case arrow5.Timestamp:
       const timeStampUnit = arrowType.unit;
       switch (timeStampUnit) {
-        case import_apache_arrow5.TimeUnit.SECOND:
+        case arrow5.TimeUnit.SECOND:
           return "timestamp-second";
-        case import_apache_arrow5.TimeUnit.MILLISECOND:
+        case arrow5.TimeUnit.MILLISECOND:
           return "timestamp-millisecond";
-        case import_apache_arrow5.TimeUnit.MICROSECOND:
+        case arrow5.TimeUnit.MICROSECOND:
           return "timestamp-microsecond";
-        case import_apache_arrow5.TimeUnit.NANOSECOND:
+        case arrow5.TimeUnit.NANOSECOND:
           return "timestamp-nanosecond";
         default:
           return "timestamp-second";
       }
-    case import_apache_arrow5.TimestampSecond:
+    case arrow5.TimestampSecond:
       return "timestamp-second";
-    case import_apache_arrow5.TimestampMillisecond:
+    case arrow5.TimestampMillisecond:
       return "timestamp-millisecond";
-    case import_apache_arrow5.TimestampMicrosecond:
+    case arrow5.TimestampMicrosecond:
       return "timestamp-microsecond";
-    case import_apache_arrow5.TimestampNanosecond:
+    case arrow5.TimestampNanosecond:
       return "timestamp-nanosecond";
-    case import_apache_arrow5.Interval:
+    case arrow5.Interval:
       const intervalUnit = arrowType.unit;
       switch (intervalUnit) {
-        case import_apache_arrow5.IntervalUnit.DAY_TIME:
+        case arrow5.IntervalUnit.DAY_TIME:
           return "interval-daytime";
-        case import_apache_arrow5.IntervalUnit.YEAR_MONTH:
+        case arrow5.IntervalUnit.YEAR_MONTH:
           return "interval-yearmonth";
         default:
           return "interval-daytime";
       }
-    case import_apache_arrow5.IntervalDayTime:
+    case arrow5.IntervalDayTime:
       return "interval-daytime";
-    case import_apache_arrow5.IntervalYearMonth:
+    case arrow5.IntervalYearMonth:
       return "interval-yearmonth";
-    case import_apache_arrow5.List:
+    case arrow5.Map_:
+      const mapType = arrowType;
+      return {
+        type: "map",
+        keysSorted: mapType.keysSorted,
+        children: mapType.children.map((arrowField) => serializeArrowField(arrowField))
+      };
+    case arrow5.List:
       const listType = arrowType;
       const listField = listType.valueField;
       return {
         type: "list",
         children: [serializeArrowField(listField)]
       };
-    case import_apache_arrow5.FixedSizeList:
+    case arrow5.FixedSizeList:
+      const fixedSizeList = arrowType;
       return {
         type: "fixed-size-list",
-        listSize: arrowType.listSize,
-        children: [serializeArrowField(arrowType.children[0])]
+        listSize: fixedSizeList.listSize,
+        children: [serializeArrowField(fixedSizeList.children[0])]
+      };
+    case arrow5.Struct:
+      const structType = arrowType;
+      return {
+        type: "struct",
+        children: structType.children.map((arrowField) => serializeArrowField(arrowField))
       };
     default:
-      throw new Error("array type not supported");
+      throw new Error(`arrow type not supported: ${arrowType.constructor.name}`);
   }
 }
 function deserializeArrowType(dataType) {
   if (typeof dataType === "object") {
     switch (dataType.type) {
+      case "decimal":
+        return new arrow5.Decimal(dataType.precision, dataType.scale, dataType.bitWidth);
+      case "map":
+        let children = dataType.children.map((arrowField) => deserializeArrowField(arrowField));
+        return new arrow5.Map_(children, dataType.keysSorted);
       case "list":
         const field = deserializeArrowField(dataType.children[0]);
-        return new import_apache_arrow5.List(field);
+        return new arrow5.List(field);
       case "fixed-size-list":
         const child = deserializeArrowField(dataType.children[0]);
-        return new import_apache_arrow5.FixedSizeList(dataType.listSize, child);
+        return new arrow5.FixedSizeList(dataType.listSize, child);
       case "struct":
-        const children = dataType.children.map((arrowField) => deserializeArrowField(arrowField));
-        return new import_apache_arrow5.Struct(children);
+        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 import_apache_arrow5.Null();
+      return new arrow5.Null();
     case "binary":
-      return new import_apache_arrow5.Binary();
+      return new arrow5.Binary();
     case "bool":
-      return new import_apache_arrow5.Bool();
+      return new arrow5.Bool();
     case "int8":
-      return new import_apache_arrow5.Int8();
+      return new arrow5.Int8();
     case "int16":
-      return new import_apache_arrow5.Int16();
+      return new arrow5.Int16();
     case "int32":
-      return new import_apache_arrow5.Int32();
+      return new arrow5.Int32();
     case "int64":
-      return new import_apache_arrow5.Int64();
+      return new arrow5.Int64();
     case "uint8":
-      return new import_apache_arrow5.Uint8();
+      return new arrow5.Uint8();
     case "uint16":
-      return new import_apache_arrow5.Uint16();
+      return new arrow5.Uint16();
     case "uint32":
-      return new import_apache_arrow5.Uint32();
+      return new arrow5.Uint32();
     case "uint64":
-      return new import_apache_arrow5.Uint64();
+      return new arrow5.Uint64();
     case "float16":
-      return new import_apache_arrow5.Float16();
+      return new arrow5.Float16();
     case "float32":
-      return new import_apache_arrow5.Float32();
+      return new arrow5.Float32();
     case "float64":
-      return new import_apache_arrow5.Float64();
+      return new arrow5.Float64();
     case "utf8":
-      return new import_apache_arrow5.Utf8();
+      return new arrow5.Utf8();
     case "date-day":
-      return new import_apache_arrow5.DateDay();
+      return new arrow5.DateDay();
     case "date-millisecond":
-      return new import_apache_arrow5.DateMillisecond();
+      return new arrow5.DateMillisecond();
     case "time-second":
-      return new import_apache_arrow5.TimeSecond();
+      return new arrow5.TimeSecond();
     case "time-millisecond":
-      return new import_apache_arrow5.TimeMillisecond();
+      return new arrow5.TimeMillisecond();
     case "time-microsecond":
-      return new import_apache_arrow5.TimeMicrosecond();
+      return new arrow5.TimeMicrosecond();
     case "time-nanosecond":
-      return new import_apache_arrow5.TimeNanosecond();
+      return new arrow5.TimeNanosecond();
     case "timestamp-second":
-      return new import_apache_arrow5.TimestampSecond();
+      return new arrow5.TimestampSecond();
     case "timestamp-millisecond":
-      return new import_apache_arrow5.TimestampMillisecond();
+      return new arrow5.TimestampMillisecond();
     case "timestamp-microsecond":
-      return new import_apache_arrow5.TimestampMicrosecond();
+      return new arrow5.TimestampMicrosecond();
     case "timestamp-nanosecond":
-      return new import_apache_arrow5.TimestampNanosecond();
+      return new arrow5.TimestampNanosecond();
     case "interval-daytime":
-      return new import_apache_arrow5.IntervalDayTime();
+      return new arrow5.IntervalDayTime();
     case "interval-yearmonth":
-      return new import_apache_arrow5.IntervalYearMonth();
+      return new arrow5.IntervalYearMonth();
     default:
       throw new Error("array type not supported");
   }
@@ -462,24 +501,24 @@ var VECTOR_TYPES = /* @__PURE__ */ ((VECTOR_TYPES2) => {
 })(VECTOR_TYPES || {});
 
 // src/lib/encode-arrow.ts
-var import_apache_arrow6 = 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_arrow6.Table(vectors);
-  const arrowBuffer = (0, import_apache_arrow6.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_arrow6.vectorFromArray)(array);
+      return arrow6.vectorFromArray(array);
     case 0 /* FLOAT */:
     default:
-      return (0, import_apache_arrow6.vectorFromArray)(array);
+      return arrow6.vectorFromArray(array);
   }
 }
 
@@ -496,11 +535,14 @@ 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
@@ -511,7 +553,7 @@ function updateBoundsFromGeoArrowSamples(flatCoords, nDim, bounds, sampleSize =
   for (let i = 0; i < numberOfFeatures; i += sampleStep) {
     const lng = flatCoords[i * nDim];
     const lat = flatCoords[i * nDim + 1];
-    if (lng < bounds[0]) {
+    if (lng < newBounds[0]) {
       newBounds[0] = lng;
     }
     if (lat < newBounds[1]) {
@@ -542,18 +584,16 @@ function getBinaryGeometriesFromArrow(geoColumn, geoEncoding) {
     line: geoEncoding === "geoarrow.multilinestring" || geoEncoding === "geoarrow.linestring"
   };
   const chunks = geoColumn.data;
-  const bounds = [Infinity, Infinity, -Infinity, -Infinity];
+  let bounds = [Infinity, Infinity, -Infinity, -Infinity];
   let globalFeatureIdOffset = 0;
   const binaryGeometries = [];
-  for (let c = 0; c < chunks.length; c++) {
-    const geometries = chunks[c];
+  chunks.forEach((chunk) => {
     const { featureIds, flatCoordinateArray, nDim, geomOffset } = getBinaryGeometriesFromChunk(
-      geometries,
+      chunk,
       geoEncoding
     );
-    const numOfVertices = flatCoordinateArray.length / nDim;
-    const globalFeatureIds = new Uint32Array(numOfVertices);
-    for (let i = 0; i < numOfVertices; i++) {
+    const globalFeatureIds = new Uint32Array(featureIds.length);
+    for (let i = 0; i < featureIds.length; i++) {
       globalFeatureIds[i] = featureIds[i] + globalFeatureIdOffset;
     }
     const binaryContent = {
@@ -563,12 +603,11 @@ function getBinaryGeometriesFromArrow(geoColumn, geoEncoding) {
         size: nDim
       },
       featureIds: { value: featureIds, size: 1 },
-      // eslint-disable-next-line no-loop-func
-      properties: [...Array(geometries.length).keys()].map((i) => ({
+      properties: [...Array(chunk.length).keys()].map((i) => ({
         index: i + globalFeatureIdOffset
       }))
     };
-    globalFeatureIdOffset += geometries.length;
+    globalFeatureIdOffset += chunk.length;
     binaryGeometries.push({
       shape: "binary-feature-collection",
       points: {
@@ -598,8 +637,8 @@ function getBinaryGeometriesFromArrow(geoColumn, geoEncoding) {
         }
       }
     });
-    updateBoundsFromGeoArrowSamples(flatCoordinateArray, nDim, bounds);
-  }
+    bounds = updateBoundsFromGeoArrowSamples(flatCoordinateArray, nDim, bounds);
+  });
   return { binaryGeometries, bounds, featureTypes };
 }
 function getBinaryGeometriesFromChunk(chunk, geoEncoding) {
@@ -620,22 +659,23 @@ function getBinaryGeometriesFromChunk(chunk, geoEncoding) {
 function getBinaryPolygonsFromChunk(chunk, geoEncoding) {
   const isMultiPolygon = geoEncoding === "geoarrow.multipolygon";
   const polygonData = isMultiPolygon ? chunk.children[0] : chunk;
+  const polygonOffset = polygonData.valueOffsets;
+  const partData = isMultiPolygon ? chunk.valueOffsets.map((i) => polygonOffset.at(i) || i) : chunk.valueOffsets;
   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]];
+  const geometryIndicies = new Uint16Array(polygonOffset.length);
+  for (let i = 0; i < polygonOffset.length; i++) {
+    geometryIndicies[i] = geomOffset[polygonOffset[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 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;
     }

package/dist/index.d.ts

@@ -14,6 +14,7 @@ export { ArrowWorkerLoader };
 export declare const ArrowLoader: LoaderWithParser<ArrowTable | ColumnarTable | ObjectRowTable, ArrowTableBatch, ArrowLoaderOptions>;
 export type { GeoArrowEncoding } from '@loaders.gl/gis';
 export type { BinaryDataFromGeoArrow } from './geoarrow/convert-geoarrow-to-binary-geometry';
-export { getBinaryGeometriesFromArrow } from './geoarrow/convert-geoarrow-to-binary-geometry';
+export { BINARY_GEOMETRY_TEMPLATE, getBinaryGeometriesFromArrow } from './geoarrow/convert-geoarrow-to-binary-geometry';
 export { parseGeometryFromArrow } from './geoarrow/convert-geoarrow-to-geojson';
+export { updateBoundsFromGeoArrowSamples } from './geoarrow/get-arrow-bounds';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAC/D,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,gBAAgB,CAAC;AACvD,OAAO,KAAK,EAAC,eAAe,EAAE,aAAa,EAAE,cAAc,EAAC,MAAM,oBAAoB,CAAC;AACvF,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,mBAAmB,CAAC;AAGlD,OAAO,EAAC,WAAW,IAAI,iBAAiB,EAAC,MAAM,gBAAgB,CAAC;AAWhE,OAAO,EAAC,YAAY,EAAC,MAAM,2BAA2B,CAAC;AAIvD,OAAO,EACL,oBAAoB,EACpB,sBAAsB,EACtB,sBAAsB,EACtB,wBAAwB,EACxB,mBAAmB,EACnB,qBAAqB,EACrB,kBAAkB,EAClB,oBAAoB,EACrB,MAAM,+BAA+B,CAAC;AAGvC,YAAY,EAAC,UAAU,EAAE,eAAe,EAAC,MAAM,mBAAmB,CAAC;AACnE,OAAO,EAAC,YAAY,EAAC,MAAM,SAAS,CAAC;AAIrC,OAAO,EAAC,WAAW,EAAC,MAAM,gBAAgB,CAAC;AAI3C,YAAY,EAAC,kBAAkB,EAAC,CAAC;AACjC,OAAO,EAAC,iBAAiB,EAAC,CAAC;AAE3B,2BAA2B;AAC3B,eAAO,MAAM,WAAW,EAAE,gBAAgB,CACxC,UAAU,GAAG,aAAa,GAAG,cAAc,EAC3C,eAAe,EACf,kBAAkB,CAOnB,CAAC;AAGF,YAAY,EAAC,gBAAgB,EAAC,MAAM,iBAAiB,CAAC;AAItD,YAAY,EAAC,sBAAsB,EAAC,MAAM,gDAAgD,CAAC;AAC3F,OAAO,EAAC,4BAA4B,EAAC,MAAM,gDAAgD,CAAC;AAE5F,OAAO,EAAC,sBAAsB,EAAC,MAAM,wCAAwC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAC/D,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,gBAAgB,CAAC;AACvD,OAAO,KAAK,EAAC,eAAe,EAAE,aAAa,EAAE,cAAc,EAAC,MAAM,oBAAoB,CAAC;AACvF,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,mBAAmB,CAAC;AAGlD,OAAO,EAAC,WAAW,IAAI,iBAAiB,EAAC,MAAM,gBAAgB,CAAC;AAWhE,OAAO,EAAC,YAAY,EAAC,MAAM,2BAA2B,CAAC;AAIvD,OAAO,EACL,oBAAoB,EACpB,sBAAsB,EACtB,sBAAsB,EACtB,wBAAwB,EACxB,mBAAmB,EACnB,qBAAqB,EACrB,kBAAkB,EAClB,oBAAoB,EACrB,MAAM,+BAA+B,CAAC;AAGvC,YAAY,EAAC,UAAU,EAAE,eAAe,EAAC,MAAM,mBAAmB,CAAC;AACnE,OAAO,EAAC,YAAY,EAAC,MAAM,SAAS,CAAC;AAIrC,OAAO,EAAC,WAAW,EAAC,MAAM,gBAAgB,CAAC;AAI3C,YAAY,EAAC,kBAAkB,EAAC,CAAC;AACjC,OAAO,EAAC,iBAAiB,EAAC,CAAC;AAE3B,2BAA2B;AAC3B,eAAO,MAAM,WAAW,EAAE,gBAAgB,CACxC,UAAU,GAAG,aAAa,GAAG,cAAc,EAC3C,eAAe,EACf,kBAAkB,CAOnB,CAAC;AAGF,YAAY,EAAC,gBAAgB,EAAC,MAAM,iBAAiB,CAAC;AAItD,YAAY,EAAC,sBAAsB,EAAC,MAAM,gDAAgD,CAAC;AAC3F,OAAO,EACL,wBAAwB,EACxB,4BAA4B,EAC7B,MAAM,gDAAgD,CAAC;AAExD,OAAO,EAAC,sBAAsB,EAAC,MAAM,wCAAwC,CAAC;AAE9E,OAAO,EAAC,+BAA+B,EAAC,MAAM,6BAA6B,CAAC"}