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

package/dist/flatgeobuf-loader.d.ts

@@ -1,16 +1,17 @@
 import type { LoaderOptions } from '@loaders.gl/loader-utils';
-import { parseFlatGeobuf, parseFlatGeobufInBatches } from "./lib/parse-flatgeobuf.js";
 export type FlatGeobufLoaderOptions = LoaderOptions & {
     flatgeobuf?: {
         shape?: 'geojson-table' | 'columnar-table' | 'binary';
         /** Override the URL to the worker bundle (by default loads from unpkg.com) */
         workerUrl?: string;
+        boundingBox?: [[number, number], [number, number]];
     };
     gis?: {
         reproject?: boolean;
         _targetCrs?: string;
     };
 };
+/** Load flatgeobuf on a worker */
 export declare const FlatGeobufWorkerLoader: {
     readonly dataType: any;
     readonly batchType: any;
@@ -33,9 +34,9 @@ export declare const FlatGeobufWorkerLoader: {
     };
 };
 export declare const FlatGeobufLoader: {
-    readonly parse: (arrayBuffer: ArrayBuffer, options: FlatGeobufLoaderOptions | undefined) => Promise<import("@loaders.gl/schema").Table>;
-    readonly parseSync: typeof parseFlatGeobuf;
-    readonly parseInBatchesFromStream: typeof parseFlatGeobufInBatches;
+    readonly parse: (arrayBuffer: ArrayBuffer, options?: FlatGeobufLoaderOptions) => Promise<import("@loaders.gl/schema").Table>;
+    readonly parseSync: typeof parseSync;
+    readonly parseInBatchesFromStream: typeof parseInBatchesFromStream;
     readonly binary: true;
     readonly dataType: any;
     readonly batchType: any;
@@ -57,4 +58,7 @@ export declare const FlatGeobufLoader: {
         };
     };
 };
+declare function parseSync(arrayBuffer: ArrayBuffer, options?: FlatGeobufLoaderOptions): import("@loaders.gl/schema").Table;
+declare function parseInBatchesFromStream(stream: any, options: FlatGeobufLoaderOptions): any[] | AsyncGenerator<import("./flatgeobuf/3.27.2").IFeature, any, unknown> | AsyncGenerator<any, void, unknown>;
+export {};
 //# sourceMappingURL=flatgeobuf-loader.d.ts.map

package/dist/flatgeobuf-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"flatgeobuf-loader.d.ts","sourceRoot":"","sources":["../src/flatgeobuf-loader.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAA2B,aAAa,EAAC,MAAM,0BAA0B,CAAC;AACtF,OAAO,EAAC,eAAe,EAAE,wBAAwB,EAAC,kCAA+B;AASjF,MAAM,MAAM,uBAAuB,GAAG,aAAa,GAAG;IACpD,UAAU,CAAC,EAAE;QACX,KAAK,CAAC,EAAE,eAAe,GAAG,gBAAgB,GAAG,QAAQ,CAAC;QACtD,8EAA8E;QAC9E,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,GAAG,CAAC,EAAE;QACJ,SAAS,CAAC,EAAE,OAAO,CAAC;QACpB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC;CACH,CAAC;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;CAqB2B,CAAC;AAE/D,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;CAO2C,CAAC"}
+{"version":3,"file":"flatgeobuf-loader.d.ts","sourceRoot":"","sources":["../src/flatgeobuf-loader.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAA2B,aAAa,EAAC,MAAM,0BAA0B,CAAC;AActF,MAAM,MAAM,uBAAuB,GAAG,aAAa,GAAG;IACpD,UAAU,CAAC,EAAE;QACX,KAAK,CAAC,EAAE,eAAe,GAAG,gBAAgB,GAAG,QAAQ,CAAC;QACtD,8EAA8E;QAC9E,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,WAAW,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;KACpD,CAAC;IACF,GAAG,CAAC,EAAE;QACJ,SAAS,CAAC,EAAE,OAAO,CAAC;QACpB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC;CACH,CAAC;AAEF,kCAAkC;AAClC,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;CAqB8D,CAAC;AAElG,eAAO,MAAM,gBAAgB;kCAEA,WAAW,YAAW,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;CAMF,CAAC;AAEzE,iBAAS,SAAS,CAAC,WAAW,EAAE,WAAW,EAAE,OAAO,GAAE,uBAA4B,sCAEjF;AAED,iBAAS,wBAAwB,CAAC,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,uBAAuB,qHAE9E"}

package/dist/flatgeobuf-loader.js

@@ -4,9 +4,10 @@
 import { parseFlatGeobuf, parseFlatGeobufInBatches } from "./lib/parse-flatgeobuf.js";
 // __VERSION__ is injected by babel-plugin-version-inline
 // @ts-ignore TS2304: Cannot find name '__VERSION__'.
-const VERSION = typeof "4.3.0-alpha.1" !== 'undefined' ? "4.3.0-alpha.1" : 'latest';
+const VERSION = typeof "4.3.0-alpha.3" !== 'undefined' ? "4.3.0-alpha.3" : 'latest';
 // FGB\3FGB\1
 const FGB_MAGIC_NUMBER = [0x66, 0x67, 0x62, 0x03, 0x66, 0x67, 0x62, 0x01];
+/** Load flatgeobuf on a worker */
 export const FlatGeobufWorkerLoader = {
     dataType: null,
     batchType: null,
@@ -30,9 +31,28 @@ export const FlatGeobufWorkerLoader = {
 };
 export const 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
+    };
+}

package/dist/flatgeobuf-worker.js

@@ -8769,15 +8769,8 @@
   // 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);
@@ -8795,24 +8788,25 @@
     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) {
@@ -8821,7 +8815,7 @@
     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);
@@ -8832,11 +8826,12 @@
     }
   }
   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;
@@ -8845,9 +8840,9 @@
     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;
       }
@@ -8858,9 +8853,24 @@
       }
     }
   }
+  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 = true ? "4.3.0-alpha.1" : "latest";
+  var VERSION = true ? "4.3.0-alpha.3" : "latest";
   var FGB_MAGIC_NUMBER = [102, 103, 98, 3, 102, 103, 98, 1];
   var FlatGeobufWorkerLoader = {
     dataType: null,
@@ -8885,12 +8895,31 @@
   };
   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
+    };
+  }
 
   // src/workers/flatgeobuf-worker.ts
   createLoaderWorker(FlatGeobufLoader);

package/dist/floatgeobuf-source.d.ts

@@ -0,0 +1,51 @@
+import { Schema, GeoJSONTable } from '@loaders.gl/schema';
+import type { VectorSourceProps, VectorSourceMetadata, GetFeaturesParameters, LoaderWithParser } from '@loaders.gl/loader-utils';
+import { VectorSource } from '@loaders.gl/loader-utils';
+/**
+ * @ndeprecated This is a WIP, not fully implemented
+ * @see https://developers.arcgis.com/rest/services-reference/enterprise/feature-service.htm
+ */
+export declare const FlatGeobufSource: {
+    readonly name: "FlatGeobuf";
+    readonly id: "flatgeobuf-server";
+    readonly module: "wms";
+    readonly version: "0.0.0";
+    readonly extensions: [];
+    readonly mimeTypes: [];
+    readonly options: {
+        readonly url: never;
+        readonly 'flatgeobuf-server': {
+            /** Tabular loaders, normally the GeoJSONLoader */
+            readonly loaders: [];
+        };
+    };
+    readonly type: "flatgeobuf-server";
+    readonly fromUrl: true;
+    readonly fromBlob: false;
+    readonly testURL: (url: string) => boolean;
+    readonly createDataSource: (url: string | Blob, props: FlatGeobufVectorSourceProps) => FlatGeobufVectorSource;
+};
+export type FlatGeobufVectorSourceProps = VectorSourceProps & {
+    url: string;
+    'flatgeobuf-server'?: {
+        loaders: LoaderWithParser[];
+    };
+};
+/**
+ * ArcGIS ImageServer
+ * Note - exports a big API, that could be exposed here if there is a use case
+ * @see https://developers.arcgis.com/rest/services-reference/enterprise/feature-service.htm
+ */
+export declare class FlatGeobufVectorSource extends VectorSource<FlatGeobufVectorSourceProps> {
+    data: string;
+    url: string;
+    protected formatSpecificMetadata: Promise<any> | null;
+    constructor(props: FlatGeobufVectorSourceProps);
+    /** TODO - not yet clear if we can find schema information in the FeatureServer metadata or if we need to request a feature */
+    getSchema(): Promise<Schema>;
+    getMetadata(options: {
+        formatSpecificMetadata: any;
+    }): Promise<VectorSourceMetadata>;
+    getFeatures(parameters: GetFeaturesParameters): Promise<GeoJSONTable>;
+}
+//# sourceMappingURL=floatgeobuf-source.d.ts.map

package/dist/floatgeobuf-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floatgeobuf-source.d.ts","sourceRoot":"","sources":["../src/floatgeobuf-source.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,MAAM,EAAE,YAAY,EAAC,MAAM,oBAAoB,CAAC;AACxD,OAAO,KAAK,EACV,iBAAiB,EACjB,oBAAoB,EACpB,qBAAqB,EACrB,gBAAgB,EACjB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAS,YAAY,EAAC,MAAM,0BAA0B,CAAC;AAI9D;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;YAUvB,kDAAkD;;;;;;;4BASvC,MAAM,KAAG,OAAO;2DACA,2BAA2B,KAAG,sBAAsB;CAEL,CAAC;AAEjF,MAAM,MAAM,2BAA2B,GAAG,iBAAiB,GAAG;IAC5D,GAAG,EAAE,MAAM,CAAC;IACZ,mBAAmB,CAAC,EAAE;QACpB,OAAO,EAAE,gBAAgB,EAAE,CAAC;KAC7B,CAAC;CACH,CAAC;AAEF;;;;GAIG;AACH,qBAAa,sBAAuB,SAAQ,YAAY,CAAC,2BAA2B,CAAC;IACnF,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,CAAC,sBAAsB,EAAE,OAAO,CAAC,GAAG,CAAC,GAAG,IAAI,CAAQ;gBAEjD,KAAK,EAAE,2BAA2B;IAO9C,8HAA8H;IACxH,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC;IAK5B,WAAW,CAAC,OAAO,EAAE;QAAC,sBAAsB,MAAA;KAAC,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAgB7E,WAAW,CAAC,UAAU,EAAE,qBAAqB,GAAG,OAAO,CAAC,YAAY,CAAC;CAU5E"}

package/dist/floatgeobuf-source.js

@@ -0,0 +1,72 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { VectorSource } from '@loaders.gl/loader-utils';
+import { FlatGeobufLoader } from "./flatgeobuf-loader.js";
+/**
+ * @ndeprecated This is a WIP, not fully implemented
+ * @see https://developers.arcgis.com/rest/services-reference/enterprise/feature-service.htm
+ */
+export const FlatGeobufSource = {
+    name: 'FlatGeobuf',
+    id: 'flatgeobuf-server',
+    module: 'wms',
+    version: '0.0.0',
+    extensions: [],
+    mimeTypes: [],
+    options: {
+        url: undefined,
+        'flatgeobuf-server': {
+            /** Tabular loaders, normally the GeoJSONLoader */
+            loaders: []
+        }
+    },
+    type: 'flatgeobuf-server',
+    fromUrl: true,
+    fromBlob: false, // TODO check if supported by library?
+    testURL: (url) => url.toLowerCase().includes('FeatureServer'),
+    createDataSource: (url, props) => new FlatGeobufVectorSource(props)
+};
+/**
+ * ArcGIS ImageServer
+ * Note - exports a big API, that could be exposed here if there is a use case
+ * @see https://developers.arcgis.com/rest/services-reference/enterprise/feature-service.htm
+ */
+export class FlatGeobufVectorSource extends VectorSource {
+    data;
+    url;
+    formatSpecificMetadata = null;
+    constructor(props) {
+        super(props);
+        this.data = props.url;
+        this.url = props.url;
+        // this.formatSpecificMetadata = this._getFormatSpecificMetadata();
+    }
+    /** TODO - not yet clear if we can find schema information in the FeatureServer metadata or if we need to request a feature */
+    async getSchema() {
+        await this.getMetadata({ formatSpecificMetadata: true });
+        return { metadata: {}, fields: [] };
+    }
+    async getMetadata(options) {
+        // Wait for raw metadata to load
+        if (!this.formatSpecificMetadata) {
+            // this.formatSpecificMetadata = await this._getFormatSpecificMetadata();
+        }
+        // const metadata = parseFlatGeobufMetadata(this.formatSpecificMetadata);
+        // Only add the big blob of source metadata if explicitly requested
+        if (options.formatSpecificMetadata) {
+            // metadata.formatSpecificMetadata = this.formatSpecificMetadata;
+        }
+        // @ts-expect-error
+        return {};
+    }
+    async getFeatures(parameters) {
+        const response = await this.fetch(this.url);
+        const arrayBuffer = await response.arrayBuffer();
+        // TODO - hack - done to avoid pulling in selectLoader from core
+        const table = await FlatGeobufLoader.parse(arrayBuffer, {});
+        // const loader = this.props['flatgeobuf-server']?.loaders?.[0];
+        // const table = loader?.parse(arrayBuffer);
+        return table;
+    }
+}

package/dist/index.cjs

@@ -1744,16 +1744,8 @@ function deserialize4(input, fromFeature2, rect) {
 // dist/lib/parse-flatgeobuf.js
 var deserializeGeoJson = deserialize3;
 var deserializeGeneric = deserialize4;
-function binaryFromFeature(feature, header) {
-  const geometry = feature.geometry();
-  const geometryType = header.geometryType || (geometry == null ? void 0 : geometry.type());
-  const parsedGeometry = fgbToBinaryGeometry(geometry, geometryType);
-  parsedGeometry.properties = parseProperties(feature, header.columns);
-  return parsedGeometry;
-}
 function parseFlatGeobuf(arrayBuffer, options) {
-  var _a;
-  const shape = (_a = options == null ? void 0 : options.flatgeobuf) == null ? void 0 : _a.shape;
+  const shape = options.shape;
   switch (shape) {
     case "geojson-table": {
       return parseFlatGeobufToGeoJSONTable(arrayBuffer, options);
@@ -1771,24 +1763,26 @@ function parseFlatGeobufToBinary(arrayBuffer, options = {}) {
   const array = new Uint8Array(arrayBuffer);
   return deserializeGeneric(array, fgbToBinaryGeometry);
 }
-function parseFlatGeobufToGeoJSONTable(arrayBuffer, options = {}) {
+function parseFlatGeobufToGeoJSONTable(arrayBuffer, options) {
+  var _a;
   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 = (_a = fgbHeader == null ? void 0 : fgbHeader.crs) == null ? void 0 : _a.wkt;
   let projection;
-  if (reproject && crs) {
+  if (reproject && fromCRS) {
     try {
-      projection = new import_proj4.Proj4Projection({ from: crs.wkt, to: _targetCrs });
-    } catch (e) {
+      projection = new import_proj4.Proj4Projection({ from: fromCRS, to: crs });
+    } catch (error) {
     }
   }
   if (projection) {
@@ -1797,8 +1791,7 @@ function parseFlatGeobufToGeoJSONTable(arrayBuffer, options = {}) {
   return { shape: "geojson-table", schema, type: "FeatureCollection", features };
 }
 function parseFlatGeobufInBatches(stream, options) {
-  var _a;
-  const shape = (_a = options.flatgeobuf) == null ? void 0 : _a.shape;
+  const shape = options.shape;
   switch (shape) {
     case "binary":
       return parseFlatGeobufInBatchesToBinary(stream, options);
@@ -1809,11 +1802,13 @@ function parseFlatGeobufInBatches(stream, options) {
   }
 }
 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 || {};
+  var _a;
+  const { reproject = false, crs = "WGS84" } = options || {};
   let fgbHeader;
   const iterator = deserializeGeoJson(stream, void 0, (headerMeta) => {
     fgbHeader = headerMeta;
@@ -1822,9 +1817,9 @@ async function* parseFlatGeobufInBatchesToGeoJSON(stream, options) {
   let firstRecord = true;
   for await (const feature of iterator) {
     if (firstRecord) {
-      const crs = fgbHeader && fgbHeader.crs;
-      if (reproject && crs) {
-        projection = new import_proj4.Proj4Projection({ from: crs.wkt, to: _targetCrs });
+      const fromCRS = (_a = fgbHeader == null ? void 0 : fgbHeader.crs) == null ? void 0 : _a.wkt;
+      if (reproject && fromCRS) {
+        projection = new import_proj4.Proj4Projection({ from: fromCRS, to: crs });
       }
       firstRecord = false;
     }
@@ -1835,9 +1830,24 @@ async function* parseFlatGeobufInBatchesToGeoJSON(stream, options) {
     }
   }
 }
+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 == null ? void 0 : geometry.type());
+  const parsedGeometry = fgbToBinaryGeometry(geometry, geometryType);
+  parsedGeometry.properties = parseProperties(feature, header.columns);
+  return parsedGeometry;
+}
 
 // dist/flatgeobuf-loader.js
-var VERSION = true ? "4.3.0-alpha.1" : "latest";
+var VERSION = true ? "4.3.0-alpha.3" : "latest";
 var FGB_MAGIC_NUMBER = [102, 103, 98, 3, 102, 103, 98, 1];
 var FlatGeobufWorkerLoader = {
   dataType: null,
@@ -1862,10 +1872,30 @@ var FlatGeobufWorkerLoader = {
 };
 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) {
+  var _a, _b, _c, _d;
+  options = {
+    ...options,
+    flatgeobuf: { ...FlatGeobufLoader.options.flatgeobuf, ...options == null ? void 0 : options.flatgeobuf },
+    gis: { ...FlatGeobufLoader.options.gis, ...options == null ? void 0 : options.gis }
+  };
+  return {
+    shape: ((_a = options == null ? void 0 : options.flatgeobuf) == null ? void 0 : _a.shape) ?? "geojson-table",
+    boundingBox: (_b = options == null ? void 0 : options.flatgeobuf) == null ? void 0 : _b.boundingBox,
+    crs: ((_c = options == null ? void 0 : options.gis) == null ? void 0 : _c._targetCrs) || "WGS84",
+    reproject: ((_d = options == null ? void 0 : options.gis) == null ? void 0 : _d.reproject) || false
+  };
+}
 //# sourceMappingURL=index.cjs.map