@loaders.gl/arrow 4.3.0-alpha.8 → 4.3.0-beta.2

package/dist/index.cjs

@@ -37,19 +37,21 @@ __export(dist_exports, {
   GeoArrowWorkerLoader: () => GeoArrowWorkerLoader,
   TriangulationWorker: () => TriangulationWorker,
   VECTOR_TYPES: () => VECTOR_TYPES,
-  convertArrowToGeoJSONTable: () => convertArrowToGeoJSONTable,
+  convertArrowToSchema: () => convertArrowToSchema,
+  convertArrowToTable: () => convertArrowToTable,
+  convertSchemaToArrow: () => convertSchemaToArrow,
+  convertTableToArrow: () => convertTableToArrow,
   deserializeArrowField: () => deserializeArrowField,
   deserializeArrowMetadata: () => deserializeArrowMetadata,
   deserializeArrowSchema: () => deserializeArrowSchema,
   deserializeArrowType: () => deserializeArrowType,
-  getArrowType: () => getArrowType,
   getBinaryGeometriesFromArrow: () => getBinaryGeometriesFromArrow,
   getBinaryGeometryTemplate: () => getBinaryGeometryTemplate,
   getMeanCentersFromBinaryGeometries: () => getMeanCentersFromBinaryGeometries,
   getTriangleIndices: () => getTriangleIndices,
   hardClone: () => hardClone,
   parseGeoArrowOnWorker: () => parseGeoArrowOnWorker,
-  parseGeometryFromArrow: () => parseGeometryFromArrow2,
+  parseGeometryFromArrow: () => parseGeometryFromArrow,
   serializeArrowField: () => serializeArrowField,
   serializeArrowMetadata: () => serializeArrowMetadata,
   serializeArrowSchema: () => serializeArrowSchema,
@@ -58,9 +60,15 @@ __export(dist_exports, {
   updateBoundsFromGeoArrowSamples: () => updateBoundsFromGeoArrowSamples
 });
 module.exports = __toCommonJS(dist_exports);
-var import_schema3 = require("@loaders.gl/schema");
 
-// dist/lib/arrow-table-batch.js
+// dist/lib/types.js
+var VECTOR_TYPES;
+(function(VECTOR_TYPES2) {
+  VECTOR_TYPES2[VECTOR_TYPES2["FLOAT"] = 0] = "FLOAT";
+  VECTOR_TYPES2[VECTOR_TYPES2["DATE"] = 1] = "DATE";
+})(VECTOR_TYPES || (VECTOR_TYPES = {}));
+
+// dist/schema/arrow-table-batch.js
 var import_schema = require("@loaders.gl/schema");
 var arrow = __toESM(require("apache-arrow"), 1);
 var ArrowTableBatchAggregator = class extends import_schema.ColumnarTableBatchAggregator {
@@ -118,60 +126,50 @@ function getArrowVectors(arrowSchema, data) {
   return arrowVectors;
 }
 
-// dist/schema/arrow-type-utils.js
-var arrow2 = __toESM(require("apache-arrow"), 1);
-function getArrowType(array) {
-  switch (array.constructor) {
-    case Int8Array:
-      return new arrow2.Int8();
-    case Uint8Array:
-      return new arrow2.Uint8();
-    case Int16Array:
-      return new arrow2.Int16();
-    case Uint16Array:
-      return new arrow2.Uint16();
-    case Int32Array:
-      return new arrow2.Int32();
-    case Uint32Array:
-      return new arrow2.Uint32();
-    case Float32Array:
-      return new arrow2.Float32();
-    case Float64Array:
-      return new arrow2.Float64();
-    default:
-      throw new Error("array type not supported");
+// dist/index.js
+var import_schema4 = require("@loaders.gl/schema");
+
+// dist/exports/arrow-loader.js
+var VERSION = true ? "4.3.0-beta.1" : "latest";
+var ArrowWorkerLoader = {
+  dataType: null,
+  batchType: null,
+  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"
+    }
   }
-}
+};
 
-// dist/types.js
-var VECTOR_TYPES;
-(function(VECTOR_TYPES2) {
-  VECTOR_TYPES2[VECTOR_TYPES2["FLOAT"] = 0] = "FLOAT";
-  VECTOR_TYPES2[VECTOR_TYPES2["DATE"] = 1] = "DATE";
-})(VECTOR_TYPES || (VECTOR_TYPES = {}));
+// dist/lib/parsers/parse-arrow.js
+var arrow3 = __toESM(require("apache-arrow"), 1);
 
-// dist/parsers/parse-arrow-sync.js
+// dist/lib/tables/convert-arrow-to-table.js
 var import_schema2 = require("@loaders.gl/schema");
-var arrow4 = __toESM(require("apache-arrow"), 1);
+var import_gis2 = require("@loaders.gl/gis");
 
-// dist/tables/convert-arrow-to-columnar-table.js
-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",
-    schema: table.schema,
-    data: columnarTable
-  };
+// dist/lib/tables/convert-arrow-schema.js
+var arrow2 = __toESM(require("apache-arrow"), 1);
+function convertArrowToSchema(arrowSchema) {
+  return serializeArrowSchema(arrowSchema);
+}
+function convertSchemaToArrow(schema) {
+  return deserializeArrowSchema(schema);
 }
-
-// dist/schema/convert-arrow-schema.js
-var arrow3 = __toESM(require("apache-arrow"), 1);
 function serializeArrowSchema(arrowSchema) {
   return {
     fields: arrowSchema.fields.map((arrowField) => serializeArrowField(arrowField)),
@@ -179,7 +177,7 @@ function serializeArrowSchema(arrowSchema) {
   };
 }
 function deserializeArrowSchema(schema) {
-  return new arrow3.Schema(schema.fields.map((field) => deserializeArrowField(field)), deserializeArrowMetadata(schema.metadata));
+  return new arrow2.Schema(schema.fields.map((field) => deserializeArrowField(field)), deserializeArrowMetadata(schema.metadata));
 }
 function serializeArrowMetadata(arrowMetadata) {
   return Object.fromEntries(arrowMetadata);
@@ -196,56 +194,56 @@ function serializeArrowField(field) {
   };
 }
 function deserializeArrowField(field) {
-  return new arrow3.Field(field.name, deserializeArrowType(field.type), field.nullable, deserializeArrowMetadata(field.metadata));
+  return new arrow2.Field(field.name, deserializeArrowType(field.type), field.nullable, deserializeArrowMetadata(field.metadata));
 }
 function serializeArrowType(arrowType) {
   switch (arrowType.constructor) {
-    case arrow3.Null:
+    case arrow2.Null:
       return "null";
-    case arrow3.Binary:
+    case arrow2.Binary:
       return "binary";
-    case arrow3.Bool:
+    case arrow2.Bool:
       return "bool";
-    case arrow3.Int:
+    case arrow2.Int:
       const intType = arrowType;
       return `${intType.isSigned ? "u" : ""}int${intType.bitWidth}`;
-    case arrow3.Int8:
+    case arrow2.Int8:
       return "int8";
-    case arrow3.Int16:
+    case arrow2.Int16:
       return "int16";
-    case arrow3.Int32:
+    case arrow2.Int32:
       return "int32";
-    case arrow3.Int64:
+    case arrow2.Int64:
       return "int64";
-    case arrow3.Uint8:
+    case arrow2.Uint8:
       return "uint8";
-    case arrow3.Uint16:
+    case arrow2.Uint16:
       return "uint16";
-    case arrow3.Uint32:
+    case arrow2.Uint32:
       return "uint32";
-    case arrow3.Uint64:
+    case arrow2.Uint64:
       return "uint64";
-    case arrow3.Float:
+    case arrow2.Float:
       const precision = arrowType.precision;
       switch (precision) {
-        case arrow3.Precision.HALF:
+        case arrow2.Precision.HALF:
           return "float16";
-        case arrow3.Precision.SINGLE:
+        case arrow2.Precision.SINGLE:
           return "float32";
-        case arrow3.Precision.DOUBLE:
+        case arrow2.Precision.DOUBLE:
           return "float64";
         default:
           return "float16";
       }
-    case arrow3.Float16:
+    case arrow2.Float16:
       return "float16";
-    case arrow3.Float32:
+    case arrow2.Float32:
       return "float32";
-    case arrow3.Float64:
+    case arrow2.Float64:
       return "float64";
-    case arrow3.Utf8:
+    case arrow2.Utf8:
       return "utf8";
-    case arrow3.Decimal:
+    case arrow2.Decimal:
       const decimal = arrowType;
       return {
         type: "decimal",
@@ -253,93 +251,93 @@ function serializeArrowType(arrowType) {
         precision: decimal.precision,
         scale: decimal.scale
       };
-    case arrow3.Date_:
+    case arrow2.Date_:
       const dateUnit = arrowType.unit;
-      return dateUnit === arrow3.DateUnit.DAY ? "date-day" : "date-millisecond";
-    case arrow3.DateDay:
+      return dateUnit === arrow2.DateUnit.DAY ? "date-day" : "date-millisecond";
+    case arrow2.DateDay:
       return "date-day";
-    case arrow3.DateMillisecond:
+    case arrow2.DateMillisecond:
       return "date-millisecond";
-    case arrow3.Time:
+    case arrow2.Time:
       const timeUnit = arrowType.unit;
       switch (timeUnit) {
-        case arrow3.TimeUnit.SECOND:
+        case arrow2.TimeUnit.SECOND:
           return "time-second";
-        case arrow3.TimeUnit.MILLISECOND:
+        case arrow2.TimeUnit.MILLISECOND:
           return "time-millisecond";
-        case arrow3.TimeUnit.MICROSECOND:
+        case arrow2.TimeUnit.MICROSECOND:
           return "time-microsecond";
-        case arrow3.TimeUnit.NANOSECOND:
+        case arrow2.TimeUnit.NANOSECOND:
           return "time-nanosecond";
         default:
           return "time-second";
       }
-    case arrow3.TimeMillisecond:
+    case arrow2.TimeMillisecond:
       return "time-millisecond";
-    case arrow3.TimeSecond:
+    case arrow2.TimeSecond:
       return "time-second";
-    case arrow3.TimeMicrosecond:
+    case arrow2.TimeMicrosecond:
       return "time-microsecond";
-    case arrow3.TimeNanosecond:
+    case arrow2.TimeNanosecond:
       return "time-nanosecond";
-    case arrow3.Timestamp:
+    case arrow2.Timestamp:
       const timeStampUnit = arrowType.unit;
       switch (timeStampUnit) {
-        case arrow3.TimeUnit.SECOND:
+        case arrow2.TimeUnit.SECOND:
           return "timestamp-second";
-        case arrow3.TimeUnit.MILLISECOND:
+        case arrow2.TimeUnit.MILLISECOND:
           return "timestamp-millisecond";
-        case arrow3.TimeUnit.MICROSECOND:
+        case arrow2.TimeUnit.MICROSECOND:
           return "timestamp-microsecond";
-        case arrow3.TimeUnit.NANOSECOND:
+        case arrow2.TimeUnit.NANOSECOND:
           return "timestamp-nanosecond";
         default:
           return "timestamp-second";
       }
-    case arrow3.TimestampSecond:
+    case arrow2.TimestampSecond:
       return "timestamp-second";
-    case arrow3.TimestampMillisecond:
+    case arrow2.TimestampMillisecond:
       return "timestamp-millisecond";
-    case arrow3.TimestampMicrosecond:
+    case arrow2.TimestampMicrosecond:
       return "timestamp-microsecond";
-    case arrow3.TimestampNanosecond:
+    case arrow2.TimestampNanosecond:
       return "timestamp-nanosecond";
-    case arrow3.Interval:
+    case arrow2.Interval:
       const intervalUnit = arrowType.unit;
       switch (intervalUnit) {
-        case arrow3.IntervalUnit.DAY_TIME:
+        case arrow2.IntervalUnit.DAY_TIME:
           return "interval-daytime";
-        case arrow3.IntervalUnit.YEAR_MONTH:
+        case arrow2.IntervalUnit.YEAR_MONTH:
           return "interval-yearmonth";
         default:
           return "interval-daytime";
       }
-    case arrow3.IntervalDayTime:
+    case arrow2.IntervalDayTime:
       return "interval-daytime";
-    case arrow3.IntervalYearMonth:
+    case arrow2.IntervalYearMonth:
       return "interval-yearmonth";
-    case arrow3.Map_:
+    case arrow2.Map_:
       const mapType = arrowType;
       return {
         type: "map",
         keysSorted: mapType.keysSorted,
         children: mapType.children.map((arrowField) => serializeArrowField(arrowField))
       };
-    case arrow3.List:
+    case arrow2.List:
       const listType = arrowType;
       const listField = listType.valueField;
       return {
         type: "list",
         children: [serializeArrowField(listField)]
       };
-    case arrow3.FixedSizeList:
+    case arrow2.FixedSizeList:
       const fixedSizeList = arrowType;
       return {
         type: "fixed-size-list",
         listSize: fixedSizeList.listSize,
         children: [serializeArrowField(fixedSizeList.children[0])]
       };
-    case arrow3.Struct:
+    case arrow2.Struct:
       const structType = arrowType;
       return {
         type: "struct",
@@ -353,114 +351,312 @@ function deserializeArrowType(dataType) {
   if (typeof dataType === "object") {
     switch (dataType.type) {
       case "decimal":
-        return new arrow3.Decimal(dataType.precision, dataType.scale, dataType.bitWidth);
+        return new arrow2.Decimal(dataType.precision, dataType.scale, dataType.bitWidth);
       case "map":
         let children = dataType.children.map((arrowField) => deserializeArrowField(arrowField));
-        return new arrow3.Map_(children, dataType.keysSorted);
+        return new arrow2.Map_(children, dataType.keysSorted);
       case "list":
         const field = deserializeArrowField(dataType.children[0]);
-        return new arrow3.List(field);
+        return new arrow2.List(field);
       case "fixed-size-list":
         const child = deserializeArrowField(dataType.children[0]);
-        return new arrow3.FixedSizeList(dataType.listSize, child);
+        return new arrow2.FixedSizeList(dataType.listSize, child);
       case "struct":
         children = dataType.children.map((arrowField) => deserializeArrowField(arrowField));
-        return new arrow3.Struct(children);
+        return new arrow2.Struct(children);
       default:
         throw new Error("array type not supported");
     }
   }
   switch (dataType) {
     case "null":
-      return new arrow3.Null();
+      return new arrow2.Null();
     case "binary":
-      return new arrow3.Binary();
+      return new arrow2.Binary();
     case "bool":
-      return new arrow3.Bool();
+      return new arrow2.Bool();
     case "int8":
-      return new arrow3.Int8();
+      return new arrow2.Int8();
     case "int16":
-      return new arrow3.Int16();
+      return new arrow2.Int16();
     case "int32":
-      return new arrow3.Int32();
+      return new arrow2.Int32();
     case "int64":
-      return new arrow3.Int64();
+      return new arrow2.Int64();
     case "uint8":
-      return new arrow3.Uint8();
+      return new arrow2.Uint8();
     case "uint16":
-      return new arrow3.Uint16();
+      return new arrow2.Uint16();
     case "uint32":
-      return new arrow3.Uint32();
+      return new arrow2.Uint32();
     case "uint64":
-      return new arrow3.Uint64();
+      return new arrow2.Uint64();
     case "float16":
-      return new arrow3.Float16();
+      return new arrow2.Float16();
     case "float32":
-      return new arrow3.Float32();
+      return new arrow2.Float32();
     case "float64":
-      return new arrow3.Float64();
+      return new arrow2.Float64();
     case "utf8":
-      return new arrow3.Utf8();
+      return new arrow2.Utf8();
     case "date-day":
-      return new arrow3.DateDay();
+      return new arrow2.DateDay();
     case "date-millisecond":
-      return new arrow3.DateMillisecond();
+      return new arrow2.DateMillisecond();
     case "time-second":
-      return new arrow3.TimeSecond();
+      return new arrow2.TimeSecond();
     case "time-millisecond":
-      return new arrow3.TimeMillisecond();
+      return new arrow2.TimeMillisecond();
     case "time-microsecond":
-      return new arrow3.TimeMicrosecond();
+      return new arrow2.TimeMicrosecond();
     case "time-nanosecond":
-      return new arrow3.TimeNanosecond();
+      return new arrow2.TimeNanosecond();
     case "timestamp-second":
-      return new arrow3.TimestampSecond();
+      return new arrow2.TimestampSecond();
     case "timestamp-millisecond":
-      return new arrow3.TimestampMillisecond();
+      return new arrow2.TimestampMillisecond();
     case "timestamp-microsecond":
-      return new arrow3.TimestampMicrosecond();
+      return new arrow2.TimestampMicrosecond();
     case "timestamp-nanosecond":
-      return new arrow3.TimestampNanosecond();
+      return new arrow2.TimestampNanosecond();
     case "interval-daytime":
-      return new arrow3.IntervalDayTime();
+      return new arrow2.IntervalDayTime();
     case "interval-yearmonth":
-      return new arrow3.IntervalYearMonth();
+      return new arrow2.IntervalYearMonth();
     default:
       throw new Error("array type not supported");
   }
 }
 
-// dist/parsers/parse-arrow-sync.js
-function parseArrowSync(arrayBuffer, options) {
-  const apacheArrowTable = arrow4.tableFromIPC([new Uint8Array(arrayBuffer)]);
-  const arrowTable = {
-    shape: "arrow-table",
-    schema: serializeArrowSchema(apacheArrowTable.schema),
-    data: apacheArrowTable
+// dist/lib/geoarrow/convert-geoarrow-to-geojson-geometry.js
+var import_gis = require("@loaders.gl/gis");
+var import_wkt = require("@loaders.gl/wkt");
+function parseGeometryFromArrow(arrowCellValue, encoding) {
+  encoding = encoding == null ? void 0 : encoding.toLowerCase();
+  if (!encoding || !arrowCellValue) {
+    return null;
+  }
+  let geometry;
+  switch (encoding) {
+    case "geoarrow.multipolygon":
+      geometry = arrowMultiPolygonToFeature(arrowCellValue);
+      break;
+    case "geoarrow.polygon":
+      geometry = arrowPolygonToFeature(arrowCellValue);
+      break;
+    case "geoarrow.multipoint":
+      geometry = arrowMultiPointToFeature(arrowCellValue);
+      break;
+    case "geoarrow.point":
+      geometry = arrowPointToFeature(arrowCellValue);
+      break;
+    case "geoarrow.multilinestring":
+      geometry = arrowMultiLineStringToFeature(arrowCellValue);
+      break;
+    case "geoarrow.linestring":
+      geometry = arrowLineStringToFeature(arrowCellValue);
+      break;
+    case "geoarrow.wkb":
+      geometry = arrowWKBToFeature(arrowCellValue);
+      break;
+    case "geoarrow.wkt":
+      geometry = arrowWKTToFeature(arrowCellValue);
+      break;
+    default: {
+      throw Error(`GeoArrow encoding not supported ${encoding}`);
+    }
+  }
+  return 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_gis.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 = [];
+  for (let m = 0; m < arrowMultiPolygon.length; m++) {
+    const arrowPolygon = arrowMultiPolygon.get(m);
+    const polygon = [];
+    for (let i = 0; arrowPolygon && i < (arrowPolygon == null ? void 0 : arrowPolygon.length); i++) {
+      const arrowRing = arrowPolygon == null ? void 0 : arrowPolygon.get(i);
+      const ring = [];
+      for (let j = 0; arrowRing && j < arrowRing.length; j++) {
+        const arrowCoord = arrowRing.get(j);
+        const coord = Array.from(arrowCoord);
+        ring.push(coord);
+      }
+      polygon.push(ring);
+    }
+    multiPolygon.push(polygon);
+  }
+  const geometry = {
+    type: "MultiPolygon",
+    coordinates: multiPolygon
   };
-  const shape = (options == null ? void 0 : options.shape) || "arrow-table";
+  return geometry;
+}
+function arrowPolygonToFeature(arrowPolygon) {
+  const polygon = [];
+  for (let i = 0; arrowPolygon && i < arrowPolygon.length; i++) {
+    const arrowRing = arrowPolygon.get(i);
+    const ring = [];
+    for (let j = 0; arrowRing && j < arrowRing.length; j++) {
+      const arrowCoord = arrowRing.get(j);
+      const coords = Array.from(arrowCoord);
+      ring.push(coords);
+    }
+    polygon.push(ring);
+  }
+  const geometry = {
+    type: "Polygon",
+    coordinates: polygon
+  };
+  return geometry;
+}
+function arrowMultiPointToFeature(arrowMultiPoint) {
+  const multiPoint = [];
+  for (let i = 0; arrowMultiPoint && i < arrowMultiPoint.length; i++) {
+    const arrowPoint = arrowMultiPoint.get(i);
+    if (arrowPoint) {
+      const coord = Array.from(arrowPoint);
+      multiPoint.push(coord);
+    }
+  }
+  return {
+    type: "MultiPoint",
+    coordinates: multiPoint
+  };
+}
+function arrowPointToFeature(arrowPoint) {
+  const point = Array.from(arrowPoint);
+  return {
+    type: "Point",
+    coordinates: point
+  };
+}
+function arrowMultiLineStringToFeature(arrowMultiLineString) {
+  const multiLineString = [];
+  for (let i = 0; arrowMultiLineString && i < arrowMultiLineString.length; i++) {
+    const arrowLineString = arrowMultiLineString.get(i);
+    const lineString = [];
+    for (let j = 0; arrowLineString && j < arrowLineString.length; j++) {
+      const arrowCoord = arrowLineString.get(j);
+      if (arrowCoord) {
+        const coords = Array.from(arrowCoord);
+        lineString.push(coords);
+      }
+    }
+    multiLineString.push(lineString);
+  }
+  return {
+    type: "MultiLineString",
+    coordinates: multiLineString
+  };
+}
+function arrowLineStringToFeature(arrowLineString) {
+  const lineString = [];
+  for (let i = 0; arrowLineString && i < arrowLineString.length; i++) {
+    const arrowCoord = arrowLineString.get(i);
+    if (arrowCoord) {
+      const coords = Array.from(arrowCoord);
+      lineString.push(coords);
+    }
+  }
+  return {
+    type: "LineString",
+    coordinates: lineString
+  };
+}
+
+// dist/lib/tables/convert-arrow-to-table.js
+function convertArrowToTable(arrowTable, shape) {
   switch (shape) {
     case "arrow-table":
-      return arrowTable;
+      return convertArrowToArrowTable(arrowTable);
+    case "array-row-table":
+      return convertArrowToArrayRowTable(arrowTable);
+    case "object-row-table":
+      return convertArrowToObjectRowTable(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");
+    case "geojson-table":
+      return convertArrowToGeoJSONTable(arrowTable);
     default:
       throw new Error(shape);
   }
 }
+function convertArrowToArrowTable(arrowTable) {
+  return {
+    shape: "arrow-table",
+    schema: convertArrowToSchema(arrowTable.schema),
+    data: arrowTable
+  };
+}
+function convertArrowToArrayRowTable(arrowTable) {
+  const columnarTable = convertArrowToColumnarTable(arrowTable);
+  return (0, import_schema2.convertTable)(columnarTable, "array-row-table");
+}
+function convertArrowToObjectRowTable(arrowTable) {
+  const columnarTable = convertArrowToColumnarTable(arrowTable);
+  return (0, import_schema2.convertTable)(columnarTable, "object-row-table");
+}
+function convertArrowToColumnarTable(arrowTable) {
+  const columns = {};
+  for (const field of arrowTable.schema.fields) {
+    const arrowColumn = arrowTable.getChild(field.name);
+    const values = arrowColumn == null ? void 0 : arrowColumn.toArray();
+    columns[field.name] = values;
+  }
+  const schema = convertArrowToSchema(arrowTable.schema);
+  return {
+    shape: "columnar-table",
+    schema,
+    data: columns
+  };
+}
+function convertArrowToGeoJSONTable(arrowTable) {
+  var _a;
+  const schema = convertArrowToSchema(arrowTable.schema);
+  const geometryColumns = (0, import_gis2.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 = 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,
+    features
+  };
+}
 
-// dist/parsers/parse-arrow-in-batches.js
-var arrow5 = __toESM(require("apache-arrow"), 1);
+// dist/lib/parsers/parse-arrow.js
+function parseArrowSync(arrayBuffer, options) {
+  const shape = (options == null ? void 0 : options.shape) || "arrow-table";
+  const arrowTable = arrow3.tableFromIPC([new Uint8Array(arrayBuffer)]);
+  return convertArrowToTable(arrowTable, shape);
+}
 function parseArrowInBatches(asyncIterator, options) {
   async function* makeArrowAsyncIterator() {
     var _a, _b;
-    const readers = arrow5.RecordBatchReader.readAll(asyncIterator);
+    const readers = arrow3.RecordBatchReader.readAll(asyncIterator);
     for await (const reader of readers) {
       for await (const recordBatch of reader) {
         if (((_a = options == null ? void 0 : options.arrow) == null ? void 0 : _a.batchDebounceMs) !== void 0 && ((_b = options == null ? void 0 : options.arrow) == null ? void 0 : _b.batchDebounceMs) > 0) {
@@ -472,7 +668,7 @@ function parseArrowInBatches(asyncIterator, options) {
         const arrowTabledBatch = {
           shape: "arrow-table",
           batchType: "data",
-          data: new arrow5.Table([recordBatch]),
+          data: new arrow3.Table([recordBatch]),
           length: recordBatch.data.length
         };
         yield arrowTabledBatch;
@@ -484,30 +680,6 @@ function parseArrowInBatches(asyncIterator, options) {
 }
 
 // dist/arrow-loader.js
-var VERSION = true ? "4.3.0-alpha.7" : "latest";
-var ArrowWorkerLoader = {
-  dataType: null,
-  batchType: null,
-  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),
@@ -515,30 +687,30 @@ var ArrowLoader = {
   parseInBatches: parseArrowInBatches
 };
 
-// dist/lib/encode-arrow.js
-var arrow6 = __toESM(require("apache-arrow"), 1);
+// dist/lib/encoders/encode-arrow.js
+var arrow4 = __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);
+  const table = new arrow4.Table(vectors);
+  const arrowBuffer = arrow4.tableToIPC(table);
   return arrowBuffer;
 }
 function createVector(array, type) {
   switch (type) {
     case VECTOR_TYPES.DATE:
-      return arrow6.vectorFromArray(array);
+      return arrow4.vectorFromArray(array);
     case VECTOR_TYPES.FLOAT:
     default:
-      return arrow6.vectorFromArray(array);
+      return arrow4.vectorFromArray(array);
   }
 }
 
 // dist/arrow-writer.js
-var VERSION2 = true ? "4.3.0-alpha.7" : "latest";
+var VERSION2 = true ? "4.3.0-beta.1" : "latest";
 var ArrowWriter = {
   name: "Apache Arrow",
   id: "arrow",
@@ -560,60 +732,31 @@ var ArrowWriter = {
   }
 };
 
-// dist/tables/convert-arrow-to-geojson-table.js
-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 });
+// dist/exports/geoarrow-loader.js
+var GeoArrowWorkerLoader = {
+  ...ArrowWorkerLoader,
+  options: {
+    arrow: {
+      shape: "arrow-table"
     }
   }
-  return {
-    shape: "geojson-table",
-    type: "FeatureCollection",
-    schema: table.schema,
-    features
-  };
-}
+};
 
-// dist/parsers/parse-geoarrow-sync.js
+// dist/lib/parsers/parse-geoarrow.js
 function parseGeoArrowSync(arrayBuffer, options) {
   const table = parseArrowSync(arrayBuffer, { shape: "arrow-table" });
   switch (options == null ? void 0 : options.shape) {
     case "geojson-table":
-      return convertArrowToGeoJSONTable(table);
+      return convertArrowToTable(table.data, "geojson-table");
     default:
       return table;
   }
 }
-
-// dist/parsers/parse-geoarrow-in-batches.js
 function parseGeoArrowInBatches(asyncIterator) {
   return parseArrowInBatches(asyncIterator);
 }
 
 // dist/geoarrow-loader.js
-var GeoArrowWorkerLoader = {
-  ...ArrowWorkerLoader,
-  options: {
-    arrow: {
-      shape: "arrow-table"
-    }
-  }
-};
 var GeoArrowLoader = {
   ...GeoArrowWorkerLoader,
   parse: async (arraybuffer, options) => parseGeoArrowSync(arraybuffer, options == null ? void 0 : options.arrow),
@@ -621,10 +764,54 @@ var GeoArrowLoader = {
   parseInBatches: parseGeoArrowInBatches
 };
 
-// dist/geoarrow/convert-geoarrow-to-binary-geometry.js
+// dist/lib/tables/convert-table-to-arrow.js
+var arrow5 = __toESM(require("apache-arrow"), 1);
+var import_schema3 = require("@loaders.gl/schema");
+function convertTableToArrow(table, options) {
+  switch (table.shape) {
+    case "arrow-table":
+      return table.data;
+    case "columnar-table":
+    default:
+      const arrowBatchIterator = makeTableToArrowBatchesIterator(table, options);
+      return new arrow5.Table(arrowBatchIterator);
+  }
+}
+function* makeTableToArrowBatchesIterator(table, options) {
+  const arrowSchema = deserializeArrowSchema(table.schema);
+  const length = (0, import_schema3.getTableLength)(table);
+  const numColumns = (0, import_schema3.getTableNumCols)(table);
+  const batchSize = (options == null ? void 0 : options.batchSize) || length;
+  const builders = arrowSchema == null ? void 0 : arrowSchema.fields.map((arrowField) => arrow5.makeBuilder(arrowField));
+  const structField = new arrow5.Struct(arrowSchema.fields);
+  let batchLength = 0;
+  for (let rowIndex = 0; rowIndex < length; rowIndex++) {
+    for (let columnIndex = 0; columnIndex < numColumns; ++columnIndex) {
+      const value = (0, import_schema3.getTableCellAt)(table, rowIndex, columnIndex);
+      const builder = builders[columnIndex];
+      builder.append(value);
+      batchLength++;
+      if (batchLength >= batchSize) {
+        const datas = builders.map((builder2) => builder2.flush());
+        const structData = new arrow5.Data(structField, 0, batchLength, 0, void 0, datas);
+        yield new arrow5.RecordBatch(arrowSchema, structData);
+        batchLength = 0;
+      }
+    }
+  }
+  if (batchLength > 0) {
+    const datas = builders.map((builder) => builder.flush());
+    const structData = new arrow5.Data(structField, 0, batchLength, 0, void 0, datas);
+    yield new arrow5.RecordBatch(arrowSchema, structData);
+    batchLength = 0;
+  }
+  builders.map((builder) => builder.finish());
+}
+
+// dist/lib/geoarrow/convert-geoarrow-to-binary-geometry.js
 var import_polygon = require("@math.gl/polygon");
 
-// dist/geoarrow/get-arrow-bounds.js
+// dist/lib/geoarrow/get-arrow-bounds.js
 function updateBoundsFromGeoArrowSamples(flatCoords, nDim, bounds, sampleSize = 100) {
   const numberOfFeatures = flatCoords.length / nDim;
   const sampleStep = Math.max(Math.floor(numberOfFeatures / sampleSize), 1);
@@ -648,7 +835,7 @@ function updateBoundsFromGeoArrowSamples(flatCoords, nDim, bounds, sampleSize =
   return newBounds;
 }
 
-// dist/geoarrow/convert-geoarrow-to-binary-geometry.js
+// dist/lib/geoarrow/convert-geoarrow-to-binary-geometry.js
 var BinaryGeometryType;
 (function(BinaryGeometryType2) {
   BinaryGeometryType2["points"] = "points";
@@ -936,159 +1123,11 @@ function getBinaryPointsFromChunk(chunk, geoEncoding) {
   };
 }
 
-// dist/geoarrow/convert-geoarrow-to-geojson-geometry.js
-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(arrowCellValue);
-      break;
-    case "geoarrow.polygon":
-      geometry = arrowPolygonToFeature(arrowCellValue);
-      break;
-    case "geoarrow.multipoint":
-      geometry = arrowMultiPointToFeature(arrowCellValue);
-      break;
-    case "geoarrow.point":
-      geometry = arrowPointToFeature(arrowCellValue);
-      break;
-    case "geoarrow.multilinestring":
-      geometry = arrowMultiLineStringToFeature(arrowCellValue);
-      break;
-    case "geoarrow.linestring":
-      geometry = arrowLineStringToFeature(arrowCellValue);
-      break;
-    case "geoarrow.wkb":
-      geometry = arrowWKBToFeature(arrowCellValue);
-      break;
-    case "geoarrow.wkt":
-      geometry = arrowWKTToFeature(arrowCellValue);
-      break;
-    default: {
-      throw Error(`GeoArrow encoding not supported ${encoding}`);
-    }
-  }
-  return 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 = [];
-  for (let m = 0; m < arrowMultiPolygon.length; m++) {
-    const arrowPolygon = arrowMultiPolygon.get(m);
-    const polygon = [];
-    for (let i = 0; arrowPolygon && i < (arrowPolygon == null ? void 0 : arrowPolygon.length); i++) {
-      const arrowRing = arrowPolygon == null ? void 0 : arrowPolygon.get(i);
-      const ring = [];
-      for (let j = 0; arrowRing && j < arrowRing.length; j++) {
-        const arrowCoord = arrowRing.get(j);
-        const coord = Array.from(arrowCoord);
-        ring.push(coord);
-      }
-      polygon.push(ring);
-    }
-    multiPolygon.push(polygon);
-  }
-  const geometry = {
-    type: "MultiPolygon",
-    coordinates: multiPolygon
-  };
-  return geometry;
-}
-function arrowPolygonToFeature(arrowPolygon) {
-  const polygon = [];
-  for (let i = 0; arrowPolygon && i < arrowPolygon.length; i++) {
-    const arrowRing = arrowPolygon.get(i);
-    const ring = [];
-    for (let j = 0; arrowRing && j < arrowRing.length; j++) {
-      const arrowCoord = arrowRing.get(j);
-      const coords = Array.from(arrowCoord);
-      ring.push(coords);
-    }
-    polygon.push(ring);
-  }
-  const geometry = {
-    type: "Polygon",
-    coordinates: polygon
-  };
-  return geometry;
-}
-function arrowMultiPointToFeature(arrowMultiPoint) {
-  const multiPoint = [];
-  for (let i = 0; arrowMultiPoint && i < arrowMultiPoint.length; i++) {
-    const arrowPoint = arrowMultiPoint.get(i);
-    if (arrowPoint) {
-      const coord = Array.from(arrowPoint);
-      multiPoint.push(coord);
-    }
-  }
-  return {
-    type: "MultiPoint",
-    coordinates: multiPoint
-  };
-}
-function arrowPointToFeature(arrowPoint) {
-  const point = Array.from(arrowPoint);
-  return {
-    type: "Point",
-    coordinates: point
-  };
-}
-function arrowMultiLineStringToFeature(arrowMultiLineString) {
-  const multiLineString = [];
-  for (let i = 0; arrowMultiLineString && i < arrowMultiLineString.length; i++) {
-    const arrowLineString = arrowMultiLineString.get(i);
-    const lineString = [];
-    for (let j = 0; arrowLineString && j < arrowLineString.length; j++) {
-      const arrowCoord = arrowLineString.get(j);
-      if (arrowCoord) {
-        const coords = Array.from(arrowCoord);
-        lineString.push(coords);
-      }
-    }
-    multiLineString.push(lineString);
-  }
-  return {
-    type: "MultiLineString",
-    coordinates: multiLineString
-  };
-}
-function arrowLineStringToFeature(arrowLineString) {
-  const lineString = [];
-  for (let i = 0; arrowLineString && i < arrowLineString.length; i++) {
-    const arrowCoord = arrowLineString.get(i);
-    if (arrowCoord) {
-      const coords = Array.from(arrowCoord);
-      lineString.push(coords);
-    }
-  }
-  return {
-    type: "LineString",
-    coordinates: lineString
-  };
-}
-
 // dist/workers/hard-clone.js
-var arrow7 = __toESM(require("apache-arrow"), 1);
+var arrow6 = __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)));
+    return new arrow6.Vector(data.data.map((data2) => hardClone(data2, force)));
   }
   const clonedChildren = [];
   for (const childData of data.children) {
@@ -1099,12 +1138,12 @@ function hardClone(data, force = false) {
     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)
+    [arrow6.BufferType.OFFSET]: cloneBuffer(data.buffers[arrow6.BufferType.OFFSET], force),
+    [arrow6.BufferType.DATA]: cloneBuffer(data.buffers[arrow6.BufferType.DATA], force),
+    [arrow6.BufferType.VALIDITY]: cloneBuffer(data.buffers[arrow6.BufferType.VALIDITY], force),
+    [arrow6.BufferType.TYPE]: cloneBuffer(data.buffers[arrow6.BufferType.TYPE], force)
   };
-  return new arrow7.Data(
+  return new arrow6.Data(
     data.type,
     data.offset,
     data.length,
@@ -1131,7 +1170,7 @@ function cloneBuffer(arr, force) {
 
 // dist/triangulate-on-worker.js
 var import_worker_utils = require("@loaders.gl/worker-utils");
-var VERSION3 = true ? "4.3.0-alpha.7" : "latest";
+var VERSION3 = true ? "4.3.0-beta.1" : "latest";
 var TriangulationWorker = {
   id: "triangulation",
   name: "Triangulate",
@@ -1147,5 +1186,5 @@ function parseGeoArrowOnWorker(data, options = {}) {
 }
 
 // dist/index.js
-import_schema3.TableBatchBuilder.ArrowBatch = ArrowTableBatchAggregator;
+import_schema4.TableBatchBuilder.ArrowBatch = ArrowTableBatchAggregator;
 //# sourceMappingURL=index.cjs.map