@loaders.gl/flatgeobuf 4.0.0-beta.5 → 4.0.0-beta.7

package/src/lib/binary-geometries.ts

@@ -1,21 +1,72 @@
-import {GeometryType} from 'flatgeobuf/lib/cjs/header_generated';
+// loaders.gl, MIT license
+
+import {Geometry as FGBGeometry, Feature as FGBFeature} from 'flatgeobuf';
+// import {GeometryType} from 'flatgeobuf/generic';
+// Copy geometry type as it is hard to access the export
+export declare enum GeometryType {
+  Unknown = 0,
+  Point = 1,
+  LineString = 2,
+  Polygon = 3,
+  MultiPoint = 4,
+  MultiLineString = 5,
+  MultiPolygon = 6,
+  GeometryCollection = 7,
+  CircularString = 8,
+  CompoundCurve = 9,
+  CurvePolygon = 10,
+  MultiCurve = 11,
+  MultiSurface = 12,
+  Curve = 13,
+  Surface = 14,
+  PolyhedralSurface = 15,
+  TIN = 16,
+  Triangle = 17
+}
+
+export function fgbToBinaryFeature(geometry: FGBFeature | null, type: GeometryType) {
+  const fgbGeometry: FGBGeometry | null = geometry?.geometry() || null;
+  return fgbToBinaryGeometry(fgbGeometry, type);
+}
+
+export function fgbToBinaryGeometry(geometry: FGBGeometry | null, type: GeometryType) {
+  if (geometry === null) {
+    return null;
+  }
+  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}`);
+  }
+}
 
 // Parse Point to flat array
-function parsePoint(geometry) {
+function parsePoint(geometry: FGBGeometry) {
   const xy = geometry.xyArray();
   const z = geometry.zArray();
+  // @ts-expect-error TODO handle null geometries
   const positions = blitArrays(xy, z);
   return {positions};
 }
 
-function parseLines(geometry) {
+function parseLines(geometry: FGBGeometry) {
   const xy = geometry.xyArray();
   const z = geometry.zArray();
-  const positions = blitArrays(xy, z);
+  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.
+  // @ts-expect-error TODO handle null geometries
   const ends = (geometry.endsArray() && Array.from(geometry.endsArray())) || [xy.length / 2];
   ends.unshift(0);
 
@@ -27,19 +78,21 @@ function parseLines(geometry) {
   };
 }
 
-function parsePolygons(geometry) {
+function parsePolygons(geometry: FGBGeometry) {
   const xy = geometry.xyArray();
   const z = geometry.zArray();
+  // @ts-expect-error TODO handle null geometries
   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.
+  // @ts-expect-error TODO handle null geometries
   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};
+  const polygonIndices = {value: new Uint16Array([0, xy!.length / 2]), size: 1};
 
   return {
     positions,
@@ -49,7 +102,7 @@ function parsePolygons(geometry) {
 }
 
 // eslint-disable-next-line max-statements
-function parseMultiPolygons(geometry) {
+function parseMultiPolygons(geometry: FGBGeometry) {
   // Create arrays for each geometry part, then concatenate
   const parsedParts: any[] = [];
   let nPositions = 0;
@@ -58,6 +111,7 @@ function parseMultiPolygons(geometry) {
 
   for (let i = 0; i < geometry.partsLength(); i++) {
     const part = geometry.parts(i);
+    // @ts-expect-error TODO handle null geometries
     const polygon = parsePolygons(part);
 
     nPositions += polygon.positions.value.length;
@@ -107,7 +161,7 @@ function parseMultiPolygons(geometry) {
 }
 
 // Combine xy and z arrays
-function blitArrays(xy, z) {
+function blitArrays(xy: Float64Array, z: Float64Array): {value: Float64Array; size: number} {
   if (!z) {
     return {value: xy, size: 2};
   }
@@ -125,20 +179,3 @@ function blitArrays(xy, z) {
   }
   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,25 +1,30 @@
+// loaders.gl, MIT license
+
 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 type {FlatGeobufLoaderOptions} from '../flatgeobuf-loader';
 import type {GeoJSONTable, Feature, Table} from '@loaders.gl/schema';
-import {fromGeometry as binaryFromGeometry} from './binary-geometries';
-// import {Feature} from 'flatgeobuf/lib/cjs/feature_generated';
+import {fgbToBinaryGeometry} from './binary-geometries';
+
+import {Feature as FBGFeature, HeaderMeta as FGBHeader} from 'flatgeobuf';
+import * as geojson from 'flatgeobuf/lib/mjs/geojson.js';
+import * as generic from 'flatgeobuf/lib/mjs/generic.js';
+import {parseProperties as parsePropertiesBinary} from 'flatgeobuf/lib/mjs/generic/feature';
+const deserializeGeoJson = geojson.deserialize;
+const deserializeGeneric = generic.deserialize;
+// const parsePropertiesBinary = FlatgeobufFeature.parseProperties;
 
 // TODO: reproject binary features
-function binaryFromFeature(feature, header) {
+function binaryFromFeature(feature: FBGFeature, header: FGBHeader) {
   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);
+  const geometryType = header.geometryType || geometry?.type();
+  const parsedGeometry = fgbToBinaryGeometry(geometry, geometryType!);
   // @ts-expect-error this looks wrong
   parsedGeometry.properties = parsePropertiesBinary(feature, header.columns);
 
@@ -37,10 +42,9 @@ export function parseFlatGeobuf(
   arrayBuffer: ArrayBuffer,
   options?: FlatGeobufLoaderOptions
 ): Table {
-  const shape = options?.gis?.format || options?.flatgeobuf?.shape;
+  const shape = options?.flatgeobuf?.shape;
 
   switch (shape) {
-    case 'geojson':
     case 'geojson-table': {
       const features = parseFlatGeobufToGeoJSON(arrayBuffer, options);
       const table: GeoJSONTable = {
@@ -70,8 +74,8 @@ function parseFlatGeobufToBinary(arrayBuffer: ArrayBuffer, options: FlatGeobufLo
   // const {reproject = false, _targetCrs = 'WGS84'} = (options && options.gis) || {};
 
   const array = new Uint8Array(arrayBuffer);
-  // @ts-expect-error this looks wrong
-  return deserializeGeneric(array, binaryFromFeature);
+  // @ts-expect-error
+  return deserializeGeneric(array, fgbToBinaryGeometry);
 }
 
 function parseFlatGeobufToGeoJSON(
@@ -118,11 +122,15 @@ function parseFlatGeobufToGeoJSON(
  */
 // eslint-disable-next-line complexity
 export function parseFlatGeobufInBatches(stream, options: FlatGeobufLoaderOptions) {
-  if (options && options.gis && options.gis.format === 'binary') {
-    return parseFlatGeobufInBatchesToBinary(stream, options);
+  const shape = options.flatgeobuf?.shape;
+  switch (shape) {
+    case 'binary':
+      return parseFlatGeobufInBatchesToBinary(stream, options);
+    case 'geojson-table':
+      return parseFlatGeobufInBatchesToGeoJSON(stream, options);
+    default:
+      throw new Error(shape);
   }
-
-  return parseFlatGeobufInBatchesToGeoJSON(stream, options);
 }
 
 function parseFlatGeobufInBatchesToBinary(stream, options: FlatGeobufLoaderOptions) {