@loaders.gl/flatgeobuf 3.1.0-beta.5 → 3.1.2

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import type { LoaderWithParser } from '@loaders.gl/loader-utils';
 import { FlatGeobufLoader as FlatGeobufWorkerLoader } from './flatgeobuf-loader';
-import parseFlatGeobuf, { parseFlatGeobufInBatches } from './lib/parse-flatgeobuf';
+import { parseFlatGeobuf, parseFlatGeobufInBatches } from './lib/parse-flatgeobuf';
 export { FlatGeobufWorkerLoader };
 export declare const FlatGeobufLoader: {
     parse: (arrayBuffer: any, options: any) => Promise<any>;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAC/D,OAAO,EAAC,gBAAgB,IAAI,sBAAsB,EAAC,MAAM,qBAAqB,CAAC;AAC/E,OAAO,eAAe,EAAE,EAAC,wBAAwB,EAAC,MAAM,wBAAwB,CAAC;AAEjF,OAAO,EAAC,sBAAsB,EAAC,CAAC;AAEhC,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;CAM5B,CAAC;AAEF,eAAO,MAAM,0BAA0B,EAAE,gBAAmC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAC/D,OAAO,EAAC,gBAAgB,IAAI,sBAAsB,EAAC,MAAM,qBAAqB,CAAC;AAC/E,OAAO,EAAC,eAAe,EAAE,wBAAwB,EAAC,MAAM,wBAAwB,CAAC;AAEjF,OAAO,EAAC,sBAAsB,EAAC,CAAC;AAEhC,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;CAM5B,CAAC;AAEF,eAAO,MAAM,0BAA0B,EAAE,gBAAmC,CAAC"}

package/dist/index.js

@@ -1,32 +1,13 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports._typecheckFlatGeobufLoader = exports.FlatGeobufLoader = exports.FlatGeobufWorkerLoader = void 0;
 const flatgeobuf_loader_1 = require("./flatgeobuf-loader");
 Object.defineProperty(exports, "FlatGeobufWorkerLoader", { enumerable: true, get: function () { return flatgeobuf_loader_1.FlatGeobufLoader; } });
-const parse_flatgeobuf_1 = __importStar(require("./lib/parse-flatgeobuf"));
+const parse_flatgeobuf_1 = require("./lib/parse-flatgeobuf");
 exports.FlatGeobufLoader = {
     ...flatgeobuf_loader_1.FlatGeobufLoader,
-    parse: async (arrayBuffer, options) => (0, parse_flatgeobuf_1.default)(arrayBuffer, options),
-    parseSync: parse_flatgeobuf_1.default,
+    parse: async (arrayBuffer, options) => (0, parse_flatgeobuf_1.parseFlatGeobuf)(arrayBuffer, options),
+    parseSync: parse_flatgeobuf_1.parseFlatGeobuf,
     parseInBatchesFromStream: parse_flatgeobuf_1.parseFlatGeobufInBatches,
     binary: true
 };

package/dist/lib/binary-geometries.d.ts

@@ -0,0 +1,20 @@
+export declare function fromGeometry(geometry: any, type: any): {
+    positions: {
+        value: any;
+        size: number;
+    };
+} | {
+    positions: {
+        value: Float64Array;
+        size: any;
+    };
+    primitivePolygonIndices: {
+        value: Uint32Array;
+        size: number;
+    };
+    polygonIndices: {
+        value: Uint32Array;
+        size: number;
+    };
+};
+//# sourceMappingURL=binary-geometries.d.ts.map

package/dist/lib/binary-geometries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary-geometries.d.ts","sourceRoot":"","sources":["../../src/lib/binary-geometries.ts"],"names":[],"mappings":"AAgIA,wBAAgB,YAAY,CAAC,QAAQ,KAAA,EAAE,IAAI,KAAA;;;;;;;;;;;;;;;;;;EAe1C"}

package/dist/lib/binary-geometries.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromGeometry = void 0;
+const header_generated_1 = require("flatgeobuf/lib/cjs/header_generated");
+// Parse Point to flat array
+function parsePoint(geometry) {
+    const xy = geometry.xyArray();
+    const z = geometry.zArray();
+    const positions = blitArrays(xy, z);
+    return { positions };
+}
+function parseLines(geometry) {
+    const xy = geometry.xyArray();
+    const z = geometry.zArray();
+    const positions = blitArrays(xy, z);
+    // If endsArray is null, a single LineString. Otherwise, contains the end
+    // indices of each part of the MultiLineString. geometry.endsArray() omits the
+    // initial 0 that we have in our internal format.
+    const ends = (geometry.endsArray() && Array.from(geometry.endsArray())) || [xy.length / 2];
+    ends.unshift(0);
+    const pathIndices = { value: new Uint16Array(ends), size: 1 };
+    return {
+        positions,
+        pathIndices
+    };
+}
+function parsePolygons(geometry) {
+    const xy = geometry.xyArray();
+    const z = geometry.zArray();
+    const positions = blitArrays(xy, z);
+    // If endsArray is null, a simple Polygon with no inner rings. Otherwise,
+    // contains the end indices of each ring of the Polygon. geometry.endsArray()
+    // omits the initial 0 that we have in our internal format.
+    const ends = (geometry.endsArray() && Array.from(geometry.endsArray())) || [xy.length / 2];
+    ends.unshift(0);
+    const primitivePolygonIndices = { value: new Uint16Array(ends), size: 1 };
+    const polygonIndices = { value: new Uint16Array([0, xy.length / 2]), size: 1 };
+    return {
+        positions,
+        primitivePolygonIndices,
+        polygonIndices
+    };
+}
+// eslint-disable-next-line max-statements
+function parseMultiPolygons(geometry) {
+    // Create arrays for each geometry part, then concatenate
+    const parsedParts = [];
+    let nPositions = 0;
+    let nPrimitivePolygonIndices = 1;
+    let nPolygonIndices = 1;
+    for (let i = 0; i < geometry.partsLength(); i++) {
+        const part = geometry.parts(i);
+        const polygon = parsePolygons(part);
+        nPositions += polygon.positions.value.length;
+        nPrimitivePolygonIndices += polygon.primitivePolygonIndices.value.length - 1;
+        nPolygonIndices += polygon.polygonIndices.value.length - 1;
+        parsedParts.push(polygon);
+    }
+    const concatPositions = new Float64Array(nPositions);
+    const concatPrimitivePolygonIndices = new Uint32Array(nPrimitivePolygonIndices);
+    const concatPolygonIndices = new Uint32Array(nPolygonIndices);
+    let positionCounter = 0;
+    let primitivePolygonIndicesCounter = 1;
+    let polygonIndicesCounter = 1;
+    // Assumes all parts of the multipolygon have the same size
+    const positionSize = parsedParts[0].positions.size;
+    for (const parsedPart of parsedParts) {
+        concatPositions.set(parsedPart.positions.value, positionCounter * positionSize);
+        // For indices, need to add positionCounter so that position indices are
+        // correct in the concatenated positions
+        concatPrimitivePolygonIndices.set(
+        // eslint-disable-next-line
+        parsedPart.primitivePolygonIndices.value.subarray(1).map((x) => x + positionCounter), primitivePolygonIndicesCounter);
+        concatPolygonIndices.set(
+        // eslint-disable-next-line
+        parsedPart.polygonIndices.value.subarray(1).map((x) => x + positionCounter), polygonIndicesCounter);
+        positionCounter += parsedPart.positions.value.length / positionSize;
+        primitivePolygonIndicesCounter += parsedPart.primitivePolygonIndices.value.length - 1;
+        polygonIndicesCounter += parsedPart.polygonIndices.value.length - 1;
+    }
+    return {
+        positions: { value: concatPositions, size: positionSize },
+        primitivePolygonIndices: { value: concatPrimitivePolygonIndices, size: 1 },
+        polygonIndices: { value: concatPolygonIndices, size: 1 }
+    };
+}
+// Combine xy and z arrays
+function blitArrays(xy, z) {
+    if (!z) {
+        return { value: xy, size: 2 };
+    }
+    if (z.length * 2 !== xy.length) {
+        throw new Error('Z array must be half XY array\'s length');
+    }
+    const totalLength = xy.length + z.length;
+    const xyz = new Float64Array(totalLength);
+    for (let i = 0; i < xy.length / 2; i++) {
+        xyz[i * 3 + 0] = xy[i * 2 + 0];
+        xyz[i * 3 + 1] = xy[i * 2 + 1];
+        xyz[i * 3 + 2] = z[i];
+    }
+    return { value: xyz, size: 3 };
+}
+function fromGeometry(geometry, type) {
+    switch (type) {
+        case header_generated_1.GeometryType.Point:
+        case header_generated_1.GeometryType.MultiPoint:
+            return parsePoint(geometry);
+        case header_generated_1.GeometryType.LineString:
+        case header_generated_1.GeometryType.MultiLineString:
+            return parseLines(geometry);
+        case header_generated_1.GeometryType.Polygon:
+            return parsePolygons(geometry);
+        case header_generated_1.GeometryType.MultiPolygon:
+            return parseMultiPolygons(geometry);
+        default:
+            throw new Error(`Unimplemented geometry type: ${type}`);
+    }
+}
+exports.fromGeometry = fromGeometry;

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

@@ -1,3 +1,3 @@
-export default function parseFlatGeobuf(input: any, options: any): any;
-export declare function parseFlatGeobufInBatches(stream: any, options: any): any;
+export declare function parseFlatGeobuf(arrayBuffer: any, options: any): any;
+export declare function parseFlatGeobufInBatches(stream: any, options: any): any[] | AsyncGenerator<import("flatgeobuf/lib/cjs/generic/feature").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":"AASA,MAAM,CAAC,OAAO,UAAU,eAAe,CAAC,KAAK,KAAA,EAAE,OAAO,KAAA,OAQrD;AAQD,wBAAgB,wBAAwB,CAAC,MAAM,KAAA,EAAE,OAAO,KAAA,OAGvD"}
+{"version":3,"file":"parse-flatgeobuf.d.ts","sourceRoot":"","sources":["../../src/lib/parse-flatgeobuf.ts"],"names":[],"mappings":"AAgCA,wBAAgB,eAAe,CAAC,WAAW,KAAA,EAAE,OAAO,KAAA,OAUnD;AA6CD,wBAAgB,wBAAwB,CAAC,MAAM,KAAA,EAAE,OAAO,KAAA,oIAMvD"}

package/dist/lib/parse-flatgeobuf.js

@@ -1,31 +1,114 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseFlatGeobufInBatches = void 0;
-// import {deserialize} from 'flatgeobuf/lib/geojson/featurecollection';
-const flatgeobuf_geojson_min_1 = require("flatgeobuf/dist/flatgeobuf-geojson.min");
+exports.parseFlatGeobufInBatches = exports.parseFlatGeobuf = void 0;
+// @ts-nocheck
+const proj4_1 = require("@math.gl/proj4");
+const gis_1 = require("@loaders.gl/gis");
+const geojson_1 = require("flatgeobuf/lib/cjs/geojson");
+const generic_1 = require("flatgeobuf/lib/cjs/generic");
+const feature_1 = require("flatgeobuf/lib/cjs/generic/feature");
+const binary_geometries_1 = require("./binary-geometries");
+// 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 = (0, binary_geometries_1.fromGeometry)(geometry, geometryType);
+    parsedGeometry.properties = (0, feature_1.parseProperties)(feature, header.columns);
+    // TODO: wrap binary data either in points, lines, or polygons key
+    return parsedGeometry;
+}
 /*
  * Parse FlatGeobuf arrayBuffer and return GeoJSON.
  *
- * @param {arrayBuffer} _ A FlatGeobuf arrayBuffer
- * @return {?Object} A GeoJSON geometry object
+ * @param arrayBuffer  A FlatGeobuf arrayBuffer
+ * @return A GeoJSON geometry object
  */
-function parseFlatGeobuf(input, options) {
-    if (input.byteLength === 0) {
+function parseFlatGeobuf(arrayBuffer, options) {
+    if (arrayBuffer.byteLength === 0) {
         return [];
     }
-    const arr = new Uint8Array(input);
-    const { features } = (0, flatgeobuf_geojson_min_1.deserialize)(arr);
+    if (options && options.gis && options.gis.format === 'binary') {
+        return parseFlatGeobufToBinary(arrayBuffer, options);
+    }
+    return parseFlatGeobufToGeoJSON(arrayBuffer, options);
+}
+exports.parseFlatGeobuf = parseFlatGeobuf;
+function parseFlatGeobufToBinary(arrayBuffer, options) {
+    // TODO: reproject binary features
+    // const {reproject = false, _targetCrs = 'WGS84'} = (options && options.gis) || {};
+    const arr = new Uint8Array(arrayBuffer);
+    return (0, generic_1.deserialize)(arr, binaryFromFeature);
+}
+function parseFlatGeobufToGeoJSON(arrayBuffer, options) {
+    const { reproject = false, _targetCrs = 'WGS84' } = (options && options.gis) || {};
+    const arr = new Uint8Array(arrayBuffer);
+    let headerMeta;
+    const { features } = (0, geojson_1.deserialize)(arr, false, (header) => {
+        headerMeta = header;
+    });
+    const crs = headerMeta && headerMeta.crs;
+    let projection;
+    if (reproject && crs) {
+        // Constructing the projection may fail for some invalid WKT strings
+        try {
+            projection = new proj4_1.Proj4Projection({ from: crs.wkt, to: _targetCrs });
+        }
+        catch (e) {
+            // no op
+        }
+    }
+    if (projection) {
+        return (0, gis_1.transformGeoJsonCoords)(features, (coords) => projection.project(coords));
+    }
     return features;
 }
-exports.default = parseFlatGeobuf;
 /*
  * Parse FlatGeobuf arrayBuffer and return GeoJSON.
  *
  * @param {ReadableStream} _ A FlatGeobuf arrayBuffer
  * @return  A GeoJSON geometry object iterator
  */
+// eslint-disable-next-line complexity
 function parseFlatGeobufInBatches(stream, options) {
-    const iterator = (0, flatgeobuf_geojson_min_1.deserializeStream)(stream);
-    return iterator;
+    if (options && options.gis && options.gis.format === 'binary') {
+        return parseFlatGeobufInBatchesToBinary(stream, options);
+    }
+    return parseFlatGeobufInBatchesToGeoJSON(stream, options);
 }
 exports.parseFlatGeobufInBatches = parseFlatGeobufInBatches;
+function parseFlatGeobufInBatchesToBinary(stream, options) {
+    // TODO: reproject binary streaming features
+    // const {reproject = false, _targetCrs = 'WGS84'} = (options && options.gis) || {};
+    const iterator = (0, generic_1.deserialize)(stream, binaryFromFeature);
+    return iterator;
+}
+// eslint-disable-next-line complexity
+async function* parseFlatGeobufInBatchesToGeoJSON(stream, options) {
+    const { reproject = false, _targetCrs = 'WGS84' } = (options && options.gis) || {};
+    let headerMeta;
+    const iterator = (0, geojson_1.deserialize)(stream, false, (header) => {
+        headerMeta = header;
+    });
+    let projection;
+    let firstRecord = true;
+    for await (const feature of iterator) {
+        if (firstRecord) {
+            const crs = headerMeta && headerMeta.crs;
+            if (reproject && crs) {
+                projection = new proj4_1.Proj4Projection({ from: crs.wkt, to: _targetCrs });
+            }
+            firstRecord = false;
+        }
+        if (reproject && projection) {
+            // eslint-disable-next-line
+            yield (0, gis_1.transformGeoJsonCoords)([feature], (coords) => projection.project(coords));
+        }
+        else {
+            yield feature;
+        }
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@loaders.gl/flatgeobuf",
   "description": "Loader for FlatGeobuf",
-  "version": "3.1.0-beta.5",
+  "version": "3.1.2",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
@@ -28,15 +28,14 @@
   ],
   "scripts": {
     "pre-build": "npm run build-worker && npm run build-worker --env.dev && npm run build-bundle",
-    "build-bundle": "esbuild src/bundle.ts --bundle --outfile=dist/bundle.js",
+    "build-bundle": "esbuild src/bundle.ts --bundle --outfile=dist/dist.min.js",
     "build-worker": "esbuild src/workers/flatgeobuf-worker.ts --bundle --outfile=dist/flatgeobuf-worker.js"
   },
   "dependencies": {
-    "@loaders.gl/loader-utils": "3.1.0-beta.5",
-    "flatgeobuf": "~3.1.0"
+    "@loaders.gl/gis": "4.0.0-alpha.1",
+    "@loaders.gl/loader-utils": "3.1.2",
+    "@math.gl/proj4": "^3.3.1",
+    "flatgeobuf": "3.6.5"
   },
-  "devDependencies": {
-    "esm": "^3.2.25"
-  },
-  "gitHead": "5d66468457cc878d2dbff3d7807d737ceb181c9a"
+  "gitHead": "5c25bb71a2ac8558ecedf2256cc925427b2a0506"
 }

package/src/index.ts

@@ -1,6 +1,6 @@
 import type {LoaderWithParser} from '@loaders.gl/loader-utils';
 import {FlatGeobufLoader as FlatGeobufWorkerLoader} from './flatgeobuf-loader';
-import parseFlatGeobuf, {parseFlatGeobufInBatches} from './lib/parse-flatgeobuf';
+import {parseFlatGeobuf, parseFlatGeobufInBatches} from './lib/parse-flatgeobuf';
 
 export {FlatGeobufWorkerLoader};
 

package/src/lib/binary-geometries.ts

@@ -0,0 +1,144 @@
+import {GeometryType} from 'flatgeobuf/lib/cjs/header_generated';
+
+// Parse Point to flat array
+function parsePoint(geometry) {
+  const xy = geometry.xyArray();
+  const z = geometry.zArray();
+  const positions = blitArrays(xy, z);
+  return {positions};
+}
+
+function parseLines(geometry) {
+  const xy = geometry.xyArray();
+  const z = geometry.zArray();
+  const positions = blitArrays(xy, z);
+
+  // If endsArray is null, a single LineString. Otherwise, contains the end
+  // indices of each part of the MultiLineString. geometry.endsArray() omits the
+  // initial 0 that we have in our internal format.
+  const ends = (geometry.endsArray() && Array.from(geometry.endsArray())) || [xy.length / 2];
+  ends.unshift(0);
+
+  const pathIndices = {value: new Uint16Array(ends), size: 1};
+
+  return {
+    positions,
+    pathIndices
+  };
+}
+
+function parsePolygons(geometry) {
+  const xy = geometry.xyArray();
+  const z = geometry.zArray();
+  const positions = blitArrays(xy, z);
+
+  // If endsArray is null, a simple Polygon with no inner rings. Otherwise,
+  // contains the end indices of each ring of the Polygon. geometry.endsArray()
+  // omits the initial 0 that we have in our internal format.
+  const ends = (geometry.endsArray() && Array.from(geometry.endsArray())) || [xy.length / 2];
+  ends.unshift(0);
+
+  const primitivePolygonIndices = {value: new Uint16Array(ends), size: 1};
+  const polygonIndices = {value: new Uint16Array([0, xy.length / 2]), size: 1};
+
+  return {
+    positions,
+    primitivePolygonIndices,
+    polygonIndices
+  };
+}
+
+// eslint-disable-next-line max-statements
+function parseMultiPolygons(geometry) {
+  // Create arrays for each geometry part, then concatenate
+  const parsedParts: any[] = [];
+  let nPositions = 0;
+  let nPrimitivePolygonIndices = 1;
+  let nPolygonIndices = 1;
+
+  for (let i = 0; i < geometry.partsLength(); i++) {
+    const part = geometry.parts(i);
+    const polygon = parsePolygons(part);
+
+    nPositions += polygon.positions.value.length;
+    nPrimitivePolygonIndices += polygon.primitivePolygonIndices.value.length - 1;
+    nPolygonIndices += polygon.polygonIndices.value.length - 1;
+
+    parsedParts.push(polygon);
+  }
+
+  const concatPositions = new Float64Array(nPositions);
+  const concatPrimitivePolygonIndices = new Uint32Array(nPrimitivePolygonIndices);
+  const concatPolygonIndices = new Uint32Array(nPolygonIndices);
+
+  let positionCounter = 0;
+  let primitivePolygonIndicesCounter = 1;
+  let polygonIndicesCounter = 1;
+
+  // Assumes all parts of the multipolygon have the same size
+  const positionSize = parsedParts[0].positions.size;
+
+  for (const parsedPart of parsedParts) {
+    concatPositions.set(parsedPart.positions.value, positionCounter * positionSize);
+
+    // For indices, need to add positionCounter so that position indices are
+    // correct in the concatenated positions
+    concatPrimitivePolygonIndices.set(
+      // eslint-disable-next-line
+      parsedPart.primitivePolygonIndices.value.subarray(1).map((x) => x + positionCounter),
+      primitivePolygonIndicesCounter
+    );
+    concatPolygonIndices.set(
+      // eslint-disable-next-line
+      parsedPart.polygonIndices.value.subarray(1).map((x) => x + positionCounter),
+      polygonIndicesCounter
+    );
+
+    positionCounter += parsedPart.positions.value.length / positionSize;
+    primitivePolygonIndicesCounter += parsedPart.primitivePolygonIndices.value.length - 1;
+    polygonIndicesCounter += parsedPart.polygonIndices.value.length - 1;
+  }
+
+  return {
+    positions: {value: concatPositions, size: positionSize},
+    primitivePolygonIndices: {value: concatPrimitivePolygonIndices, size: 1},
+    polygonIndices: {value: concatPolygonIndices, size: 1}
+  };
+}
+
+// Combine xy and z arrays
+function blitArrays(xy, z) {
+  if (!z) {
+    return {value: xy, size: 2};
+  }
+
+  if (z.length * 2 !== xy.length) {
+    throw new Error('Z array must be half XY array\'s length');
+  }
+  const totalLength = xy.length + z.length;
+
+  const xyz = new Float64Array(totalLength);
+  for (let i = 0; i < xy.length / 2; i++) {
+    xyz[i * 3 + 0] = xy[i * 2 + 0];
+    xyz[i * 3 + 1] = xy[i * 2 + 1];
+    xyz[i * 3 + 2] = z[i];
+  }
+  return {value: xyz, size: 3};
+}
+
+export function fromGeometry(geometry, type) {
+  switch (type) {
+    case GeometryType.Point:
+    case GeometryType.MultiPoint:
+      return parsePoint(geometry);
+    case GeometryType.LineString:
+    case GeometryType.MultiLineString:
+      return parseLines(geometry);
+    case GeometryType.Polygon:
+      return parsePolygons(geometry);
+    case GeometryType.MultiPolygon:
+      return parseMultiPolygons(geometry);
+    default:
+      throw new Error(`Unimplemented geometry type: ${type}`);
+  }
+}

package/src/lib/parse-flatgeobuf.ts

@@ -1,19 +1,80 @@
-// import {deserialize} from 'flatgeobuf/lib/geojson/featurecollection';
-import {deserialize, deserializeStream} from 'flatgeobuf/dist/flatgeobuf-geojson.min';
+// @ts-nocheck
+import {Proj4Projection} from '@math.gl/proj4';
+import {transformGeoJsonCoords} from '@loaders.gl/gis';
+
+import {deserialize as deserializeGeoJson} from 'flatgeobuf/lib/cjs/geojson';
+import {deserialize as deserializeGeneric} from 'flatgeobuf/lib/cjs/generic';
+import {parseProperties as parsePropertiesBinary} from 'flatgeobuf/lib/cjs/generic/feature';
+
+import {fromGeometry as binaryFromGeometry} from './binary-geometries';
+
+// 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 = binaryFromGeometry(geometry, geometryType);
+  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.
  *
- * @param {arrayBuffer} _ A FlatGeobuf arrayBuffer
- * @return {?Object} A GeoJSON geometry object
+ * @param arrayBuffer  A FlatGeobuf arrayBuffer
+ * @return A GeoJSON geometry object
  */
-export default function parseFlatGeobuf(input, options) {
-  if (input.byteLength === 0) {
+export function parseFlatGeobuf(arrayBuffer, options) {
+  if (arrayBuffer.byteLength === 0) {
     return [];
   }
 
-  const arr = new Uint8Array(input);
-  const {features} = deserialize(arr);
+  if (options && options.gis && options.gis.format === 'binary') {
+    return parseFlatGeobufToBinary(arrayBuffer, options);
+  }
+
+  return parseFlatGeobufToGeoJSON(arrayBuffer, options);
+}
+
+function parseFlatGeobufToBinary(arrayBuffer, options) {
+  // TODO: reproject binary features
+  // const {reproject = false, _targetCrs = 'WGS84'} = (options && options.gis) || {};
+
+  const arr = new Uint8Array(arrayBuffer);
+  return deserializeGeneric(arr, binaryFromFeature);
+}
+
+function parseFlatGeobufToGeoJSON(arrayBuffer, options) {
+  const {reproject = false, _targetCrs = 'WGS84'} = (options && options.gis) || {};
+
+  const arr = new Uint8Array(arrayBuffer);
+
+  let headerMeta;
+  const {features} = deserializeGeoJson(arr, false, (header) => {
+    headerMeta = header;
+  });
+
+  const crs = headerMeta && headerMeta.crs;
+  let projection;
+  if (reproject && crs) {
+    // Constructing the projection may fail for some invalid WKT strings
+    try {
+      projection = new Proj4Projection({from: crs.wkt, to: _targetCrs});
+    } catch (e) {
+      // no op
+    }
+  }
+
+  if (projection) {
+    return transformGeoJsonCoords(features, (coords) => projection.project(coords));
+  }
+
   return features;
 }
 
@@ -23,7 +84,49 @@ export default function parseFlatGeobuf(input, options) {
  * @param {ReadableStream} _ A FlatGeobuf arrayBuffer
  * @return  A GeoJSON geometry object iterator
  */
+// eslint-disable-next-line complexity
 export function parseFlatGeobufInBatches(stream, options) {
-  const iterator = deserializeStream(stream);
+  if (options && options.gis && options.gis.format === 'binary') {
+    return parseFlatGeobufInBatchesToBinary(stream, options);
+  }
+
+  return parseFlatGeobufInBatchesToGeoJSON(stream, options);
+}
+
+function parseFlatGeobufInBatchesToBinary(stream, options) {
+  // TODO: reproject binary streaming features
+  // const {reproject = false, _targetCrs = 'WGS84'} = (options && options.gis) || {};
+
+  const iterator = deserializeGeneric(stream, binaryFromFeature);
   return iterator;
 }
+
+// eslint-disable-next-line complexity
+async function* parseFlatGeobufInBatchesToGeoJSON(stream, options) {
+  const {reproject = false, _targetCrs = 'WGS84'} = (options && options.gis) || {};
+
+  let headerMeta;
+  const iterator = deserializeGeoJson(stream, false, (header) => {
+    headerMeta = header;
+  });
+
+  let projection;
+  let firstRecord = true;
+  for await (const feature of iterator) {
+    if (firstRecord) {
+      const crs = headerMeta && headerMeta.crs;
+      if (reproject && crs) {
+        projection = new Proj4Projection({from: crs.wkt, to: _targetCrs});
+      }
+
+      firstRecord = false;
+    }
+
+    if (reproject && projection) {
+      // eslint-disable-next-line
+      yield transformGeoJsonCoords([feature], (coords) => projection.project(coords));
+    } else {
+      yield feature;
+    }
+  }
+}