@loaders.gl/arrow 4.0.2 → 4.0.4

package/dist/index.cjs

@@ -30,120 +30,38 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  ArrowLoader: () => ArrowLoader2,
-  ArrowWorkerLoader: () => ArrowLoader,
+  ArrowLoader: () => ArrowLoader,
+  ArrowWorkerLoader: () => ArrowWorkerLoader,
   ArrowWriter: () => ArrowWriter,
   BINARY_GEOMETRY_TEMPLATE: () => BINARY_GEOMETRY_TEMPLATE,
+  GeoArrowLoader: () => GeoArrowLoader,
+  GeoArrowWorkerLoader: () => GeoArrowWorkerLoader,
+  TriangulationWorker: () => TriangulationWorker,
   VECTOR_TYPES: () => VECTOR_TYPES,
+  convertArrowToGeoJSONTable: () => convertArrowToGeoJSONTable,
   deserializeArrowField: () => deserializeArrowField,
   deserializeArrowMetadata: () => deserializeArrowMetadata,
   deserializeArrowSchema: () => deserializeArrowSchema,
   deserializeArrowType: () => deserializeArrowType,
   getArrowType: () => getArrowType,
   getBinaryGeometriesFromArrow: () => getBinaryGeometriesFromArrow,
-  parseGeometryFromArrow: () => parseGeometryFromArrow,
+  getMeanCentersFromBinaryGeometries: () => getMeanCentersFromBinaryGeometries,
+  getTriangleIndices: () => getTriangleIndices,
+  parseGeometryFromArrow: () => parseGeometryFromArrow2,
   serializeArrowField: () => serializeArrowField,
   serializeArrowMetadata: () => serializeArrowMetadata,
-  serializeArrowSchema: () => serializeArrowSchema,
+  serializeArrowSchema: () => serializeArrowSchema2,
   serializeArrowType: () => serializeArrowType,
+  triangulateOnWorker: () => triangulateOnWorker,
   updateBoundsFromGeoArrowSamples: () => updateBoundsFromGeoArrowSamples
 });
 module.exports = __toCommonJS(src_exports);
 var import_schema3 = require("@loaders.gl/schema");
 
-// src/arrow-loader.ts
-var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-var ArrowLoader = {
-  name: "Apache Arrow",
-  id: "arrow",
-  module: "arrow",
-  version: VERSION,
-  // worker: true,
-  category: "table",
-  extensions: ["arrow", "feather"],
-  mimeTypes: [
-    "application/vnd.apache.arrow.file",
-    "application/vnd.apache.arrow.stream",
-    "application/octet-stream"
-  ],
-  binary: true,
-  tests: ["ARROW"],
-  options: {
-    arrow: {
-      shape: "columnar-table"
-    }
-  }
-};
-
-// src/lib/parse-arrow-sync.ts
+// src/lib/arrow-table-batch.ts
 var import_schema = require("@loaders.gl/schema");
 var arrow = __toESM(require("apache-arrow"), 1);
-
-// src/tables/convert-arrow-to-table.ts
-function convertApacheArrowToArrowTable(arrowTable) {
-  return {
-    shape: "arrow-table",
-    data: arrowTable
-  };
-}
-function convertArrowToColumnarTable(table) {
-  const arrowTable = table.data;
-  const columnarTable = {};
-  for (const field of arrowTable.schema.fields) {
-    const arrowColumn = arrowTable.getChild(field.name);
-    const values = arrowColumn == null ? void 0 : arrowColumn.toArray();
-    columnarTable[field.name] = values;
-  }
-  return {
-    shape: "columnar-table",
-    data: columnarTable
-  };
-}
-
-// src/lib/parse-arrow-sync.ts
-function parseArrowSync(arrayBuffer, options) {
-  var _a;
-  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) {
-    case "arrow-table":
-      return arrowTable;
-    case "columnar-table":
-      return convertArrowToColumnarTable(arrowTable);
-    case "object-row-table":
-      const columnarTable = convertArrowToColumnarTable(arrowTable);
-      return (0, import_schema.convertTable)(columnarTable, "object-row-table");
-    default:
-      throw new Error(shape);
-  }
-}
-
-// src/lib/parse-arrow-in-batches.ts
-var arrow2 = __toESM(require("apache-arrow"), 1);
-function parseArrowInBatches(asyncIterator) {
-  async function* makeArrowAsyncIterator() {
-    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 arrow2.Table([recordBatch]),
-          length: recordBatch.data.length
-        };
-        yield arrowTabledBatch;
-      }
-      break;
-    }
-  }
-  return makeArrowAsyncIterator();
-}
-
-// src/lib/arrow-table-batch.ts
-var import_schema2 = require("@loaders.gl/schema");
-var arrow3 = __toESM(require("apache-arrow"), 1);
-var ArrowTableBatchAggregator = class extends import_schema2.ColumnarTableBatchAggregator {
+var ArrowTableBatchAggregator = class extends import_schema.ColumnarTableBatchAggregator {
   constructor(schema, options) {
     super(schema, options);
     this.arrowSchema = null;
@@ -153,17 +71,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 arrow3.RecordBatch(
+      const recordBatch = new arrow.RecordBatch(
         this.arrowSchema,
-        arrow3.makeData({
-          type: new arrow3.Struct(this.arrowSchema.fields),
+        arrow.makeData({
+          type: new arrow.Struct(this.arrowSchema.fields),
           children: arrowVectors.map(({ data }) => data[0])
         })
       );
       return {
         shape: "arrow-table",
         batchType: "data",
-        data: new arrow3.Table([recordBatch]),
+        data: new arrow.Table([recordBatch]),
         length: batch.length
       };
     }
@@ -176,21 +94,21 @@ function getArrowSchema(schema) {
     const field = schema[key];
     if (field.type === Float32Array) {
       const metadata = /* @__PURE__ */ new Map();
-      const arrowField = new arrow3.Field(field.name, new arrow3.Float32(), field.nullable, metadata);
+      const arrowField = new arrow.Field(field.name, new arrow.Float32(), field.nullable, metadata);
       arrowFields.push(arrowField);
     }
   }
   if (arrowFields.length === 0) {
     throw new Error("No arrow convertible fields");
   }
-  return new arrow3.Schema(arrowFields);
+  return new arrow.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 = arrow3.makeVector(vector);
+      const arrowVector = arrow.makeVector(vector);
       arrowVectors.push(arrowVector);
     }
   }
@@ -201,40 +119,245 @@ function getArrowVectors(arrowSchema, data) {
 }
 
 // src/schema/arrow-type-utils.ts
-var arrow4 = __toESM(require("apache-arrow"), 1);
+var arrow2 = __toESM(require("apache-arrow"), 1);
 function getArrowType(array) {
   switch (array.constructor) {
     case Int8Array:
-      return new arrow4.Int8();
+      return new arrow2.Int8();
     case Uint8Array:
-      return new arrow4.Uint8();
+      return new arrow2.Uint8();
     case Int16Array:
-      return new arrow4.Int16();
+      return new arrow2.Int16();
     case Uint16Array:
-      return new arrow4.Uint16();
+      return new arrow2.Uint16();
     case Int32Array:
-      return new arrow4.Int32();
+      return new arrow2.Int32();
     case Uint32Array:
-      return new arrow4.Uint32();
+      return new arrow2.Uint32();
     case Float32Array:
-      return new arrow4.Float32();
+      return new arrow2.Float32();
     case Float64Array:
-      return new arrow4.Float64();
+      return new arrow2.Float64();
     default:
       throw new Error("array type not supported");
   }
 }
 
-// src/schema/convert-arrow-schema.ts
+// src/types.ts
+var VECTOR_TYPES = /* @__PURE__ */ ((VECTOR_TYPES2) => {
+  VECTOR_TYPES2[VECTOR_TYPES2["FLOAT"] = 0] = "FLOAT";
+  VECTOR_TYPES2[VECTOR_TYPES2["DATE"] = 1] = "DATE";
+  return VECTOR_TYPES2;
+})(VECTOR_TYPES || {});
+
+// src/parsers/parse-arrow-sync.ts
+var import_schema2 = require("@loaders.gl/schema");
+var arrow3 = __toESM(require("apache-arrow"), 1);
+
+// src/tables/convert-arrow-to-columnar-table.ts
+function convertArrowToColumnarTable(table) {
+  const arrowTable = table.data;
+  const columnarTable = {};
+  for (const field of arrowTable.schema.fields) {
+    const arrowColumn = arrowTable.getChild(field.name);
+    const values = arrowColumn == null ? void 0 : arrowColumn.toArray();
+    columnarTable[field.name] = values;
+  }
+  return {
+    shape: "columnar-table",
+    data: columnarTable
+  };
+}
+
+// src/parsers/parse-arrow-sync.ts
+function parseArrowSync(arrayBuffer, options) {
+  const apacheArrowTable = arrow3.tableFromIPC([new Uint8Array(arrayBuffer)]);
+  const arrowTable = { shape: "arrow-table", data: apacheArrowTable };
+  const shape = (options == null ? void 0 : 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 (0, import_schema2.convertTable)(columnarTable, "object-row-table");
+    case "array-row-table":
+      columnarTable = convertArrowToColumnarTable(arrowTable);
+      return (0, import_schema2.convertTable)(columnarTable, "array-row-table");
+    default:
+      throw new Error(shape);
+  }
+}
+
+// src/parsers/parse-arrow-in-batches.ts
+var arrow4 = __toESM(require("apache-arrow"), 1);
+function parseArrowInBatches(asyncIterator) {
+  async function* makeArrowAsyncIterator() {
+    const readers = arrow4.RecordBatchReader.readAll(asyncIterator);
+    for await (const reader of readers) {
+      for await (const recordBatch of reader) {
+        const arrowTabledBatch = {
+          shape: "arrow-table",
+          batchType: "data",
+          data: new arrow4.Table([recordBatch]),
+          length: recordBatch.data.length
+        };
+        yield arrowTabledBatch;
+      }
+      break;
+    }
+  }
+  return makeArrowAsyncIterator();
+}
+
+// src/arrow-loader.ts
+var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+var ArrowWorkerLoader = {
+  name: "Apache Arrow",
+  id: "arrow",
+  module: "arrow",
+  version: VERSION,
+  // worker: true,
+  category: "table",
+  extensions: ["arrow", "feather"],
+  mimeTypes: [
+    "application/vnd.apache.arrow.file",
+    "application/vnd.apache.arrow.stream",
+    "application/octet-stream"
+  ],
+  binary: true,
+  tests: ["ARROW"],
+  options: {
+    arrow: {
+      shape: "columnar-table"
+    }
+  }
+};
+var ArrowLoader = {
+  ...ArrowWorkerLoader,
+  parse: async (arraybuffer, options) => parseArrowSync(arraybuffer, options == null ? void 0 : options.arrow),
+  parseSync: (arraybuffer, options) => parseArrowSync(arraybuffer, options == null ? void 0 : options.arrow),
+  parseInBatches: parseArrowInBatches
+};
+
+// src/lib/encode-arrow.ts
 var arrow5 = __toESM(require("apache-arrow"), 1);
-function serializeArrowSchema(arrowSchema) {
+function encodeArrowSync(data) {
+  const vectors = {};
+  for (const arrayData of data) {
+    const arrayVector = createVector(arrayData.array, arrayData.type);
+    vectors[arrayData.name] = arrayVector;
+  }
+  const table = new arrow5.Table(vectors);
+  const arrowBuffer = arrow5.tableToIPC(table);
+  return arrowBuffer;
+}
+function createVector(array, type) {
+  switch (type) {
+    case 1 /* DATE */:
+      return arrow5.vectorFromArray(array);
+    case 0 /* FLOAT */:
+    default:
+      return arrow5.vectorFromArray(array);
+  }
+}
+
+// src/arrow-writer.ts
+var VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+var ArrowWriter = {
+  name: "Apache Arrow",
+  id: "arrow",
+  module: "arrow",
+  version: VERSION2,
+  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) {
+    return encodeArrowSync(data);
+  },
+  encodeSync(data, options) {
+    return encodeArrowSync(data);
+  }
+};
+
+// src/tables/convert-arrow-to-geojson-table.ts
+var import_arrow = require("@loaders.gl/arrow");
+var import_gis = require("@loaders.gl/gis");
+function convertArrowToGeoJSONTable(table) {
+  var _a;
+  const arrowTable = table.data;
+  const schema = (0, import_arrow.serializeArrowSchema)(arrowTable.schema);
+  const geometryColumns = (0, import_gis.getGeometryColumnsFromSchema)(schema);
+  const encoding = geometryColumns.geometry.encoding;
+  const features = [];
+  for (let row = 0; row < arrowTable.numRows; row++) {
+    const arrowGeometry = (_a = arrowTable.getChild("geometry")) == null ? void 0 : _a.get(row);
+    const arrowGeometryObject = { encoding, data: arrowGeometry };
+    const feature = (0, import_arrow.parseGeometryFromArrow)(arrowGeometryObject);
+    if (feature) {
+      features.push(feature);
+    }
+  }
+  return {
+    shape: "geojson-table",
+    type: "FeatureCollection",
+    features
+  };
+}
+
+// src/parsers/parse-geoarrow-sync.ts
+function parseGeoArrowSync(arrayBuffer, options) {
+  const table = parseArrowSync(arrayBuffer, { shape: "arrow-table" });
+  switch (options == null ? void 0 : options.shape) {
+    case "geojson-table":
+      return convertArrowToGeoJSONTable(table);
+    default:
+      return table;
+  }
+}
+
+// src/parsers/parse-geoarrow-in-batches.ts
+function parseGeoArrowInBatches(asyncIterator) {
+  return parseArrowInBatches(asyncIterator);
+}
+
+// src/geoarrow-loader.ts
+var GeoArrowWorkerLoader = {
+  ...ArrowWorkerLoader,
+  options: {
+    arrow: {
+      shape: "arrow-table"
+    }
+  }
+};
+var GeoArrowLoader = {
+  ...ArrowWorkerLoader,
+  options: {
+    arrow: {
+      shape: "arrow-table"
+    }
+  },
+  parse: async (arraybuffer, options) => parseGeoArrowSync(arraybuffer, options == null ? void 0 : options.arrow),
+  parseSync: (arraybuffer, options) => parseGeoArrowSync(arraybuffer, options == null ? void 0 : options.arrow),
+  parseInBatches: parseGeoArrowInBatches
+};
+
+// src/schema/convert-arrow-schema.ts
+var arrow6 = __toESM(require("apache-arrow"), 1);
+function serializeArrowSchema2(arrowSchema) {
   return {
     fields: arrowSchema.fields.map((arrowField) => serializeArrowField(arrowField)),
     metadata: serializeArrowMetadata(arrowSchema.metadata)
   };
 }
 function deserializeArrowSchema(schema) {
-  return new arrow5.Schema(
+  return new arrow6.Schema(
     schema.fields.map((field) => deserializeArrowField(field)),
     deserializeArrowMetadata(schema.metadata)
   );
@@ -254,7 +377,7 @@ function serializeArrowField(field) {
   };
 }
 function deserializeArrowField(field) {
-  return new arrow5.Field(
+  return new arrow6.Field(
     field.name,
     deserializeArrowType(field.type),
     field.nullable,
@@ -263,260 +386,238 @@ function deserializeArrowField(field) {
 }
 function serializeArrowType(arrowType) {
   switch (arrowType.constructor) {
-    case arrow5.Null:
+    case arrow6.Null:
       return "null";
-    case arrow5.Binary:
+    case arrow6.Binary:
       return "binary";
-    case arrow5.Bool:
+    case arrow6.Bool:
       return "bool";
-    case arrow5.Int:
+    case arrow6.Int:
       const intType = arrowType;
       return `${intType.isSigned ? "u" : ""}int${intType.bitWidth}`;
-    case arrow5.Int8:
+    case arrow6.Int8:
       return "int8";
-    case arrow5.Int16:
+    case arrow6.Int16:
       return "int16";
-    case arrow5.Int32:
+    case arrow6.Int32:
       return "int32";
-    case arrow5.Int64:
+    case arrow6.Int64:
       return "int64";
-    case arrow5.Uint8:
+    case arrow6.Uint8:
       return "uint8";
-    case arrow5.Uint16:
+    case arrow6.Uint16:
       return "uint16";
-    case arrow5.Uint32:
+    case arrow6.Uint32:
       return "uint32";
-    case arrow5.Uint64:
+    case arrow6.Uint64:
       return "uint64";
-    case arrow5.Float:
+    case arrow6.Float:
       const precision = arrowType.precision;
       switch (precision) {
-        case arrow5.Precision.HALF:
+        case arrow6.Precision.HALF:
           return "float16";
-        case arrow5.Precision.SINGLE:
+        case arrow6.Precision.SINGLE:
           return "float32";
-        case arrow5.Precision.DOUBLE:
+        case arrow6.Precision.DOUBLE:
           return "float64";
         default:
           return "float16";
       }
-    case arrow5.Float16:
+    case arrow6.Float16:
       return "float16";
-    case arrow5.Float32:
+    case arrow6.Float32:
       return "float32";
-    case arrow5.Float64:
+    case arrow6.Float64:
       return "float64";
-    case arrow5.Utf8:
+    case arrow6.Utf8:
       return "utf8";
-    case Date:
+    case arrow6.Decimal:
+      const decimal = arrowType;
+      return {
+        type: "decimal",
+        bitWidth: decimal.bitWidth,
+        precision: decimal.precision,
+        scale: decimal.scale
+      };
+    case arrow6.Date_:
       const dateUnit = arrowType.unit;
-      return dateUnit === arrow5.DateUnit.DAY ? "date-day" : "date-millisecond";
-    case arrow5.DateDay:
+      return dateUnit === arrow6.DateUnit.DAY ? "date-day" : "date-millisecond";
+    case arrow6.DateDay:
       return "date-day";
-    case arrow5.DateMillisecond:
+    case arrow6.DateMillisecond:
       return "date-millisecond";
-    case arrow5.Time:
+    case arrow6.Time:
       const timeUnit = arrowType.unit;
       switch (timeUnit) {
-        case arrow5.TimeUnit.SECOND:
+        case arrow6.TimeUnit.SECOND:
           return "time-second";
-        case arrow5.TimeUnit.MILLISECOND:
+        case arrow6.TimeUnit.MILLISECOND:
           return "time-millisecond";
-        case arrow5.TimeUnit.MICROSECOND:
+        case arrow6.TimeUnit.MICROSECOND:
           return "time-microsecond";
-        case arrow5.TimeUnit.NANOSECOND:
+        case arrow6.TimeUnit.NANOSECOND:
           return "time-nanosecond";
         default:
           return "time-second";
       }
-    case arrow5.TimeMillisecond:
+    case arrow6.TimeMillisecond:
       return "time-millisecond";
-    case arrow5.TimeSecond:
+    case arrow6.TimeSecond:
       return "time-second";
-    case arrow5.TimeMicrosecond:
+    case arrow6.TimeMicrosecond:
       return "time-microsecond";
-    case arrow5.TimeNanosecond:
+    case arrow6.TimeNanosecond:
       return "time-nanosecond";
-    case arrow5.Timestamp:
+    case arrow6.Timestamp:
       const timeStampUnit = arrowType.unit;
       switch (timeStampUnit) {
-        case arrow5.TimeUnit.SECOND:
+        case arrow6.TimeUnit.SECOND:
           return "timestamp-second";
-        case arrow5.TimeUnit.MILLISECOND:
+        case arrow6.TimeUnit.MILLISECOND:
           return "timestamp-millisecond";
-        case arrow5.TimeUnit.MICROSECOND:
+        case arrow6.TimeUnit.MICROSECOND:
           return "timestamp-microsecond";
-        case arrow5.TimeUnit.NANOSECOND:
+        case arrow6.TimeUnit.NANOSECOND:
           return "timestamp-nanosecond";
         default:
           return "timestamp-second";
       }
-    case arrow5.TimestampSecond:
+    case arrow6.TimestampSecond:
       return "timestamp-second";
-    case arrow5.TimestampMillisecond:
+    case arrow6.TimestampMillisecond:
       return "timestamp-millisecond";
-    case arrow5.TimestampMicrosecond:
+    case arrow6.TimestampMicrosecond:
       return "timestamp-microsecond";
-    case arrow5.TimestampNanosecond:
+    case arrow6.TimestampNanosecond:
       return "timestamp-nanosecond";
-    case arrow5.Interval:
+    case arrow6.Interval:
       const intervalUnit = arrowType.unit;
       switch (intervalUnit) {
-        case arrow5.IntervalUnit.DAY_TIME:
+        case arrow6.IntervalUnit.DAY_TIME:
           return "interval-daytime";
-        case arrow5.IntervalUnit.YEAR_MONTH:
+        case arrow6.IntervalUnit.YEAR_MONTH:
           return "interval-yearmonth";
         default:
           return "interval-daytime";
       }
-    case arrow5.IntervalDayTime:
+    case arrow6.IntervalDayTime:
       return "interval-daytime";
-    case arrow5.IntervalYearMonth:
+    case arrow6.IntervalYearMonth:
       return "interval-yearmonth";
-    case arrow5.List:
+    case arrow6.Map_:
+      const mapType = arrowType;
+      return {
+        type: "map",
+        keysSorted: mapType.keysSorted,
+        children: mapType.children.map((arrowField) => serializeArrowField(arrowField))
+      };
+    case arrow6.List:
       const listType = arrowType;
       const listField = listType.valueField;
       return {
         type: "list",
         children: [serializeArrowField(listField)]
       };
-    case arrow5.FixedSizeList:
+    case arrow6.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 arrow6.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 arrow6.Decimal(dataType.precision, dataType.scale, dataType.bitWidth);
+      case "map":
+        let children = dataType.children.map((arrowField) => deserializeArrowField(arrowField));
+        return new arrow6.Map_(children, dataType.keysSorted);
       case "list":
         const field = deserializeArrowField(dataType.children[0]);
-        return new arrow5.List(field);
+        return new arrow6.List(field);
       case "fixed-size-list":
         const child = deserializeArrowField(dataType.children[0]);
-        return new arrow5.FixedSizeList(dataType.listSize, child);
+        return new arrow6.FixedSizeList(dataType.listSize, child);
       case "struct":
-        const children = dataType.children.map((arrowField) => deserializeArrowField(arrowField));
-        return new arrow5.Struct(children);
+        children = dataType.children.map((arrowField) => deserializeArrowField(arrowField));
+        return new arrow6.Struct(children);
       default:
         throw new Error("array type not supported");
     }
   }
   switch (dataType) {
     case "null":
-      return new arrow5.Null();
+      return new arrow6.Null();
     case "binary":
-      return new arrow5.Binary();
+      return new arrow6.Binary();
     case "bool":
-      return new arrow5.Bool();
+      return new arrow6.Bool();
     case "int8":
-      return new arrow5.Int8();
+      return new arrow6.Int8();
     case "int16":
-      return new arrow5.Int16();
+      return new arrow6.Int16();
     case "int32":
-      return new arrow5.Int32();
+      return new arrow6.Int32();
     case "int64":
-      return new arrow5.Int64();
+      return new arrow6.Int64();
     case "uint8":
-      return new arrow5.Uint8();
+      return new arrow6.Uint8();
     case "uint16":
-      return new arrow5.Uint16();
+      return new arrow6.Uint16();
     case "uint32":
-      return new arrow5.Uint32();
+      return new arrow6.Uint32();
     case "uint64":
-      return new arrow5.Uint64();
+      return new arrow6.Uint64();
     case "float16":
-      return new arrow5.Float16();
+      return new arrow6.Float16();
     case "float32":
-      return new arrow5.Float32();
+      return new arrow6.Float32();
     case "float64":
-      return new arrow5.Float64();
+      return new arrow6.Float64();
     case "utf8":
-      return new arrow5.Utf8();
+      return new arrow6.Utf8();
     case "date-day":
-      return new arrow5.DateDay();
+      return new arrow6.DateDay();
     case "date-millisecond":
-      return new arrow5.DateMillisecond();
+      return new arrow6.DateMillisecond();
     case "time-second":
-      return new arrow5.TimeSecond();
+      return new arrow6.TimeSecond();
     case "time-millisecond":
-      return new arrow5.TimeMillisecond();
+      return new arrow6.TimeMillisecond();
     case "time-microsecond":
-      return new arrow5.TimeMicrosecond();
+      return new arrow6.TimeMicrosecond();
     case "time-nanosecond":
-      return new arrow5.TimeNanosecond();
+      return new arrow6.TimeNanosecond();
     case "timestamp-second":
-      return new arrow5.TimestampSecond();
+      return new arrow6.TimestampSecond();
     case "timestamp-millisecond":
-      return new arrow5.TimestampMillisecond();
+      return new arrow6.TimestampMillisecond();
     case "timestamp-microsecond":
-      return new arrow5.TimestampMicrosecond();
+      return new arrow6.TimestampMicrosecond();
     case "timestamp-nanosecond":
-      return new arrow5.TimestampNanosecond();
+      return new arrow6.TimestampNanosecond();
     case "interval-daytime":
-      return new arrow5.IntervalDayTime();
+      return new arrow6.IntervalDayTime();
     case "interval-yearmonth":
-      return new arrow5.IntervalYearMonth();
+      return new arrow6.IntervalYearMonth();
     default:
       throw new Error("array type not supported");
   }
 }
 
-// src/types.ts
-var VECTOR_TYPES = /* @__PURE__ */ ((VECTOR_TYPES2) => {
-  VECTOR_TYPES2[VECTOR_TYPES2["FLOAT"] = 0] = "FLOAT";
-  VECTOR_TYPES2[VECTOR_TYPES2["DATE"] = 1] = "DATE";
-  return VECTOR_TYPES2;
-})(VECTOR_TYPES || {});
-
-// src/lib/encode-arrow.ts
-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 arrow6.Table(vectors);
-  const arrowBuffer = arrow6.tableToIPC(table);
-  return arrowBuffer;
-}
-function createVector(array, type) {
-  switch (type) {
-    case 1 /* DATE */:
-      return arrow6.vectorFromArray(array);
-    case 0 /* FLOAT */:
-    default:
-      return arrow6.vectorFromArray(array);
-  }
-}
-
-// src/arrow-writer.ts
-var VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-var ArrowWriter = {
-  name: "Apache Arrow",
-  id: "arrow",
-  module: "arrow",
-  version: VERSION2,
-  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) {
-    return encodeArrowSync(data);
-  },
-  encodeSync(data, options) {
-    return encodeArrowSync(data);
-  }
-};
+// src/geoarrow/convert-geoarrow-to-binary-geometry.ts
+var import_polygon = require("@math.gl/polygon");
 
 // src/geoarrow/get-arrow-bounds.ts
 function updateBoundsFromGeoArrowSamples(flatCoords, nDim, bounds, sampleSize = 100) {
@@ -550,24 +651,20 @@ var BINARY_GEOMETRY_TEMPLATE = {
   numericProps: {},
   featureIds: { value: new Uint32Array(0), size: 1 }
 };
-function getBinaryGeometriesFromArrow(geoColumn, geoEncoding) {
+function getBinaryGeometriesFromArrow(geoColumn, geoEncoding, options) {
   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;
+  const chunks = (options == null ? void 0 : options.chunkIndex) ? [geoColumn.data[options == null ? void 0 : options.chunkIndex]] : 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++) {
+    const { featureIds, flatCoordinateArray, nDim, geomOffset, triangles } = getBinaryGeometriesFromChunk(chunk, geoEncoding);
+    const globalFeatureIds = new Uint32Array(featureIds.length);
+    for (let i = 0; i < featureIds.length; i++) {
       globalFeatureIds[i] = featureIds[i] + globalFeatureIdOffset;
     }
     const binaryContent = {
@@ -600,20 +697,81 @@ function getBinaryGeometriesFromArrow(geoColumn, geoEncoding) {
         ...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 == null ? void 0 : options.meanCenter) ? { meanCenters: getMeanCentersFromBinaryGeometries(binaryGeometries) } : {}
+  };
+}
+function getMeanCentersFromBinaryGeometries(binaryGeometries) {
+  const globalMeanCenters = [];
+  binaryGeometries.forEach((binaryGeometry) => {
+    var _a;
+    let binaryGeometryType = 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 = (_a = binaryContent.primitivePolygonIndices) == null ? void 0 : _a.value;
+      const meanCenters = getMeanCentersFromGeometry(
+        featureIds,
+        flatCoordinateArray,
+        nDim,
+        binaryGeometryType,
+        primitivePolygonIndices
+      );
+      meanCenters.forEach((center) => {
+        globalMeanCenters.push(center);
+      });
+    }
+  });
+  return globalMeanCenters;
+}
+function getMeanCentersFromGeometry(featureIds, flatCoordinateArray, nDim, geometryType, primitivePolygonIndices) {
+  const meanCenters = [];
+  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) {
+        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;
 }
 function getBinaryGeometriesFromChunk(chunk, geoEncoding) {
   switch (geoEncoding) {
@@ -630,35 +788,67 @@ function getBinaryGeometriesFromChunk(chunk, geoEncoding) {
       throw Error("invalid geoarrow encoding");
   }
 }
+function getTriangleIndices(polygonIndices, primitivePolygonIndices, flatCoordinateArray, nDim) {
+  let primitiveIndex = 0;
+  const triangles = [];
+  for (let i = 0; i < polygonIndices.length - 1; i++) {
+    const startIdx = polygonIndices[i];
+    const endIdx = polygonIndices[i + 1];
+    const slicedFlatCoords = flatCoordinateArray.subarray(startIdx * nDim, endIdx * nDim);
+    const holeIndices = [];
+    while (primitivePolygonIndices[primitiveIndex] < endIdx) {
+      if (primitivePolygonIndices[primitiveIndex] > startIdx) {
+        holeIndices.push(primitivePolygonIndices[primitiveIndex] - startIdx);
+      }
+      primitiveIndex++;
+    }
+    const triangleIndices = (0, import_polygon.earcut)(
+      slicedFlatCoords,
+      holeIndices.length > 0 ? holeIndices : void 0,
+      nDim
+    );
+    for (let j = 0; j < triangleIndices.length; j++) {
+      triangles.push(triangleIndices[j] + startIdx);
+    }
+  }
+  const trianglesUint32 = new Uint32Array(triangles.length);
+  for (let i = 0; i < triangles.length; i++) {
+    trianglesUint32[i] = triangles[i];
+  }
+  return trianglesUint32;
+}
 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;
     }
   }
+  const triangles = getTriangleIndices(geometryIndicies, geomOffset, flatCoordinateArray, nDim);
   return {
     featureIds,
     flatCoordinateArray,
     nDim,
     geomOffset,
-    geometryIndicies
+    geometryIndicies,
+    triangles
   };
 }
 function getBinaryLinesFromChunk(chunk, geoEncoding) {
@@ -672,11 +862,22 @@ function getBinaryLinesFromChunk(chunk, geoEncoding) {
   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;
+  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;
+      }
     }
   }
   return {
@@ -697,8 +898,19 @@ function getBinaryPointsFromChunk(chunk, geoEncoding) {
   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;
+  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 {
     featureIds,
@@ -710,7 +922,7 @@ function getBinaryPointsFromChunk(chunk, geoEncoding) {
 }
 
 // src/geoarrow/convert-geoarrow-to-geojson.ts
-function parseGeometryFromArrow(rawData) {
+function parseGeometryFromArrow2(rawData) {
   var _a;
   const encoding = (_a = rawData.encoding) == null ? void 0 : _a.toLowerCase();
   const data = rawData.data;
@@ -737,6 +949,10 @@ function parseGeometryFromArrow(rawData) {
     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}`);
     }
@@ -847,11 +1063,19 @@ function arrowLineStringToFeature(arrowLineString) {
   return geometry;
 }
 
+// src/triangulate-on-worker.ts
+var import_worker_utils = require("@loaders.gl/worker-utils");
+var VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+var TriangulationWorker = {
+  id: "triangulation",
+  name: "Triangulate",
+  module: "arrow",
+  version: VERSION3,
+  options: {}
+};
+function triangulateOnWorker(data, options = {}) {
+  return (0, import_worker_utils.processOnWorker)(TriangulationWorker, data, options);
+}
+
 // src/index.ts
 import_schema3.TableBatchBuilder.ArrowBatch = ArrowTableBatchAggregator;
-var ArrowLoader2 = {
-  ...ArrowLoader,
-  parse: async (arraybuffer, options) => parseArrowSync(arraybuffer, options),
-  parseSync: parseArrowSync,
-  parseInBatches: parseArrowInBatches
-};