@loaders.gl/flatgeobuf 4.3.0-alpha.2 → 4.3.0-alpha.4

package/dist/dist.dev.js

@@ -8621,15 +8621,8 @@ var __exports__ = (() => {
   // src/lib/parse-flatgeobuf.ts
   var deserializeGeoJson = deserialize3;
   var deserializeGeneric = deserialize4;
-  function binaryFromFeature(feature, header) {
-    const geometry = feature.geometry();
-    const geometryType = header.geometryType || geometry?.type();
-    const parsedGeometry = fgbToBinaryGeometry(geometry, geometryType);
-    parsedGeometry.properties = parseProperties(feature, header.columns);
-    return parsedGeometry;
-  }
   function parseFlatGeobuf(arrayBuffer, options) {
-    const shape = options?.flatgeobuf?.shape;
+    const shape = options.shape;
     switch (shape) {
       case "geojson-table": {
         return parseFlatGeobufToGeoJSONTable(arrayBuffer, options);
@@ -8647,24 +8640,25 @@ var __exports__ = (() => {
     const array = new Uint8Array(arrayBuffer);
     return deserializeGeneric(array, fgbToBinaryGeometry);
   }
-  function parseFlatGeobufToGeoJSONTable(arrayBuffer, options = {}) {
+  function parseFlatGeobufToGeoJSONTable(arrayBuffer, options) {
     if (arrayBuffer.byteLength === 0) {
       return { shape: "geojson-table", type: "FeatureCollection", features: [] };
     }
-    const { reproject = false, _targetCrs = "WGS84" } = options && options.gis || {};
+    const { reproject = false, crs = "WGS84" } = options;
     const arr = new Uint8Array(arrayBuffer);
     let fgbHeader;
     let schema;
-    let { features } = deserializeGeoJson(arr, void 0, (headerMeta) => {
+    const rect = options.boundingBox && convertBoundingBox(options.boundingBox);
+    let { features } = deserializeGeoJson(arr, rect, (headerMeta) => {
       fgbHeader = headerMeta;
       schema = getSchemaFromFGBHeader(fgbHeader);
     });
-    const crs = fgbHeader && fgbHeader.crs;
+    const fromCRS = fgbHeader?.crs?.wkt;
     let projection;
-    if (reproject && crs) {
+    if (reproject && fromCRS) {
       try {
-        projection = new Proj4Projection({ from: crs.wkt, to: _targetCrs });
-      } catch (e) {
+        projection = new Proj4Projection({ from: fromCRS, to: crs });
+      } catch (error) {
       }
     }
     if (projection) {
@@ -8673,7 +8667,7 @@ var __exports__ = (() => {
     return { shape: "geojson-table", schema, type: "FeatureCollection", features };
   }
   function parseFlatGeobufInBatches(stream, options) {
-    const shape = options.flatgeobuf?.shape;
+    const shape = options.shape;
     switch (shape) {
       case "binary":
         return parseFlatGeobufInBatchesToBinary(stream, options);
@@ -8684,11 +8678,12 @@ var __exports__ = (() => {
     }
   }
   function parseFlatGeobufInBatchesToBinary(stream, options) {
-    const iterator = deserializeGeneric(stream, binaryFromFeature);
+    const rect = options.boundingBox && convertBoundingBox(options.boundingBox);
+    const iterator = deserializeGeneric(stream, binaryFromFeature, rect);
     return iterator;
   }
   async function* parseFlatGeobufInBatchesToGeoJSON(stream, options) {
-    const { reproject = false, _targetCrs = "WGS84" } = options && options.gis || {};
+    const { reproject = false, crs = "WGS84" } = options || {};
     let fgbHeader;
     const iterator = deserializeGeoJson(stream, void 0, (headerMeta) => {
       fgbHeader = headerMeta;
@@ -8697,9 +8692,9 @@ var __exports__ = (() => {
     let firstRecord = true;
     for await (const feature of iterator) {
       if (firstRecord) {
-        const crs = fgbHeader && fgbHeader.crs;
-        if (reproject && crs) {
-          projection = new Proj4Projection({ from: crs.wkt, to: _targetCrs });
+        const fromCRS = fgbHeader?.crs?.wkt;
+        if (reproject && fromCRS) {
+          projection = new Proj4Projection({ from: fromCRS, to: crs });
         }
         firstRecord = false;
       }
@@ -8710,6 +8705,21 @@ var __exports__ = (() => {
       }
     }
   }
+  function convertBoundingBox(boundingBox) {
+    return {
+      minX: boundingBox[0][0],
+      minY: boundingBox[0][1],
+      maxX: boundingBox[1][0],
+      maxY: boundingBox[1][1]
+    };
+  }
+  function binaryFromFeature(feature, header) {
+    const geometry = feature.geometry();
+    const geometryType = header.geometryType || geometry?.type();
+    const parsedGeometry = fgbToBinaryGeometry(geometry, geometryType);
+    parsedGeometry.properties = parseProperties(feature, header.columns);
+    return parsedGeometry;
+  }
 
   // src/flatgeobuf-loader.ts
   var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
@@ -8737,12 +8747,31 @@ var __exports__ = (() => {
   };
   var FlatGeobufLoader = {
     ...FlatGeobufWorkerLoader,
-    parse: async (arrayBuffer, options) => parseFlatGeobuf(arrayBuffer, options),
-    parseSync: parseFlatGeobuf,
+    parse: async (arrayBuffer, options = {}) => parseSync(arrayBuffer, options),
+    parseSync,
     // @ts-expect-error this is a stream parser not an async iterator parser
-    parseInBatchesFromStream: parseFlatGeobufInBatches,
+    parseInBatchesFromStream,
     binary: true
   };
+  function parseSync(arrayBuffer, options = {}) {
+    return parseFlatGeobuf(arrayBuffer, getOptions(options));
+  }
+  function parseInBatchesFromStream(stream, options) {
+    return parseFlatGeobufInBatches(stream, getOptions(options));
+  }
+  function getOptions(options) {
+    options = {
+      ...options,
+      flatgeobuf: { ...FlatGeobufLoader.options.flatgeobuf, ...options?.flatgeobuf },
+      gis: { ...FlatGeobufLoader.options.gis, ...options?.gis }
+    };
+    return {
+      shape: options?.flatgeobuf?.shape ?? "geojson-table",
+      boundingBox: options?.flatgeobuf?.boundingBox,
+      crs: options?.gis?._targetCrs || "WGS84",
+      reproject: options?.gis?.reproject || false
+    };
+  }
   return __toCommonJS(bundle_exports);
 })();
 /*! Bundled license information: