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

package/dist/lib/parse-flatgeobuf.d.ts

@@ -1,6 +1,14 @@
-import type { FlatGeobufLoaderOptions } from "../flatgeobuf-loader.js";
 import type { Table } from '@loaders.gl/schema';
 import * as fgb from '../flatgeobuf/3.27.2';
-export declare function parseFlatGeobuf(arrayBuffer: ArrayBuffer, options?: FlatGeobufLoaderOptions): Table;
-export declare function parseFlatGeobufInBatches(stream: any, options: FlatGeobufLoaderOptions): any[] | AsyncGenerator<fgb.IFeature, any, unknown> | AsyncGenerator<any, void, unknown>;
+export type ParseFlatGeobufOptions = {
+    shape?: 'geojson-table' | 'columnar-table' | 'binary';
+    /** If supplied, only loads features within the bounding box */
+    boundingBox?: [[number, number], [number, number]];
+    /** Desired output CRS */
+    crs?: string;
+    /** Should geometries be reprojected to target CRS */
+    reproject?: boolean;
+};
+export declare function parseFlatGeobuf(arrayBuffer: ArrayBuffer, options: ParseFlatGeobufOptions): Table;
+export declare function parseFlatGeobufInBatches(stream: any, options: ParseFlatGeobufOptions): any[] | AsyncGenerator<fgb.IFeature, any, unknown> | AsyncGenerator<any, void, unknown>;
 //# sourceMappingURL=parse-flatgeobuf.d.ts.map

package/dist/lib/parse-flatgeobuf.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse-flatgeobuf.d.ts","sourceRoot":"","sources":["../../src/lib/parse-flatgeobuf.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAC,uBAAuB,EAAC,gCAA6B;AAClE,OAAO,KAAK,EAAe,KAAK,EAAS,MAAM,oBAAoB,CAAC;AAKpE,OAAO,KAAK,GAAG,MAAM,sBAAsB,CAAC;AAgC5C,wBAAgB,eAAe,CAC7B,WAAW,EAAE,WAAW,EACxB,OAAO,CAAC,EAAE,uBAAuB,GAChC,KAAK,CAoBP;AAyDD,wBAAgB,wBAAwB,CAAC,MAAM,KAAA,EAAE,OAAO,EAAE,uBAAuB,2FAUhF"}
+{"version":3,"file":"parse-flatgeobuf.d.ts","sourceRoot":"","sources":["../../src/lib/parse-flatgeobuf.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAe,KAAK,EAAS,MAAM,oBAAoB,CAAC;AAKpE,OAAO,KAAK,GAAG,MAAM,sBAAsB,CAAC;AAS5C,MAAM,MAAM,sBAAsB,GAAG;IACnC,KAAK,CAAC,EAAE,eAAe,GAAG,gBAAgB,GAAG,QAAQ,CAAC;IACtD,+DAA+D;IAC/D,WAAW,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACnD,yBAAyB;IACzB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,qDAAqD;IACrD,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,CAAC;AAQF,wBAAgB,eAAe,CAAC,WAAW,EAAE,WAAW,EAAE,OAAO,EAAE,sBAAsB,GAAG,KAAK,CAoBhG;AA2DD,wBAAgB,wBAAwB,CAAC,MAAM,KAAA,EAAE,OAAO,EAAE,sBAAsB,2FAU/E"}

package/dist/lib/parse-flatgeobuf.js

@@ -10,21 +10,6 @@ import * as generic from "../flatgeobuf/3.27.2/generic.js";
 import { parseProperties as parsePropertiesBinary } from "../flatgeobuf/3.27.2/generic/feature.js";
 const deserializeGeoJson = geojson.deserialize;
 const deserializeGeneric = generic.deserialize;
-// const parsePropertiesBinary = FlatgeobufFeature.parseProperties;
-// TODO: reproject binary features
-function binaryFromFeature(feature, header) {
-    const geometry = feature.geometry();
-    // FlatGeobuf files can only hold a single geometry type per file, otherwise
-    // GeometryType is GeometryCollection
-    // I believe geometry.type() is null (0) except when the geometry type isn't
-    // known in the header?
-    const geometryType = header.geometryType || geometry?.type();
-    const parsedGeometry = fgbToBinaryGeometry(geometry, geometryType);
-    // @ts-expect-error this looks wrong
-    parsedGeometry.properties = parsePropertiesBinary(feature, header.columns);
-    // TODO: wrap binary data either in points, lines, or polygons key
-    return parsedGeometry;
-}
 /*
  * Parse FlatGeobuf arrayBuffer and return GeoJSON.
  *
@@ -32,7 +17,7 @@ function binaryFromFeature(feature, header) {
  * @return A GeoJSON geometry object
  */
 export function parseFlatGeobuf(arrayBuffer, options) {
-    const shape = options?.flatgeobuf?.shape;
+    const shape = options.shape;
     switch (shape) {
         case 'geojson-table': {
             return parseFlatGeobufToGeoJSONTable(arrayBuffer, options);
@@ -55,27 +40,28 @@ function parseFlatGeobufToBinary(arrayBuffer, options = {}) {
     // @ts-expect-error
     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;
+    const rect = options.boundingBox && convertBoundingBox(options.boundingBox);
     // @ts-expect-error this looks wrong
-    let { features } = deserializeGeoJson(arr, undefined, (headerMeta) => {
+    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) {
         // Constructing the projection may fail for some invalid WKT strings
         try {
-            projection = new Proj4Projection({ from: crs.wkt, to: _targetCrs });
+            projection = new Proj4Projection({ from: fromCRS, to: crs });
         }
-        catch (e) {
+        catch (error) {
             // no op
         }
     }
@@ -92,7 +78,7 @@ function parseFlatGeobufToGeoJSONTable(arrayBuffer, options = {}) {
  */
 // eslint-disable-next-line complexity
 export function parseFlatGeobufInBatches(stream, options) {
-    const shape = options.flatgeobuf?.shape;
+    const shape = options.shape;
     switch (shape) {
         case 'binary':
             return parseFlatGeobufInBatchesToBinary(stream, options);
@@ -105,8 +91,9 @@ export function parseFlatGeobufInBatches(stream, options) {
 function parseFlatGeobufInBatchesToBinary(stream, options) {
     // TODO: reproject binary streaming features
     // const {reproject = false, _targetCrs = 'WGS84'} = (options && options.gis) || {};
+    const rect = options.boundingBox && convertBoundingBox(options.boundingBox);
     // @ts-expect-error
-    const iterator = deserializeGeneric(stream, binaryFromFeature);
+    const iterator = deserializeGeneric(stream, binaryFromFeature, rect);
     return iterator;
 }
 /**
@@ -116,7 +103,7 @@ function parseFlatGeobufInBatchesToBinary(stream, options) {
  */
 // eslint-disable-next-line complexity
 async function* parseFlatGeobufInBatchesToGeoJSON(stream, options) {
-    const { reproject = false, _targetCrs = 'WGS84' } = (options && options.gis) || {};
+    const { reproject = false, crs = 'WGS84' } = options || {};
     let fgbHeader;
     // let schema: Schema | undefined;
     const iterator = deserializeGeoJson(stream, undefined, (headerMeta) => {
@@ -128,9 +115,9 @@ async function* parseFlatGeobufInBatchesToGeoJSON(stream, options) {
     // @ts-expect-error this looks wrong
     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;
         }
@@ -143,3 +130,26 @@ async function* parseFlatGeobufInBatchesToGeoJSON(stream, options) {
         }
     }
 }
+// HELPERS
+function convertBoundingBox(boundingBox) {
+    return {
+        minX: boundingBox[0][0],
+        minY: boundingBox[0][1],
+        maxX: boundingBox[1][0],
+        maxY: boundingBox[1][1]
+    };
+}
+// TODO: reproject binary features
+function binaryFromFeature(feature, header) {
+    const geometry = feature.geometry();
+    // FlatGeobuf files can only hold a single geometry type per file, otherwise
+    // GeometryType is GeometryCollection
+    // I believe geometry.type() is null (0) except when the geometry type isn't
+    // known in the header?
+    const geometryType = header.geometryType || geometry?.type();
+    const parsedGeometry = fgbToBinaryGeometry(geometry, geometryType);
+    // @ts-expect-error this looks wrong
+    parsedGeometry.properties = parsePropertiesBinary(feature, header.columns);
+    // TODO: wrap binary data either in points, lines, or polygons key
+    return parsedGeometry;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@loaders.gl/flatgeobuf",
   "description": "Loader for FlatGeobuf",
-  "version": "4.3.0-alpha.2",
+  "version": "4.3.0-alpha.4",
   "license": "MIT",
   "type": "module",
   "publishConfig": {
@@ -44,9 +44,9 @@
     "build-worker": "esbuild src/workers/flatgeobuf-worker.ts --bundle --outfile=dist/flatgeobuf-worker.js --define:__VERSION__=\\\"$npm_package_version\\\""
   },
   "dependencies": {
-    "@loaders.gl/gis": "4.3.0-alpha.2",
-    "@loaders.gl/loader-utils": "4.3.0-alpha.2",
-    "@loaders.gl/schema": "4.3.0-alpha.2",
+    "@loaders.gl/gis": "4.3.0-alpha.4",
+    "@loaders.gl/loader-utils": "4.3.0-alpha.4",
+    "@loaders.gl/schema": "4.3.0-alpha.4",
     "@math.gl/proj4": "^4.0.0",
     "flatgeobuf": "3.27.2"
   },
@@ -56,5 +56,5 @@
   "peerDependencies": {
     "@loaders.gl/core": "^4.0.0"
   },
-  "gitHead": "77a3cb538ab7a1fbf74245f25590210451689f5c"
+  "gitHead": "4900ac4c4de20366c050b80cef04dc5b52d167af"
 }

package/src/flatgeobuf-loader.ts

@@ -2,8 +2,13 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
+import type {GeoJSONTable, BinaryFeatureCollection} from '@loaders.gl/schema';
 import type {Loader, LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';
-import {parseFlatGeobuf, parseFlatGeobufInBatches} from './lib/parse-flatgeobuf';
+import {
+  parseFlatGeobuf,
+  parseFlatGeobufInBatches,
+  ParseFlatGeobufOptions
+} from './lib/parse-flatgeobuf';
 
 // __VERSION__ is injected by babel-plugin-version-inline
 // @ts-ignore TS2304: Cannot find name '__VERSION__'.
@@ -17,6 +22,7 @@ export type FlatGeobufLoaderOptions = LoaderOptions & {
     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;
@@ -24,6 +30,7 @@ export type FlatGeobufLoaderOptions = LoaderOptions & {
   };
 };
 
+/** Load flatgeobuf on a worker */
 export const FlatGeobufWorkerLoader = {
   dataType: null as any,
   batchType: null as any,
@@ -45,13 +52,36 @@ export const FlatGeobufWorkerLoader = {
       reproject: false
     }
   }
-} as const satisfies Loader<any, any, FlatGeobufLoaderOptions>;
+} as const satisfies Loader<GeoJSONTable | BinaryFeatureCollection, any, FlatGeobufLoaderOptions>;
 
 export const FlatGeobufLoader = {
   ...FlatGeobufWorkerLoader,
-  parse: async (arrayBuffer, options) => parseFlatGeobuf(arrayBuffer, options),
-  parseSync: parseFlatGeobuf,
+  parse: async (arrayBuffer: ArrayBuffer, options: FlatGeobufLoaderOptions = {}) =>
+    parseSync(arrayBuffer, options),
+  parseSync,
   // @ts-expect-error this is a stream parser not an async iterator parser
-  parseInBatchesFromStream: parseFlatGeobufInBatches,
+  parseInBatchesFromStream,
   binary: true
 } as const satisfies LoaderWithParser<any, any, FlatGeobufLoaderOptions>;
+
+function parseSync(arrayBuffer: ArrayBuffer, options: FlatGeobufLoaderOptions = {}) {
+  return parseFlatGeobuf(arrayBuffer, getOptions(options));
+}
+
+function parseInBatchesFromStream(stream: any, options: FlatGeobufLoaderOptions) {
+  return parseFlatGeobufInBatches(stream, getOptions(options));
+}
+
+function getOptions(options: FlatGeobufLoaderOptions): ParseFlatGeobufOptions {
+  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/src/floatgeobuf-source.ts

@@ -0,0 +1,100 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {Schema, GeoJSONTable} from '@loaders.gl/schema';
+import type {
+  VectorSourceProps,
+  VectorSourceMetadata,
+  GetFeaturesParameters,
+  LoaderWithParser
+} from '@loaders.gl/loader-utils';
+import {Source, VectorSource} from '@loaders.gl/loader-utils';
+
+import {FlatGeobufLoader} from './flatgeobuf-loader';
+
+/**
+ * @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: string): boolean => url.toLowerCase().includes('FeatureServer'),
+  createDataSource: (url, props: FlatGeobufVectorSourceProps): FlatGeobufVectorSource =>
+    new FlatGeobufVectorSource(props)
+} as const satisfies Source<FlatGeobufVectorSource, FlatGeobufVectorSourceProps>;
+
+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 class FlatGeobufVectorSource extends VectorSource<FlatGeobufVectorSourceProps> {
+  data: string;
+  url: string;
+  protected formatSpecificMetadata: Promise<any> | null = null;
+
+  constructor(props: FlatGeobufVectorSourceProps) {
+    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(): Promise<Schema> {
+    await this.getMetadata({formatSpecificMetadata: true});
+    return {metadata: {}, fields: []};
+  }
+
+  async getMetadata(options: {formatSpecificMetadata}): Promise<VectorSourceMetadata> {
+    // 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: GetFeaturesParameters): Promise<GeoJSONTable> {
+    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 as GeoJSONTable;
+  }
+}

package/src/lib/parse-flatgeobuf.ts

@@ -5,7 +5,6 @@
 import {Proj4Projection} from '@math.gl/proj4';
 import {transformGeoJsonCoords} from '@loaders.gl/gis';
 
-import type {FlatGeobufLoaderOptions} from '../flatgeobuf-loader';
 import type {GeoJSONTable, Table, Schema} from '@loaders.gl/schema';
 
 import {fgbToBinaryGeometry} from './binary-geometries';
@@ -20,22 +19,15 @@ const deserializeGeoJson = geojson.deserialize;
 const deserializeGeneric = generic.deserialize;
 // const parsePropertiesBinary = FlatgeobufFeature.parseProperties;
 
-// TODO: reproject binary features
-function binaryFromFeature(feature: fgb.Feature, header: fgb.HeaderMeta) {
-  const geometry = feature.geometry();
-
-  // FlatGeobuf files can only hold a single geometry type per file, otherwise
-  // GeometryType is GeometryCollection
-  // I believe geometry.type() is null (0) except when the geometry type isn't
-  // known in the header?
-  const geometryType = header.geometryType || geometry?.type();
-  const parsedGeometry = fgbToBinaryGeometry(geometry, geometryType!);
-  // @ts-expect-error this looks wrong
-  parsedGeometry.properties = parsePropertiesBinary(feature, header.columns);
-
-  // TODO: wrap binary data either in points, lines, or polygons key
-  return parsedGeometry;
-}
+export type ParseFlatGeobufOptions = {
+  shape?: 'geojson-table' | 'columnar-table' | 'binary';
+  /** If supplied, only loads features within the bounding box */
+  boundingBox?: [[number, number], [number, number]];
+  /** Desired output CRS */
+  crs?: string;
+  /** Should geometries be reprojected to target CRS */
+  reproject?: boolean;
+};
 
 /*
  * Parse FlatGeobuf arrayBuffer and return GeoJSON.
@@ -43,11 +35,8 @@ function binaryFromFeature(feature: fgb.Feature, header: fgb.HeaderMeta) {
  * @param arrayBuffer  A FlatGeobuf arrayBuffer
  * @return A GeoJSON geometry object
  */
-export function parseFlatGeobuf(
-  arrayBuffer: ArrayBuffer,
-  options?: FlatGeobufLoaderOptions
-): Table {
-  const shape = options?.flatgeobuf?.shape;
+export function parseFlatGeobuf(arrayBuffer: ArrayBuffer, options: ParseFlatGeobufOptions): Table {
+  const shape = options.shape;
 
   switch (shape) {
     case 'geojson-table': {
@@ -68,7 +57,7 @@ export function parseFlatGeobuf(
   }
 }
 
-function parseFlatGeobufToBinary(arrayBuffer: ArrayBuffer, options: FlatGeobufLoaderOptions = {}) {
+function parseFlatGeobufToBinary(arrayBuffer: ArrayBuffer, options: ParseFlatGeobufOptions = {}) {
   // TODO: reproject binary features
   // const {reproject = false, _targetCrs = 'WGS84'} = (options && options.gis) || {};
 
@@ -79,32 +68,34 @@ function parseFlatGeobufToBinary(arrayBuffer: ArrayBuffer, options: FlatGeobufLo
 
 function parseFlatGeobufToGeoJSONTable(
   arrayBuffer: ArrayBuffer,
-  options: FlatGeobufLoaderOptions = {}
+  options: ParseFlatGeobufOptions
 ): GeoJSONTable {
   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 fgbHeader: fgb.HeaderMeta | undefined;
   let schema: Schema | undefined;
 
+  const rect = options.boundingBox && convertBoundingBox(options.boundingBox);
+
   // @ts-expect-error this looks wrong
-  let {features} = deserializeGeoJson(arr, undefined, (headerMeta) => {
+  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) {
     // Constructing the projection may fail for some invalid WKT strings
     try {
-      projection = new Proj4Projection({from: crs.wkt, to: _targetCrs});
-    } catch (e) {
+      projection = new Proj4Projection({from: fromCRS, to: crs});
+    } catch (error) {
       // no op
     }
   }
@@ -123,8 +114,8 @@ function parseFlatGeobufToGeoJSONTable(
  * @return  A GeoJSON geometry object iterator
  */
 // eslint-disable-next-line complexity
-export function parseFlatGeobufInBatches(stream, options: FlatGeobufLoaderOptions) {
-  const shape = options.flatgeobuf?.shape;
+export function parseFlatGeobufInBatches(stream, options: ParseFlatGeobufOptions) {
+  const shape = options.shape;
   switch (shape) {
     case 'binary':
       return parseFlatGeobufInBatchesToBinary(stream, options);
@@ -135,12 +126,14 @@ export function parseFlatGeobufInBatches(stream, options: FlatGeobufLoaderOption
   }
 }
 
-function parseFlatGeobufInBatchesToBinary(stream, options: FlatGeobufLoaderOptions) {
+function parseFlatGeobufInBatchesToBinary(stream, options: ParseFlatGeobufOptions) {
   // TODO: reproject binary streaming features
   // const {reproject = false, _targetCrs = 'WGS84'} = (options && options.gis) || {};
 
+  const rect = options.boundingBox && convertBoundingBox(options.boundingBox);
+
   // @ts-expect-error
-  const iterator = deserializeGeneric(stream, binaryFromFeature);
+  const iterator = deserializeGeneric(stream, binaryFromFeature, rect);
   return iterator;
 }
 
@@ -150,8 +143,8 @@ function parseFlatGeobufInBatchesToBinary(stream, options: FlatGeobufLoaderOptio
  * @param options
  */
 // eslint-disable-next-line complexity
-async function* parseFlatGeobufInBatchesToGeoJSON(stream, options: FlatGeobufLoaderOptions) {
-  const {reproject = false, _targetCrs = 'WGS84'} = (options && options.gis) || {};
+async function* parseFlatGeobufInBatchesToGeoJSON(stream, options: ParseFlatGeobufOptions) {
+  const {reproject = false, crs = 'WGS84'} = options || {};
 
   let fgbHeader;
   // let schema: Schema | undefined;
@@ -165,9 +158,9 @@ async function* parseFlatGeobufInBatchesToGeoJSON(stream, options: FlatGeobufLoa
   // @ts-expect-error this looks wrong
   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;
@@ -181,3 +174,31 @@ async function* parseFlatGeobufInBatchesToGeoJSON(stream, options: FlatGeobufLoa
     }
   }
 }
+
+// HELPERS
+
+function convertBoundingBox(boundingBox: [[number, number], [number, number]]): fgb.Rect {
+  return {
+    minX: boundingBox[0][0],
+    minY: boundingBox[0][1],
+    maxX: boundingBox[1][0],
+    maxY: boundingBox[1][1]
+  };
+}
+
+// TODO: reproject binary features
+function binaryFromFeature(feature: fgb.Feature, header: fgb.HeaderMeta) {
+  const geometry = feature.geometry();
+
+  // FlatGeobuf files can only hold a single geometry type per file, otherwise
+  // GeometryType is GeometryCollection
+  // I believe geometry.type() is null (0) except when the geometry type isn't
+  // known in the header?
+  const geometryType = header.geometryType || geometry?.type();
+  const parsedGeometry = fgbToBinaryGeometry(geometry, geometryType!);
+  // @ts-expect-error this looks wrong
+  parsedGeometry.properties = parsePropertiesBinary(feature, header.columns);
+
+  // TODO: wrap binary data either in points, lines, or polygons key
+  return parsedGeometry;
+}