@loaders.gl/arrow 4.0.1 → 4.0.2

package/dist/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -23,6 +33,7 @@ __export(src_exports, {
   ArrowLoader: () => ArrowLoader2,
   ArrowWorkerLoader: () => ArrowLoader,
   ArrowWriter: () => ArrowWriter,
+  BINARY_GEOMETRY_TEMPLATE: () => BINARY_GEOMETRY_TEMPLATE,
   VECTOR_TYPES: () => VECTOR_TYPES,
   deserializeArrowField: () => deserializeArrowField,
   deserializeArrowMetadata: () => deserializeArrowMetadata,
@@ -34,7 +45,8 @@ __export(src_exports, {
   serializeArrowField: () => serializeArrowField,
   serializeArrowMetadata: () => serializeArrowMetadata,
   serializeArrowSchema: () => serializeArrowSchema,
-  serializeArrowType: () => serializeArrowType
+  serializeArrowType: () => serializeArrowType,
+  updateBoundsFromGeoArrowSamples: () => updateBoundsFromGeoArrowSamples
 });
 module.exports = __toCommonJS(src_exports);
 var import_schema3 = require("@loaders.gl/schema");
@@ -65,7 +77,7 @@ var ArrowLoader = {
 
 // src/lib/parse-arrow-sync.ts
 var import_schema = require("@loaders.gl/schema");
-var import_apache_arrow = require("apache-arrow");
+var arrow = __toESM(require("apache-arrow"), 1);
 
 // src/tables/convert-arrow-to-table.ts
 function convertApacheArrowToArrowTable(arrowTable) {
@@ -91,7 +103,7 @@ function convertArrowToColumnarTable(table) {
 // src/lib/parse-arrow-sync.ts
 function parseArrowSync(arrayBuffer, options) {
   var _a;
-  const apacheArrowTable = (0, import_apache_arrow.tableFromIPC)([new Uint8Array(arrayBuffer)]);
+  const apacheArrowTable = arrow.tableFromIPC([new Uint8Array(arrayBuffer)]);
   const arrowTable = convertApacheArrowToArrowTable(apacheArrowTable);
   const shape = ((_a = options == null ? void 0 : options.arrow) == null ? void 0 : _a.shape) || "arrow-table";
   switch (shape) {
@@ -108,16 +120,16 @@ function parseArrowSync(arrayBuffer, options) {
 }
 
 // src/lib/parse-arrow-in-batches.ts
-var import_apache_arrow2 = require("apache-arrow");
+var arrow2 = __toESM(require("apache-arrow"), 1);
 function parseArrowInBatches(asyncIterator) {
   async function* makeArrowAsyncIterator() {
-    const readers = import_apache_arrow2.RecordBatchReader.readAll(asyncIterator);
+    const readers = arrow2.RecordBatchReader.readAll(asyncIterator);
     for await (const reader of readers) {
       for await (const recordBatch of reader) {
         const arrowTabledBatch = {
           shape: "arrow-table",
           batchType: "data",
-          data: new import_apache_arrow2.Table([recordBatch]),
+          data: new arrow2.Table([recordBatch]),
           length: recordBatch.data.length
         };
         yield arrowTabledBatch;
@@ -130,7 +142,7 @@ function parseArrowInBatches(asyncIterator) {
 
 // src/lib/arrow-table-batch.ts
 var import_schema2 = require("@loaders.gl/schema");
-var import_apache_arrow3 = require("apache-arrow");
+var arrow3 = __toESM(require("apache-arrow"), 1);
 var ArrowTableBatchAggregator = class extends import_schema2.ColumnarTableBatchAggregator {
   constructor(schema, options) {
     super(schema, options);
@@ -141,17 +153,17 @@ var ArrowTableBatchAggregator = class extends import_schema2.ColumnarTableBatchA
     if (batch) {
       this.arrowSchema = this.arrowSchema || getArrowSchema(batch.schema);
       const arrowVectors = getArrowVectors(this.arrowSchema, batch.data);
-      const recordBatch = new import_apache_arrow3.RecordBatch(
+      const recordBatch = new arrow3.RecordBatch(
         this.arrowSchema,
-        (0, import_apache_arrow3.makeData)({
-          type: new import_apache_arrow3.Struct(this.arrowSchema.fields),
+        arrow3.makeData({
+          type: new arrow3.Struct(this.arrowSchema.fields),
           children: arrowVectors.map(({ data }) => data[0])
         })
       );
       return {
         shape: "arrow-table",
         batchType: "data",
-        data: new import_apache_arrow3.Table([recordBatch]),
+        data: new arrow3.Table([recordBatch]),
         length: batch.length
       };
     }
@@ -164,21 +176,21 @@ function getArrowSchema(schema) {
     const field = schema[key];
     if (field.type === Float32Array) {
       const metadata = /* @__PURE__ */ new Map();
-      const arrowField = new import_apache_arrow3.Field(field.name, new import_apache_arrow3.Float32(), field.nullable, metadata);
+      const arrowField = new arrow3.Field(field.name, new arrow3.Float32(), field.nullable, metadata);
       arrowFields.push(arrowField);
     }
   }
   if (arrowFields.length === 0) {
     throw new Error("No arrow convertible fields");
   }
-  return new import_apache_arrow3.Schema(arrowFields);
+  return new arrow3.Schema(arrowFields);
 }
 function getArrowVectors(arrowSchema, data) {
   const arrowVectors = [];
   for (const field of arrowSchema.fields) {
     const vector = data[field.name];
     if (vector instanceof Float32Array) {
-      const arrowVector = (0, import_apache_arrow3.makeVector)(vector);
+      const arrowVector = arrow3.makeVector(vector);
       arrowVectors.push(arrowVector);
     }
   }
@@ -189,32 +201,32 @@ function getArrowVectors(arrowSchema, data) {
 }
 
 // src/schema/arrow-type-utils.ts
-var import_apache_arrow4 = require("apache-arrow");
+var arrow4 = __toESM(require("apache-arrow"), 1);
 function getArrowType(array) {
   switch (array.constructor) {
     case Int8Array:
-      return new import_apache_arrow4.Int8();
+      return new arrow4.Int8();
     case Uint8Array:
-      return new import_apache_arrow4.Uint8();
+      return new arrow4.Uint8();
     case Int16Array:
-      return new import_apache_arrow4.Int16();
+      return new arrow4.Int16();
     case Uint16Array:
-      return new import_apache_arrow4.Uint16();
+      return new arrow4.Uint16();
     case Int32Array:
-      return new import_apache_arrow4.Int32();
+      return new arrow4.Int32();
     case Uint32Array:
-      return new import_apache_arrow4.Uint32();
+      return new arrow4.Uint32();
     case Float32Array:
-      return new import_apache_arrow4.Float32();
+      return new arrow4.Float32();
     case Float64Array:
-      return new import_apache_arrow4.Float64();
+      return new arrow4.Float64();
     default:
       throw new Error("array type not supported");
   }
 }
 
 // src/schema/convert-arrow-schema.ts
-var import_apache_arrow5 = require("apache-arrow");
+var arrow5 = __toESM(require("apache-arrow"), 1);
 function serializeArrowSchema(arrowSchema) {
   return {
     fields: arrowSchema.fields.map((arrowField) => serializeArrowField(arrowField)),
@@ -222,7 +234,7 @@ function serializeArrowSchema(arrowSchema) {
   };
 }
 function deserializeArrowSchema(schema) {
-  return new import_apache_arrow5.Schema(
+  return new arrow5.Schema(
     schema.fields.map((field) => deserializeArrowField(field)),
     deserializeArrowMetadata(schema.metadata)
   );
@@ -242,7 +254,7 @@ function serializeArrowField(field) {
   };
 }
 function deserializeArrowField(field) {
-  return new import_apache_arrow5.Field(
+  return new arrow5.Field(
     field.name,
     deserializeArrowType(field.type),
     field.nullable,
@@ -251,124 +263,124 @@ function deserializeArrowField(field) {
 }
 function serializeArrowType(arrowType) {
   switch (arrowType.constructor) {
-    case import_apache_arrow5.Null:
+    case arrow5.Null:
       return "null";
-    case import_apache_arrow5.Binary:
+    case arrow5.Binary:
       return "binary";
-    case import_apache_arrow5.Bool:
+    case arrow5.Bool:
       return "bool";
-    case import_apache_arrow5.Int:
+    case arrow5.Int:
       const intType = arrowType;
       return `${intType.isSigned ? "u" : ""}int${intType.bitWidth}`;
-    case import_apache_arrow5.Int8:
+    case arrow5.Int8:
       return "int8";
-    case import_apache_arrow5.Int16:
+    case arrow5.Int16:
       return "int16";
-    case import_apache_arrow5.Int32:
+    case arrow5.Int32:
       return "int32";
-    case import_apache_arrow5.Int64:
+    case arrow5.Int64:
       return "int64";
-    case import_apache_arrow5.Uint8:
+    case arrow5.Uint8:
       return "uint8";
-    case import_apache_arrow5.Uint16:
+    case arrow5.Uint16:
       return "uint16";
-    case import_apache_arrow5.Uint32:
+    case arrow5.Uint32:
       return "uint32";
-    case import_apache_arrow5.Uint64:
+    case arrow5.Uint64:
       return "uint64";
-    case import_apache_arrow5.Float:
+    case arrow5.Float:
       const precision = arrowType.precision;
       switch (precision) {
-        case import_apache_arrow5.Precision.HALF:
+        case arrow5.Precision.HALF:
           return "float16";
-        case import_apache_arrow5.Precision.SINGLE:
+        case arrow5.Precision.SINGLE:
           return "float32";
-        case import_apache_arrow5.Precision.DOUBLE:
+        case arrow5.Precision.DOUBLE:
           return "float64";
         default:
           return "float16";
       }
-    case import_apache_arrow5.Float16:
+    case arrow5.Float16:
       return "float16";
-    case import_apache_arrow5.Float32:
+    case arrow5.Float32:
       return "float32";
-    case import_apache_arrow5.Float64:
+    case arrow5.Float64:
       return "float64";
-    case import_apache_arrow5.Utf8:
+    case arrow5.Utf8:
       return "utf8";
     case Date:
       const dateUnit = arrowType.unit;
-      return dateUnit === import_apache_arrow5.DateUnit.DAY ? "date-day" : "date-millisecond";
-    case import_apache_arrow5.DateDay:
+      return dateUnit === arrow5.DateUnit.DAY ? "date-day" : "date-millisecond";
+    case arrow5.DateDay:
       return "date-day";
-    case import_apache_arrow5.DateMillisecond:
+    case arrow5.DateMillisecond:
       return "date-millisecond";
-    case import_apache_arrow5.Time:
+    case arrow5.Time:
       const timeUnit = arrowType.unit;
       switch (timeUnit) {
-        case import_apache_arrow5.TimeUnit.SECOND:
+        case arrow5.TimeUnit.SECOND:
           return "time-second";
-        case import_apache_arrow5.TimeUnit.MILLISECOND:
+        case arrow5.TimeUnit.MILLISECOND:
           return "time-millisecond";
-        case import_apache_arrow5.TimeUnit.MICROSECOND:
+        case arrow5.TimeUnit.MICROSECOND:
           return "time-microsecond";
-        case import_apache_arrow5.TimeUnit.NANOSECOND:
+        case arrow5.TimeUnit.NANOSECOND:
           return "time-nanosecond";
         default:
           return "time-second";
       }
-    case import_apache_arrow5.TimeMillisecond:
+    case arrow5.TimeMillisecond:
       return "time-millisecond";
-    case import_apache_arrow5.TimeSecond:
+    case arrow5.TimeSecond:
       return "time-second";
-    case import_apache_arrow5.TimeMicrosecond:
+    case arrow5.TimeMicrosecond:
       return "time-microsecond";
-    case import_apache_arrow5.TimeNanosecond:
+    case arrow5.TimeNanosecond:
       return "time-nanosecond";
-    case import_apache_arrow5.Timestamp:
+    case arrow5.Timestamp:
       const timeStampUnit = arrowType.unit;
       switch (timeStampUnit) {
-        case import_apache_arrow5.TimeUnit.SECOND:
+        case arrow5.TimeUnit.SECOND:
           return "timestamp-second";
-        case import_apache_arrow5.TimeUnit.MILLISECOND:
+        case arrow5.TimeUnit.MILLISECOND:
           return "timestamp-millisecond";
-        case import_apache_arrow5.TimeUnit.MICROSECOND:
+        case arrow5.TimeUnit.MICROSECOND:
           return "timestamp-microsecond";
-        case import_apache_arrow5.TimeUnit.NANOSECOND:
+        case arrow5.TimeUnit.NANOSECOND:
           return "timestamp-nanosecond";
         default:
           return "timestamp-second";
       }
-    case import_apache_arrow5.TimestampSecond:
+    case arrow5.TimestampSecond:
       return "timestamp-second";
-    case import_apache_arrow5.TimestampMillisecond:
+    case arrow5.TimestampMillisecond:
       return "timestamp-millisecond";
-    case import_apache_arrow5.TimestampMicrosecond:
+    case arrow5.TimestampMicrosecond:
       return "timestamp-microsecond";
-    case import_apache_arrow5.TimestampNanosecond:
+    case arrow5.TimestampNanosecond:
       return "timestamp-nanosecond";
-    case import_apache_arrow5.Interval:
+    case arrow5.Interval:
       const intervalUnit = arrowType.unit;
       switch (intervalUnit) {
-        case import_apache_arrow5.IntervalUnit.DAY_TIME:
+        case arrow5.IntervalUnit.DAY_TIME:
           return "interval-daytime";
-        case import_apache_arrow5.IntervalUnit.YEAR_MONTH:
+        case arrow5.IntervalUnit.YEAR_MONTH:
           return "interval-yearmonth";
         default:
           return "interval-daytime";
       }
-    case import_apache_arrow5.IntervalDayTime:
+    case arrow5.IntervalDayTime:
       return "interval-daytime";
-    case import_apache_arrow5.IntervalYearMonth:
+    case arrow5.IntervalYearMonth:
       return "interval-yearmonth";
-    case import_apache_arrow5.List:
+    case arrow5.List:
       const listType = arrowType;
       const listField = listType.valueField;
       return {
         type: "list",
         children: [serializeArrowField(listField)]
       };
-    case import_apache_arrow5.FixedSizeList:
+    case arrow5.FixedSizeList:
       return {
         type: "fixed-size-list",
         listSize: arrowType.listSize,
@@ -383,72 +395,72 @@ function deserializeArrowType(dataType) {
     switch (dataType.type) {
       case "list":
         const field = deserializeArrowField(dataType.children[0]);
-        return new import_apache_arrow5.List(field);
+        return new arrow5.List(field);
       case "fixed-size-list":
         const child = deserializeArrowField(dataType.children[0]);
-        return new import_apache_arrow5.FixedSizeList(dataType.listSize, child);
+        return new arrow5.FixedSizeList(dataType.listSize, child);
       case "struct":
         const children = dataType.children.map((arrowField) => deserializeArrowField(arrowField));
-        return new import_apache_arrow5.Struct(children);
+        return new arrow5.Struct(children);
       default:
         throw new Error("array type not supported");
     }
   }
   switch (dataType) {
     case "null":
-      return new import_apache_arrow5.Null();
+      return new arrow5.Null();
     case "binary":
-      return new import_apache_arrow5.Binary();
+      return new arrow5.Binary();
     case "bool":
-      return new import_apache_arrow5.Bool();
+      return new arrow5.Bool();
     case "int8":
-      return new import_apache_arrow5.Int8();
+      return new arrow5.Int8();
     case "int16":
-      return new import_apache_arrow5.Int16();
+      return new arrow5.Int16();
     case "int32":
-      return new import_apache_arrow5.Int32();
+      return new arrow5.Int32();
     case "int64":
-      return new import_apache_arrow5.Int64();
+      return new arrow5.Int64();
     case "uint8":
-      return new import_apache_arrow5.Uint8();
+      return new arrow5.Uint8();
     case "uint16":
-      return new import_apache_arrow5.Uint16();
+      return new arrow5.Uint16();
     case "uint32":
-      return new import_apache_arrow5.Uint32();
+      return new arrow5.Uint32();
     case "uint64":
-      return new import_apache_arrow5.Uint64();
+      return new arrow5.Uint64();
     case "float16":
-      return new import_apache_arrow5.Float16();
+      return new arrow5.Float16();
     case "float32":
-      return new import_apache_arrow5.Float32();
+      return new arrow5.Float32();
     case "float64":
-      return new import_apache_arrow5.Float64();
+      return new arrow5.Float64();
     case "utf8":
-      return new import_apache_arrow5.Utf8();
+      return new arrow5.Utf8();
     case "date-day":
-      return new import_apache_arrow5.DateDay();
+      return new arrow5.DateDay();
     case "date-millisecond":
-      return new import_apache_arrow5.DateMillisecond();
+      return new arrow5.DateMillisecond();
     case "time-second":
-      return new import_apache_arrow5.TimeSecond();
+      return new arrow5.TimeSecond();
     case "time-millisecond":
-      return new import_apache_arrow5.TimeMillisecond();
+      return new arrow5.TimeMillisecond();
     case "time-microsecond":
-      return new import_apache_arrow5.TimeMicrosecond();
+      return new arrow5.TimeMicrosecond();
     case "time-nanosecond":
-      return new import_apache_arrow5.TimeNanosecond();
+      return new arrow5.TimeNanosecond();
     case "timestamp-second":
-      return new import_apache_arrow5.TimestampSecond();
+      return new arrow5.TimestampSecond();
     case "timestamp-millisecond":
-      return new import_apache_arrow5.TimestampMillisecond();
+      return new arrow5.TimestampMillisecond();
     case "timestamp-microsecond":
-      return new import_apache_arrow5.TimestampMicrosecond();
+      return new arrow5.TimestampMicrosecond();
     case "timestamp-nanosecond":
-      return new import_apache_arrow5.TimestampNanosecond();
+      return new arrow5.TimestampNanosecond();
     case "interval-daytime":
-      return new import_apache_arrow5.IntervalDayTime();
+      return new arrow5.IntervalDayTime();
     case "interval-yearmonth":
-      return new import_apache_arrow5.IntervalYearMonth();
+      return new arrow5.IntervalYearMonth();
     default:
       throw new Error("array type not supported");
   }
@@ -462,24 +474,24 @@ var VECTOR_TYPES = /* @__PURE__ */ ((VECTOR_TYPES2) => {
 })(VECTOR_TYPES || {});
 
 // src/lib/encode-arrow.ts
-var import_apache_arrow6 = require("apache-arrow");
+var arrow6 = __toESM(require("apache-arrow"), 1);
 function encodeArrowSync(data) {
   const vectors = {};
   for (const arrayData of data) {
     const arrayVector = createVector(arrayData.array, arrayData.type);
     vectors[arrayData.name] = arrayVector;
   }
-  const table = new import_apache_arrow6.Table(vectors);
-  const arrowBuffer = (0, import_apache_arrow6.tableToIPC)(table);
+  const table = new arrow6.Table(vectors);
+  const arrowBuffer = arrow6.tableToIPC(table);
   return arrowBuffer;
 }
 function createVector(array, type) {
   switch (type) {
     case 1 /* DATE */:
-      return (0, import_apache_arrow6.vectorFromArray)(array);
+      return arrow6.vectorFromArray(array);
     case 0 /* FLOAT */:
     default:
-      return (0, import_apache_arrow6.vectorFromArray)(array);
+      return arrow6.vectorFromArray(array);
   }
 }
 
@@ -496,11 +508,14 @@ var ArrowWriter = {
     "application/vnd.apache.arrow.stream",
     "application/octet-stream"
   ],
-  encodeSync(data, options) {
+  binary: true,
+  options: {},
+  encode: async function encodeArrow(data, options) {
     return encodeArrowSync(data);
   },
-  binary: true,
-  options: {}
+  encodeSync(data, options) {
+    return encodeArrowSync(data);
+  }
 };
 
 // src/geoarrow/get-arrow-bounds.ts
@@ -511,7 +526,7 @@ function updateBoundsFromGeoArrowSamples(flatCoords, nDim, bounds, sampleSize =
   for (let i = 0; i < numberOfFeatures; i += sampleStep) {
     const lng = flatCoords[i * nDim];
     const lat = flatCoords[i * nDim + 1];
-    if (lng < bounds[0]) {
+    if (lng < newBounds[0]) {
       newBounds[0] = lng;
     }
     if (lat < newBounds[1]) {
@@ -542,13 +557,12 @@ function getBinaryGeometriesFromArrow(geoColumn, geoEncoding) {
     line: geoEncoding === "geoarrow.multilinestring" || geoEncoding === "geoarrow.linestring"
   };
   const chunks = geoColumn.data;
-  const bounds = [Infinity, Infinity, -Infinity, -Infinity];
+  let bounds = [Infinity, Infinity, -Infinity, -Infinity];
   let globalFeatureIdOffset = 0;
   const binaryGeometries = [];
-  for (let c = 0; c < chunks.length; c++) {
-    const geometries = chunks[c];
+  chunks.forEach((chunk) => {
     const { featureIds, flatCoordinateArray, nDim, geomOffset } = getBinaryGeometriesFromChunk(
-      geometries,
+      chunk,
       geoEncoding
     );
     const numOfVertices = flatCoordinateArray.length / nDim;
@@ -563,12 +577,11 @@ function getBinaryGeometriesFromArrow(geoColumn, geoEncoding) {
         size: nDim
       },
       featureIds: { value: featureIds, size: 1 },
-      // eslint-disable-next-line no-loop-func
-      properties: [...Array(geometries.length).keys()].map((i) => ({
+      properties: [...Array(chunk.length).keys()].map((i) => ({
         index: i + globalFeatureIdOffset
       }))
     };
-    globalFeatureIdOffset += geometries.length;
+    globalFeatureIdOffset += chunk.length;
     binaryGeometries.push({
       shape: "binary-feature-collection",
       points: {
@@ -598,8 +611,8 @@ function getBinaryGeometriesFromArrow(geoColumn, geoEncoding) {
         }
       }
     });
-    updateBoundsFromGeoArrowSamples(flatCoordinateArray, nDim, bounds);
-  }
+    bounds = updateBoundsFromGeoArrowSamples(flatCoordinateArray, nDim, bounds);
+  });
   return { binaryGeometries, bounds, featureTypes };
 }
 function getBinaryGeometriesFromChunk(chunk, geoEncoding) {

package/dist/index.d.ts

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

package/dist/index.d.ts.map

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

package/dist/index.js

@@ -15,6 +15,7 @@ export const ArrowLoader = {
   parseSync,
   parseInBatches: parseArrowInBatches
 };
-export { getBinaryGeometriesFromArrow } from "./geoarrow/convert-geoarrow-to-binary-geometry.js";
+export { BINARY_GEOMETRY_TEMPLATE, getBinaryGeometriesFromArrow } from "./geoarrow/convert-geoarrow-to-binary-geometry.js";
 export { parseGeometryFromArrow } from "./geoarrow/convert-geoarrow-to-geojson.js";
+export { updateBoundsFromGeoArrowSamples } from "./geoarrow/get-arrow-bounds.js";
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["TableBatchBuilder","ArrowLoader","ArrowWorkerLoader","parseSync","parseArrowInBatches","ArrowTableBatchAggregator","ArrowBatch","getArrowType","serializeArrowSchema","deserializeArrowSchema","serializeArrowMetadata","deserializeArrowMetadata","serializeArrowField","deserializeArrowField","serializeArrowType","deserializeArrowType","VECTOR_TYPES","ArrowWriter","parse","arraybuffer","options","parseInBatches","getBinaryGeometriesFromArrow","parseGeometryFromArrow"],"sources":["../src/index.ts"],"sourcesContent":["// loaders.gl, MIT license\n// Copyright (c) vis.gl contributors\n\nimport type {LoaderWithParser} from '@loaders.gl/loader-utils';\nimport type {ArrowLoaderOptions} from './arrow-loader';\nimport type {ArrowTableBatch, ColumnarTable, ObjectRowTable} from '@loaders.gl/schema';\nimport type {ArrowTable} from './lib/arrow-table';\n\nimport {TableBatchBuilder} from '@loaders.gl/schema';\nimport {ArrowLoader as ArrowWorkerLoader} from './arrow-loader';\nimport parseSync from './lib/parse-arrow-sync';\nimport {parseArrowInBatches} from './lib/parse-arrow-in-batches';\n\nimport {ArrowTableBatchAggregator} from './lib/arrow-table-batch';\n\n// Make the ArrowBatch type available\nTableBatchBuilder.ArrowBatch = ArrowTableBatchAggregator;\n\n// TYPES\n\nexport {getArrowType} from './schema/arrow-type-utils';\n\n// SCHEMA\n\nexport {\n  serializeArrowSchema,\n  deserializeArrowSchema,\n  serializeArrowMetadata,\n  deserializeArrowMetadata,\n  serializeArrowField,\n  deserializeArrowField,\n  serializeArrowType,\n  deserializeArrowType\n} from './schema/convert-arrow-schema';\n\n// Types\nexport type {ArrowTable, ArrowTableBatch} from './lib/arrow-table';\nexport {VECTOR_TYPES} from './types';\n\n// Arrow writer\n\nexport {ArrowWriter} from './arrow-writer';\n\n// Arrow loader\n\nexport type {ArrowLoaderOptions};\nexport {ArrowWorkerLoader};\n\n/** ArrowJS table loader */\nexport const ArrowLoader: LoaderWithParser<\n  ArrowTable | ColumnarTable | ObjectRowTable,\n  ArrowTableBatch,\n  ArrowLoaderOptions\n> = {\n  ...ArrowWorkerLoader,\n  parse: async (arraybuffer: ArrayBuffer, options?: ArrowLoaderOptions) =>\n    parseSync(arraybuffer, options),\n  parseSync,\n  parseInBatches: parseArrowInBatches\n};\n\n// Arrow Utils\nexport type {GeoArrowEncoding} from '@loaders.gl/gis';\n// getGeometryColumnsFromArrowTable,\n// getGeoArrowEncoding\n\nexport type {BinaryDataFromGeoArrow} from './geoarrow/convert-geoarrow-to-binary-geometry';\nexport {getBinaryGeometriesFromArrow} from './geoarrow/convert-geoarrow-to-binary-geometry';\n\nexport {parseGeometryFromArrow} from './geoarrow/convert-geoarrow-to-geojson';\n"],"mappings":"AAQA,SAAQA,iBAAiB,QAAO,oBAAoB;AAAC,SAC7CC,WAAW,IAAIC,iBAAiB;AAAA,OACjCC,SAAS;AAAA,SACRC,mBAAmB;AAAA,SAEnBC,yBAAyB;AAGjCL,iBAAiB,CAACM,UAAU,GAAGD,yBAAyB;AAAC,SAIjDE,YAAY;AAAA,SAKlBC,oBAAoB,EACpBC,sBAAsB,EACtBC,sBAAsB,EACtBC,wBAAwB,EACxBC,mBAAmB,EACnBC,qBAAqB,EACrBC,kBAAkB,EAClBC,oBAAoB;AAAA,SAKdC,YAAY;AAAA,SAIZC,WAAW;AAKnB,SAAQf,iBAAiB;AAGzB,OAAO,MAAMD,WAIZ,GAAG;EACF,GAAGC,iBAAiB;EACpBgB,KAAK,EAAE,MAAAA,CAAOC,WAAwB,EAAEC,OAA4B,KAClEjB,SAAS,CAACgB,WAAW,EAAEC,OAAO,CAAC;EACjCjB,SAAS;EACTkB,cAAc,EAAEjB;AAClB,CAAC;AAAC,SAQMkB,4BAA4B;AAAA,SAE5BC,sBAAsB"}
+{"version":3,"file":"index.js","names":["TableBatchBuilder","ArrowLoader","ArrowWorkerLoader","parseSync","parseArrowInBatches","ArrowTableBatchAggregator","ArrowBatch","getArrowType","serializeArrowSchema","deserializeArrowSchema","serializeArrowMetadata","deserializeArrowMetadata","serializeArrowField","deserializeArrowField","serializeArrowType","deserializeArrowType","VECTOR_TYPES","ArrowWriter","parse","arraybuffer","options","parseInBatches","BINARY_GEOMETRY_TEMPLATE","getBinaryGeometriesFromArrow","parseGeometryFromArrow","updateBoundsFromGeoArrowSamples"],"sources":["../src/index.ts"],"sourcesContent":["// loaders.gl, MIT license\n// Copyright (c) vis.gl contributors\n\nimport type {LoaderWithParser} from '@loaders.gl/loader-utils';\nimport type {ArrowLoaderOptions} from './arrow-loader';\nimport type {ArrowTableBatch, ColumnarTable, ObjectRowTable} from '@loaders.gl/schema';\nimport type {ArrowTable} from './lib/arrow-table';\n\nimport {TableBatchBuilder} from '@loaders.gl/schema';\nimport {ArrowLoader as ArrowWorkerLoader} from './arrow-loader';\nimport parseSync from './lib/parse-arrow-sync';\nimport {parseArrowInBatches} from './lib/parse-arrow-in-batches';\n\nimport {ArrowTableBatchAggregator} from './lib/arrow-table-batch';\n\n// Make the ArrowBatch type available\nTableBatchBuilder.ArrowBatch = ArrowTableBatchAggregator;\n\n// TYPES\n\nexport {getArrowType} from './schema/arrow-type-utils';\n\n// SCHEMA\n\nexport {\n  serializeArrowSchema,\n  deserializeArrowSchema,\n  serializeArrowMetadata,\n  deserializeArrowMetadata,\n  serializeArrowField,\n  deserializeArrowField,\n  serializeArrowType,\n  deserializeArrowType\n} from './schema/convert-arrow-schema';\n\n// Types\nexport type {ArrowTable, ArrowTableBatch} from './lib/arrow-table';\nexport {VECTOR_TYPES} from './types';\n\n// Arrow writer\n\nexport {ArrowWriter} from './arrow-writer';\n\n// Arrow loader\n\nexport type {ArrowLoaderOptions};\nexport {ArrowWorkerLoader};\n\n/** ArrowJS table loader */\nexport const ArrowLoader: LoaderWithParser<\n  ArrowTable | ColumnarTable | ObjectRowTable,\n  ArrowTableBatch,\n  ArrowLoaderOptions\n> = {\n  ...ArrowWorkerLoader,\n  parse: async (arraybuffer: ArrayBuffer, options?: ArrowLoaderOptions) =>\n    parseSync(arraybuffer, options),\n  parseSync,\n  parseInBatches: parseArrowInBatches\n};\n\n// Arrow Utils\nexport type {GeoArrowEncoding} from '@loaders.gl/gis';\n// getGeometryColumnsFromArrowTable,\n// getGeoArrowEncoding\n\nexport type {BinaryDataFromGeoArrow} from './geoarrow/convert-geoarrow-to-binary-geometry';\nexport {\n  BINARY_GEOMETRY_TEMPLATE,\n  getBinaryGeometriesFromArrow\n} from './geoarrow/convert-geoarrow-to-binary-geometry';\n\nexport {parseGeometryFromArrow} from './geoarrow/convert-geoarrow-to-geojson';\n\nexport {updateBoundsFromGeoArrowSamples} from './geoarrow/get-arrow-bounds';\n"],"mappings":"AAQA,SAAQA,iBAAiB,QAAO,oBAAoB;AAAC,SAC7CC,WAAW,IAAIC,iBAAiB;AAAA,OACjCC,SAAS;AAAA,SACRC,mBAAmB;AAAA,SAEnBC,yBAAyB;AAGjCL,iBAAiB,CAACM,UAAU,GAAGD,yBAAyB;AAAC,SAIjDE,YAAY;AAAA,SAKlBC,oBAAoB,EACpBC,sBAAsB,EACtBC,sBAAsB,EACtBC,wBAAwB,EACxBC,mBAAmB,EACnBC,qBAAqB,EACrBC,kBAAkB,EAClBC,oBAAoB;AAAA,SAKdC,YAAY;AAAA,SAIZC,WAAW;AAKnB,SAAQf,iBAAiB;AAGzB,OAAO,MAAMD,WAIZ,GAAG;EACF,GAAGC,iBAAiB;EACpBgB,KAAK,EAAE,MAAAA,CAAOC,WAAwB,EAAEC,OAA4B,KAClEjB,SAAS,CAACgB,WAAW,EAAEC,OAAO,CAAC;EACjCjB,SAAS;EACTkB,cAAc,EAAEjB;AAClB,CAAC;AAAC,SASAkB,wBAAwB,EACxBC,4BAA4B;AAAA,SAGtBC,sBAAsB;AAAA,SAEtBC,+BAA+B"}

package/dist/lib/arrow-table-batch.d.ts

@@ -1,8 +1,8 @@
 import { ColumnarTableBatchAggregator } from '@loaders.gl/schema';
 import type { ArrowTableBatch } from './arrow-table';
-import { Schema } from 'apache-arrow';
+import * as arrow from 'apache-arrow';
 export declare class ArrowTableBatchAggregator extends ColumnarTableBatchAggregator {
-    arrowSchema: Schema | null;
+    arrowSchema: arrow.Schema | null;
     constructor(schema: any, options: any);
     getBatch(): ArrowTableBatch | null;
 }

package/dist/lib/arrow-table-batch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"arrow-table-batch.d.ts","sourceRoot":"","sources":["../../src/lib/arrow-table-batch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,4BAA4B,EAAC,MAAM,oBAAoB,CAAC;AAChE,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,eAAe,CAAC;AACnD,OAAO,EAEL,MAAM,EAQP,MAAM,cAAc,CAAC;AAEtB,qBAAa,yBAA0B,SAAQ,4BAA4B;IACzE,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;gBAEf,MAAM,KAAA,EAAE,OAAO,KAAA;IAK3B,QAAQ,IAAI,eAAe,GAAG,IAAI;CA4BnC"}
+{"version":3,"file":"arrow-table-batch.d.ts","sourceRoot":"","sources":["../../src/lib/arrow-table-batch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,4BAA4B,EAAC,MAAM,oBAAoB,CAAC;AAChE,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,eAAe,CAAC;AACnD,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAEtC,qBAAa,yBAA0B,SAAQ,4BAA4B;IACzE,WAAW,EAAE,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC;gBAErB,MAAM,KAAA,EAAE,OAAO,KAAA;IAK3B,QAAQ,IAAI,eAAe,GAAG,IAAI;CA4BnC"}