@loaders.gl/arrow 4.0.4 → 4.1.0-alpha.2

package/dist/index.cjs

@@ -33,7 +33,6 @@ __export(src_exports, {
   ArrowLoader: () => ArrowLoader,
   ArrowWorkerLoader: () => ArrowWorkerLoader,
   ArrowWriter: () => ArrowWriter,
-  BINARY_GEOMETRY_TEMPLATE: () => BINARY_GEOMETRY_TEMPLATE,
   GeoArrowLoader: () => GeoArrowLoader,
   GeoArrowWorkerLoader: () => GeoArrowWorkerLoader,
   TriangulationWorker: () => TriangulationWorker,
@@ -45,12 +44,15 @@ __export(src_exports, {
   deserializeArrowType: () => deserializeArrowType,
   getArrowType: () => getArrowType,
   getBinaryGeometriesFromArrow: () => getBinaryGeometriesFromArrow,
+  getBinaryGeometryTemplate: () => getBinaryGeometryTemplate,
   getMeanCentersFromBinaryGeometries: () => getMeanCentersFromBinaryGeometries,
   getTriangleIndices: () => getTriangleIndices,
+  hardClone: () => hardClone,
+  parseGeoArrowOnWorker: () => parseGeoArrowOnWorker,
   parseGeometryFromArrow: () => parseGeometryFromArrow2,
   serializeArrowField: () => serializeArrowField,
   serializeArrowMetadata: () => serializeArrowMetadata,
-  serializeArrowSchema: () => serializeArrowSchema2,
+  serializeArrowSchema: () => serializeArrowSchema,
   serializeArrowType: () => serializeArrowType,
   triangulateOnWorker: () => triangulateOnWorker,
   updateBoundsFromGeoArrowSamples: () => updateBoundsFromGeoArrowSamples
@@ -152,7 +154,7 @@ var VECTOR_TYPES = /* @__PURE__ */ ((VECTOR_TYPES2) => {
 
 // src/parsers/parse-arrow-sync.ts
 var import_schema2 = require("@loaders.gl/schema");
-var arrow3 = __toESM(require("apache-arrow"), 1);
+var arrow4 = __toESM(require("apache-arrow"), 1);
 
 // src/tables/convert-arrow-to-columnar-table.ts
 function convertArrowToColumnarTable(table) {
@@ -165,199 +167,21 @@ function convertArrowToColumnarTable(table) {
   }
   return {
     shape: "columnar-table",
+    schema: table.schema,
     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 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) {
+var arrow3 = __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 arrow6.Schema(
+  return new arrow3.Schema(
     schema.fields.map((field) => deserializeArrowField(field)),
     deserializeArrowMetadata(schema.metadata)
   );
@@ -377,7 +201,7 @@ function serializeArrowField(field) {
   };
 }
 function deserializeArrowField(field) {
-  return new arrow6.Field(
+  return new arrow3.Field(
     field.name,
     deserializeArrowType(field.type),
     field.nullable,
@@ -386,52 +210,52 @@ function deserializeArrowField(field) {
 }
 function serializeArrowType(arrowType) {
   switch (arrowType.constructor) {
-    case arrow6.Null:
+    case arrow3.Null:
       return "null";
-    case arrow6.Binary:
+    case arrow3.Binary:
       return "binary";
-    case arrow6.Bool:
+    case arrow3.Bool:
       return "bool";
-    case arrow6.Int:
+    case arrow3.Int:
       const intType = arrowType;
       return `${intType.isSigned ? "u" : ""}int${intType.bitWidth}`;
-    case arrow6.Int8:
+    case arrow3.Int8:
       return "int8";
-    case arrow6.Int16:
+    case arrow3.Int16:
       return "int16";
-    case arrow6.Int32:
+    case arrow3.Int32:
       return "int32";
-    case arrow6.Int64:
+    case arrow3.Int64:
       return "int64";
-    case arrow6.Uint8:
+    case arrow3.Uint8:
       return "uint8";
-    case arrow6.Uint16:
+    case arrow3.Uint16:
       return "uint16";
-    case arrow6.Uint32:
+    case arrow3.Uint32:
       return "uint32";
-    case arrow6.Uint64:
+    case arrow3.Uint64:
       return "uint64";
-    case arrow6.Float:
+    case arrow3.Float:
       const precision = arrowType.precision;
       switch (precision) {
-        case arrow6.Precision.HALF:
+        case arrow3.Precision.HALF:
           return "float16";
-        case arrow6.Precision.SINGLE:
+        case arrow3.Precision.SINGLE:
           return "float32";
-        case arrow6.Precision.DOUBLE:
+        case arrow3.Precision.DOUBLE:
           return "float64";
         default:
           return "float16";
       }
-    case arrow6.Float16:
+    case arrow3.Float16:
       return "float16";
-    case arrow6.Float32:
+    case arrow3.Float32:
       return "float32";
-    case arrow6.Float64:
+    case arrow3.Float64:
       return "float64";
-    case arrow6.Utf8:
+    case arrow3.Utf8:
       return "utf8";
-    case arrow6.Decimal:
+    case arrow3.Decimal:
       const decimal = arrowType;
       return {
         type: "decimal",
@@ -439,93 +263,93 @@ function serializeArrowType(arrowType) {
         precision: decimal.precision,
         scale: decimal.scale
       };
-    case arrow6.Date_:
+    case arrow3.Date_:
       const dateUnit = arrowType.unit;
-      return dateUnit === arrow6.DateUnit.DAY ? "date-day" : "date-millisecond";
-    case arrow6.DateDay:
+      return dateUnit === arrow3.DateUnit.DAY ? "date-day" : "date-millisecond";
+    case arrow3.DateDay:
       return "date-day";
-    case arrow6.DateMillisecond:
+    case arrow3.DateMillisecond:
       return "date-millisecond";
-    case arrow6.Time:
+    case arrow3.Time:
       const timeUnit = arrowType.unit;
       switch (timeUnit) {
-        case arrow6.TimeUnit.SECOND:
+        case arrow3.TimeUnit.SECOND:
           return "time-second";
-        case arrow6.TimeUnit.MILLISECOND:
+        case arrow3.TimeUnit.MILLISECOND:
           return "time-millisecond";
-        case arrow6.TimeUnit.MICROSECOND:
+        case arrow3.TimeUnit.MICROSECOND:
           return "time-microsecond";
-        case arrow6.TimeUnit.NANOSECOND:
+        case arrow3.TimeUnit.NANOSECOND:
           return "time-nanosecond";
         default:
           return "time-second";
       }
-    case arrow6.TimeMillisecond:
+    case arrow3.TimeMillisecond:
       return "time-millisecond";
-    case arrow6.TimeSecond:
+    case arrow3.TimeSecond:
       return "time-second";
-    case arrow6.TimeMicrosecond:
+    case arrow3.TimeMicrosecond:
       return "time-microsecond";
-    case arrow6.TimeNanosecond:
+    case arrow3.TimeNanosecond:
       return "time-nanosecond";
-    case arrow6.Timestamp:
+    case arrow3.Timestamp:
       const timeStampUnit = arrowType.unit;
       switch (timeStampUnit) {
-        case arrow6.TimeUnit.SECOND:
+        case arrow3.TimeUnit.SECOND:
           return "timestamp-second";
-        case arrow6.TimeUnit.MILLISECOND:
+        case arrow3.TimeUnit.MILLISECOND:
           return "timestamp-millisecond";
-        case arrow6.TimeUnit.MICROSECOND:
+        case arrow3.TimeUnit.MICROSECOND:
           return "timestamp-microsecond";
-        case arrow6.TimeUnit.NANOSECOND:
+        case arrow3.TimeUnit.NANOSECOND:
           return "timestamp-nanosecond";
         default:
           return "timestamp-second";
       }
-    case arrow6.TimestampSecond:
+    case arrow3.TimestampSecond:
       return "timestamp-second";
-    case arrow6.TimestampMillisecond:
+    case arrow3.TimestampMillisecond:
       return "timestamp-millisecond";
-    case arrow6.TimestampMicrosecond:
+    case arrow3.TimestampMicrosecond:
       return "timestamp-microsecond";
-    case arrow6.TimestampNanosecond:
+    case arrow3.TimestampNanosecond:
       return "timestamp-nanosecond";
-    case arrow6.Interval:
+    case arrow3.Interval:
       const intervalUnit = arrowType.unit;
       switch (intervalUnit) {
-        case arrow6.IntervalUnit.DAY_TIME:
+        case arrow3.IntervalUnit.DAY_TIME:
           return "interval-daytime";
-        case arrow6.IntervalUnit.YEAR_MONTH:
+        case arrow3.IntervalUnit.YEAR_MONTH:
           return "interval-yearmonth";
         default:
           return "interval-daytime";
       }
-    case arrow6.IntervalDayTime:
+    case arrow3.IntervalDayTime:
       return "interval-daytime";
-    case arrow6.IntervalYearMonth:
+    case arrow3.IntervalYearMonth:
       return "interval-yearmonth";
-    case arrow6.Map_:
+    case arrow3.Map_:
       const mapType = arrowType;
       return {
         type: "map",
         keysSorted: mapType.keysSorted,
         children: mapType.children.map((arrowField) => serializeArrowField(arrowField))
       };
-    case arrow6.List:
+    case arrow3.List:
       const listType = arrowType;
       const listField = listType.valueField;
       return {
         type: "list",
         children: [serializeArrowField(listField)]
       };
-    case arrow6.FixedSizeList:
+    case arrow3.FixedSizeList:
       const fixedSizeList = arrowType;
       return {
         type: "fixed-size-list",
         listSize: fixedSizeList.listSize,
         children: [serializeArrowField(fixedSizeList.children[0])]
       };
-    case arrow6.Struct:
+    case arrow3.Struct:
       const structType = arrowType;
       return {
         type: "struct",
@@ -539,83 +363,270 @@ function deserializeArrowType(dataType) {
   if (typeof dataType === "object") {
     switch (dataType.type) {
       case "decimal":
-        return new arrow6.Decimal(dataType.precision, dataType.scale, dataType.bitWidth);
+        return new arrow3.Decimal(dataType.precision, dataType.scale, dataType.bitWidth);
       case "map":
         let children = dataType.children.map((arrowField) => deserializeArrowField(arrowField));
-        return new arrow6.Map_(children, dataType.keysSorted);
+        return new arrow3.Map_(children, dataType.keysSorted);
       case "list":
         const field = deserializeArrowField(dataType.children[0]);
-        return new arrow6.List(field);
+        return new arrow3.List(field);
       case "fixed-size-list":
         const child = deserializeArrowField(dataType.children[0]);
-        return new arrow6.FixedSizeList(dataType.listSize, child);
+        return new arrow3.FixedSizeList(dataType.listSize, child);
       case "struct":
         children = dataType.children.map((arrowField) => deserializeArrowField(arrowField));
-        return new arrow6.Struct(children);
+        return new arrow3.Struct(children);
       default:
         throw new Error("array type not supported");
     }
   }
   switch (dataType) {
     case "null":
-      return new arrow6.Null();
+      return new arrow3.Null();
     case "binary":
-      return new arrow6.Binary();
+      return new arrow3.Binary();
     case "bool":
-      return new arrow6.Bool();
+      return new arrow3.Bool();
     case "int8":
-      return new arrow6.Int8();
+      return new arrow3.Int8();
     case "int16":
-      return new arrow6.Int16();
+      return new arrow3.Int16();
     case "int32":
-      return new arrow6.Int32();
+      return new arrow3.Int32();
     case "int64":
-      return new arrow6.Int64();
+      return new arrow3.Int64();
     case "uint8":
-      return new arrow6.Uint8();
+      return new arrow3.Uint8();
     case "uint16":
-      return new arrow6.Uint16();
+      return new arrow3.Uint16();
     case "uint32":
-      return new arrow6.Uint32();
+      return new arrow3.Uint32();
     case "uint64":
-      return new arrow6.Uint64();
+      return new arrow3.Uint64();
     case "float16":
-      return new arrow6.Float16();
+      return new arrow3.Float16();
     case "float32":
-      return new arrow6.Float32();
+      return new arrow3.Float32();
     case "float64":
-      return new arrow6.Float64();
+      return new arrow3.Float64();
     case "utf8":
-      return new arrow6.Utf8();
+      return new arrow3.Utf8();
     case "date-day":
-      return new arrow6.DateDay();
+      return new arrow3.DateDay();
     case "date-millisecond":
-      return new arrow6.DateMillisecond();
+      return new arrow3.DateMillisecond();
     case "time-second":
-      return new arrow6.TimeSecond();
+      return new arrow3.TimeSecond();
     case "time-millisecond":
-      return new arrow6.TimeMillisecond();
+      return new arrow3.TimeMillisecond();
     case "time-microsecond":
-      return new arrow6.TimeMicrosecond();
+      return new arrow3.TimeMicrosecond();
     case "time-nanosecond":
-      return new arrow6.TimeNanosecond();
+      return new arrow3.TimeNanosecond();
     case "timestamp-second":
-      return new arrow6.TimestampSecond();
+      return new arrow3.TimestampSecond();
     case "timestamp-millisecond":
-      return new arrow6.TimestampMillisecond();
+      return new arrow3.TimestampMillisecond();
     case "timestamp-microsecond":
-      return new arrow6.TimestampMicrosecond();
+      return new arrow3.TimestampMicrosecond();
     case "timestamp-nanosecond":
-      return new arrow6.TimestampNanosecond();
+      return new arrow3.TimestampNanosecond();
     case "interval-daytime":
-      return new arrow6.IntervalDayTime();
+      return new arrow3.IntervalDayTime();
     case "interval-yearmonth":
-      return new arrow6.IntervalYearMonth();
+      return new arrow3.IntervalYearMonth();
     default:
       throw new Error("array type not supported");
   }
 }
 
+// src/parsers/parse-arrow-sync.ts
+function parseArrowSync(arrayBuffer, options) {
+  const apacheArrowTable = arrow4.tableFromIPC([new Uint8Array(arrayBuffer)]);
+  const arrowTable = {
+    shape: "arrow-table",
+    schema: serializeArrowSchema(apacheArrowTable.schema),
+    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 arrow5 = __toESM(require("apache-arrow"), 1);
+function parseArrowInBatches(asyncIterator) {
+  async function* makeArrowAsyncIterator() {
+    const readers = arrow5.RecordBatchReader.readAll(asyncIterator);
+    for await (const reader of readers) {
+      for await (const recordBatch of reader) {
+        const arrowTabledBatch = {
+          shape: "arrow-table",
+          batchType: "data",
+          data: new arrow5.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 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/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 = [];
+  const propertyColumnNames = arrowTable.schema.fields.map((field) => field.name).filter((name) => !(name in geometryColumns));
+  const propertiesTable = arrowTable.select(propertyColumnNames);
+  const arrowGeometryColumn = arrowTable.getChild("geometry");
+  for (let row = 0; row < arrowTable.numRows; row++) {
+    const arrowGeometry = arrowGeometryColumn == null ? void 0 : arrowGeometryColumn.get(row);
+    const feature = (0, import_arrow.parseGeometryFromArrow)(arrowGeometry, encoding);
+    if (feature) {
+      const properties = ((_a = propertiesTable.get(row)) == null ? void 0 : _a.toJSON()) || {};
+      features.push({ type: "Feature", geometry: feature, properties });
+    }
+  }
+  return {
+    shape: "geojson-table",
+    type: "FeatureCollection",
+    schema: table.schema,
+    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/geoarrow/convert-geoarrow-to-binary-geometry.ts
 var import_polygon = require("@math.gl/polygon");
 
@@ -644,25 +655,27 @@ function updateBoundsFromGeoArrowSamples(flatCoords, nDim, bounds, sampleSize =
 }
 
 // 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 getBinaryGeometryTemplate() {
+  return {
+    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, 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 = (options == null ? void 0 : options.chunkIndex) ? [geoColumn.data[options == null ? void 0 : options.chunkIndex]] : geoColumn.data;
+  const chunks = (options == null ? void 0 : options.chunkIndex) !== void 0 && (options == null ? void 0 : options.chunkIndex) >= 0 ? [geoColumn.data[options == null ? void 0 : options.chunkIndex]] : geoColumn.data;
   let bounds = [Infinity, Infinity, -Infinity, -Infinity];
-  let globalFeatureIdOffset = 0;
+  let globalFeatureIdOffset = (options == null ? void 0 : options.chunkOffset) || 0;
   const binaryGeometries = [];
   chunks.forEach((chunk) => {
-    const { featureIds, flatCoordinateArray, nDim, geomOffset, triangles } = getBinaryGeometriesFromChunk(chunk, geoEncoding);
+    const { featureIds, flatCoordinateArray, nDim, geomOffset, triangles } = getBinaryGeometriesFromChunk(chunk, geoEncoding, options);
     const globalFeatureIds = new Uint32Array(featureIds.length);
     for (let i = 0; i < featureIds.length; i++) {
       globalFeatureIds[i] = featureIds[i] + globalFeatureIdOffset;
@@ -674,6 +687,7 @@ function getBinaryGeometriesFromArrow(geoColumn, geoEncoding, options) {
         size: nDim
       },
       featureIds: { value: featureIds, size: 1 },
+      // eslint-disable-next-line no-loop-func
       properties: [...Array(chunk.length).keys()].map((i) => ({
         index: i + globalFeatureIdOffset
       }))
@@ -683,18 +697,18 @@ function getBinaryGeometriesFromArrow(geoColumn, geoEncoding, options) {
       shape: "binary-feature-collection",
       points: {
         type: "Point",
-        ...BINARY_GEOMETRY_TEMPLATE,
+        ...getBinaryGeometryTemplate(),
         ...featureTypes.point ? binaryContent : {}
       },
       lines: {
         type: "LineString",
-        ...BINARY_GEOMETRY_TEMPLATE,
+        ...getBinaryGeometryTemplate(),
         ...featureTypes.line ? binaryContent : {},
         pathIndices: { value: featureTypes.line ? geomOffset : new Uint16Array(0), size: 1 }
       },
       polygons: {
         type: "Polygon",
-        ...BINARY_GEOMETRY_TEMPLATE,
+        ...getBinaryGeometryTemplate(),
         ...featureTypes.polygon ? binaryContent : {},
         polygonIndices: {
           // use geomOffset as polygonIndices same as primitivePolygonIndices since we are using earcut to get triangule indices
@@ -714,7 +728,7 @@ function getBinaryGeometriesFromArrow(geoColumn, geoEncoding, options) {
     binaryGeometries,
     bounds,
     featureTypes,
-    ...(options == null ? void 0 : options.meanCenter) ? { meanCenters: getMeanCentersFromBinaryGeometries(binaryGeometries) } : {}
+    ...(options == null ? void 0 : options.calculateMeanCenters) ? { meanCenters: getMeanCentersFromBinaryGeometries(binaryGeometries) } : {}
   };
 }
 function getMeanCentersFromBinaryGeometries(binaryGeometries) {
@@ -723,18 +737,18 @@ function getMeanCentersFromBinaryGeometries(binaryGeometries) {
     var _a;
     let binaryGeometryType = null;
     if (binaryGeometry.points && binaryGeometry.points.positions.value.length > 0) {
-      binaryGeometryType = "points";
+      binaryGeometryType = "points" /* points */;
     } else if (binaryGeometry.lines && binaryGeometry.lines.positions.value.length > 0) {
-      binaryGeometryType = "lines";
+      binaryGeometryType = "lines" /* lines */;
     } else if (binaryGeometry.polygons && binaryGeometry.polygons.positions.value.length > 0) {
-      binaryGeometryType = "polygons";
+      binaryGeometryType = "polygons" /* 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 primitivePolygonIndices = binaryContent.type === "Polygon" ? (_a = binaryContent.primitivePolygonIndices) == null ? void 0 : _a.value : void 0;
       const meanCenters = getMeanCentersFromGeometry(
         featureIds,
         flatCoordinateArray,
@@ -753,19 +767,23 @@ function getMeanCentersFromGeometry(featureIds, flatCoordinateArray, nDim, geome
   const meanCenters = [];
   const vertexCount = flatCoordinateArray.length;
   let vertexIndex = 0;
+  let coordIdx = 0;
+  let primitiveIdx = 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) {
+    while (vertexIndex < vertexCount && featureIds[coordIdx] === featureId) {
+      if (geometryType === "polygons" /* polygons */ && (primitivePolygonIndices == null ? void 0 : primitivePolygonIndices[primitiveIdx]) === coordIdx) {
         vertexIndex += nDim;
+        primitiveIdx++;
       } else {
         center[0] += flatCoordinateArray[vertexIndex];
         center[1] += flatCoordinateArray[vertexIndex + 1];
         vertexIndex += nDim;
         vertexCountInFeature++;
       }
+      coordIdx += 1;
     }
     center[0] /= vertexCountInFeature;
     center[1] /= vertexCountInFeature;
@@ -773,7 +791,7 @@ function getMeanCentersFromGeometry(featureIds, flatCoordinateArray, nDim, geome
   }
   return meanCenters;
 }
-function getBinaryGeometriesFromChunk(chunk, geoEncoding) {
+function getBinaryGeometriesFromChunk(chunk, geoEncoding, options) {
   switch (geoEncoding) {
     case "geoarrow.point":
     case "geoarrow.multipoint":
@@ -783,41 +801,48 @@ function getBinaryGeometriesFromChunk(chunk, geoEncoding) {
       return getBinaryLinesFromChunk(chunk, geoEncoding);
     case "geoarrow.polygon":
     case "geoarrow.multipolygon":
-      return getBinaryPolygonsFromChunk(chunk, geoEncoding);
+      return getBinaryPolygonsFromChunk(chunk, geoEncoding, options);
     default:
       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);
+  try {
+    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
+      );
+      if (triangleIndices.length === 0) {
+        throw Error("earcut failed e.g. invalid polygon");
+      }
+      for (let j = 0; j < triangleIndices.length; j++) {
+        triangles.push(triangleIndices[j] + 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;
+  } catch (error) {
+    return null;
   }
-  const trianglesUint32 = new Uint32Array(triangles.length);
-  for (let i = 0; i < triangles.length; i++) {
-    trianglesUint32[i] = triangles[i];
-  }
-  return trianglesUint32;
 }
-function getBinaryPolygonsFromChunk(chunk, geoEncoding) {
+function getBinaryPolygonsFromChunk(chunk, geoEncoding, options) {
   const isMultiPolygon = geoEncoding === "geoarrow.multipolygon";
   const polygonData = isMultiPolygon ? chunk.children[0] : chunk;
   const polygonOffset = polygonData.valueOffsets;
@@ -841,14 +866,14 @@ function getBinaryPolygonsFromChunk(chunk, geoEncoding) {
       featureIds[j] = i;
     }
   }
-  const triangles = getTriangleIndices(geometryIndicies, geomOffset, flatCoordinateArray, nDim);
+  const triangles = (options == null ? void 0 : options.triangulate) ? getTriangleIndices(geometryIndicies, geomOffset, flatCoordinateArray, nDim) : null;
   return {
     featureIds,
-    flatCoordinateArray,
     nDim,
+    flatCoordinateArray,
     geomOffset,
     geometryIndicies,
-    triangles
+    ...(options == null ? void 0 : options.triangulate) && triangles ? { triangles } : {}
   };
 }
 function getBinaryLinesFromChunk(chunk, geoEncoding) {
@@ -921,47 +946,60 @@ function getBinaryPointsFromChunk(chunk, geoEncoding) {
   };
 }
 
-// src/geoarrow/convert-geoarrow-to-geojson.ts
-function parseGeometryFromArrow2(rawData) {
-  var _a;
-  const encoding = (_a = rawData.encoding) == null ? void 0 : _a.toLowerCase();
-  const data = rawData.data;
-  if (!encoding || !data) {
+// src/geoarrow/convert-geoarrow-to-geojson-geometry.ts
+var import_gis2 = require("@loaders.gl/gis");
+var import_wkt = require("@loaders.gl/wkt");
+function parseGeometryFromArrow2(arrowCellValue, encoding) {
+  encoding = encoding == null ? void 0 : encoding.toLowerCase();
+  if (!encoding || !arrowCellValue) {
     return null;
   }
   let geometry;
   switch (encoding) {
     case "geoarrow.multipolygon":
-      geometry = arrowMultiPolygonToFeature(data);
+      geometry = arrowMultiPolygonToFeature(arrowCellValue);
       break;
     case "geoarrow.polygon":
-      geometry = arrowPolygonToFeature(data);
+      geometry = arrowPolygonToFeature(arrowCellValue);
       break;
     case "geoarrow.multipoint":
-      geometry = arrowMultiPointToFeature(data);
+      geometry = arrowMultiPointToFeature(arrowCellValue);
       break;
     case "geoarrow.point":
-      geometry = arrowPointToFeature(data);
+      geometry = arrowPointToFeature(arrowCellValue);
       break;
     case "geoarrow.multilinestring":
-      geometry = arrowMultiLineStringToFeature(data);
+      geometry = arrowMultiLineStringToFeature(arrowCellValue);
       break;
     case "geoarrow.linestring":
-      geometry = arrowLineStringToFeature(data);
+      geometry = arrowLineStringToFeature(arrowCellValue);
       break;
     case "geoarrow.wkb":
-      throw Error(`GeoArrow encoding not supported ${encoding}`);
+      geometry = arrowWKBToFeature(arrowCellValue);
+      break;
     case "geoarrow.wkt":
-      throw Error(`GeoArrow encoding not supported ${encoding}`);
+      geometry = arrowWKTToFeature(arrowCellValue);
+      break;
     default: {
       throw Error(`GeoArrow encoding not supported ${encoding}`);
     }
   }
-  return {
-    type: "Feature",
-    geometry,
-    properties: {}
-  };
+  return geometry;
+}
+function arrowWKBToFeature(arrowCellValue) {
+  var _a, _b;
+  const arrayBuffer = arrowCellValue.buffer.slice(
+    arrowCellValue.byteOffset,
+    arrowCellValue.byteOffset + arrowCellValue.byteLength
+  );
+  const binaryGeometry = (_b = (_a = import_wkt.WKBLoader).parseSync) == null ? void 0 : _b.call(_a, arrayBuffer);
+  const geometry = (0, import_gis2.binaryToGeometry)(binaryGeometry);
+  return geometry;
+}
+function arrowWKTToFeature(arrowCellValue) {
+  var _a, _b;
+  const string = arrowCellValue;
+  return (_b = (_a = import_wkt.WKTLoader).parseTextSync) == null ? void 0 : _b.call(_a, string);
 }
 function arrowMultiPolygonToFeature(arrowMultiPolygon) {
   const multiPolygon = [];
@@ -1013,19 +1051,17 @@ function arrowMultiPointToFeature(arrowMultiPoint) {
       multiPoint.push(coord);
     }
   }
-  const geometry = {
+  return {
     type: "MultiPoint",
     coordinates: multiPoint
   };
-  return geometry;
 }
 function arrowPointToFeature(arrowPoint) {
   const point = Array.from(arrowPoint);
-  const geometry = {
+  return {
     type: "Point",
     coordinates: point
   };
-  return geometry;
 }
 function arrowMultiLineStringToFeature(arrowMultiLineString) {
   const multiLineString = [];
@@ -1041,11 +1077,10 @@ function arrowMultiLineStringToFeature(arrowMultiLineString) {
     }
     multiLineString.push(lineString);
   }
-  const geometry = {
+  return {
     type: "MultiLineString",
     coordinates: multiLineString
   };
-  return geometry;
 }
 function arrowLineStringToFeature(arrowLineString) {
   const lineString = [];
@@ -1056,11 +1091,55 @@ function arrowLineStringToFeature(arrowLineString) {
       lineString.push(coords);
     }
   }
-  const geometry = {
+  return {
     type: "LineString",
     coordinates: lineString
   };
-  return geometry;
+}
+
+// src/workers/hard-clone.ts
+var arrow7 = __toESM(require("apache-arrow"), 1);
+function hardClone(data, force = false) {
+  if ("data" in data) {
+    return new arrow7.Vector(data.data.map((data2) => hardClone(data2, force)));
+  }
+  const clonedChildren = [];
+  for (const childData of data.children) {
+    clonedChildren.push(hardClone(childData, force));
+  }
+  let clonedDictionary;
+  if (data.dictionary !== void 0) {
+    clonedDictionary = hardClone(data.dictionary, force);
+  }
+  const clonedBuffers = {
+    [arrow7.BufferType.OFFSET]: cloneBuffer(data.buffers[arrow7.BufferType.OFFSET], force),
+    [arrow7.BufferType.DATA]: cloneBuffer(data.buffers[arrow7.BufferType.DATA], force),
+    [arrow7.BufferType.VALIDITY]: cloneBuffer(data.buffers[arrow7.BufferType.VALIDITY], force),
+    [arrow7.BufferType.TYPE]: cloneBuffer(data.buffers[arrow7.BufferType.TYPE], force)
+  };
+  return new arrow7.Data(
+    data.type,
+    data.offset,
+    data.length,
+    // @ts-expect-error _nullCount is protected. We're using it here to mimic
+    // `Data.clone`
+    data._nullCount,
+    clonedBuffers,
+    clonedChildren,
+    clonedDictionary
+  );
+}
+function isTypedArraySliced(arr) {
+  return !(arr.byteOffset === 0 && arr.byteLength === arr.buffer.byteLength);
+}
+function cloneBuffer(arr, force) {
+  if (arr === void 0) {
+    return arr;
+  }
+  if (!force && !isTypedArraySliced(arr)) {
+    return arr;
+  }
+  return arr.slice();
 }
 
 // src/triangulate-on-worker.ts
@@ -1074,7 +1153,10 @@ var TriangulationWorker = {
   options: {}
 };
 function triangulateOnWorker(data, options = {}) {
-  return (0, import_worker_utils.processOnWorker)(TriangulationWorker, data, options);
+  return (0, import_worker_utils.processOnWorker)(TriangulationWorker, { ...data, operation: "triangulate" }, options);
+}
+function parseGeoArrowOnWorker(data, options = {}) {
+  return (0, import_worker_utils.processOnWorker)(TriangulationWorker, { ...data, operation: "parse-geoarrow" }, options);
 }
 
 // src/index.ts