@loaders.gl/flatgeobuf 4.0.0-alpha.4 → 4.0.0-alpha.6

package/src/lib/parse-flatgeobuf.ts

@@ -1,19 +1,99 @@
-// 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';
+import {FlatGeobufLoaderOptions} from './types';
+import {GeoJSONRowTable, Feature} from '@loaders.gl/schema';
+
+// 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: ArrayBuffer, options?: FlatGeobufLoaderOptions) {
+  const shape = options?.gis?.format || options?.flatgeobuf?.shape;
+
+  switch (shape) {
+    case 'geojson-row-table': {
+      const table: GeoJSONRowTable = {
+        shape: 'geojson-row-table',
+        data: parseFlatGeobufToGeoJSON(arrayBuffer, options)
+      };
+      return table;
+    }
+    case 'columnar-table': // binary + some JS arrays
+      return {shape: 'columnar-table', data: parseFlatGeobufToBinary(arrayBuffer, options)};
+    case 'geojson':
+      return parseFlatGeobufToGeoJSON(arrayBuffer, options);
+    case 'binary':
+      return parseFlatGeobufToBinary(arrayBuffer, options);
+    default:
+      throw new Error(shape);
+  }
+}
+
+function parseFlatGeobufToBinary(arrayBuffer: ArrayBuffer, options: FlatGeobufLoaderOptions) {
+  // TODO: reproject binary features
+  // const {reproject = false, _targetCrs = 'WGS84'} = (options && options.gis) || {};
+
+  const array = new Uint8Array(arrayBuffer);
+  return deserializeGeneric(array, binaryFromFeature);
+}
+
+function parseFlatGeobufToGeoJSON(
+  arrayBuffer: ArrayBuffer,
+  options: FlatGeobufLoaderOptions
+): Feature[] {
+  if (arrayBuffer.byteLength === 0) {
     return [];
   }
 
-  const arr = new Uint8Array(input);
-  const {features} = deserialize(arr);
+  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 +103,49 @@ export default function parseFlatGeobuf(input, options) {
  * @param {ReadableStream} _ A FlatGeobuf arrayBuffer
  * @return  A GeoJSON geometry object iterator
  */
-export function parseFlatGeobufInBatches(stream, options) {
-  const iterator = deserializeStream(stream);
+// eslint-disable-next-line complexity
+export function parseFlatGeobufInBatches(stream, options: FlatGeobufLoaderOptions) {
+  if (options && options.gis && options.gis.format === 'binary') {
+    return parseFlatGeobufInBatchesToBinary(stream, options);
+  }
+
+  return parseFlatGeobufInBatchesToGeoJSON(stream, options);
+}
+
+function parseFlatGeobufInBatchesToBinary(stream, options: FlatGeobufLoaderOptions) {
+  // 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: FlatGeobufLoaderOptions) {
+  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;
+    }
+  }
+}

package/src/lib/types.ts

@@ -0,0 +1,13 @@
+import type {LoaderOptions} from '@loaders.gl/loader-utils';
+
+export type FlatGeobufLoaderOptions = LoaderOptions & {
+  flatgeobuf?: {
+    shape?: 'geojson-row-table' | 'columnar-table' | 'geojson' | 'binary';
+  };
+  gis?: {
+    reproject?: boolean;
+    _targetCrs?: string;
+    /** @deprecated Use options.flatgeobuf.shape */
+    format?: 'geojson-row-table' | 'columnar-table' | 'geojson' | 'binary';
+  };
+};

package/dist/bundle.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/bundle.ts"],"names":["moduleExports","require","globalThis","loaders","module","exports","Object","assign"],"mappings":"AACA,MAAMA,aAAa,GAAGC,OAAO,CAAC,SAAD,CAA7B;;AACAC,UAAU,CAACC,OAAX,GAAqBD,UAAU,CAACC,OAAX,IAAsB,EAA3C;AACAC,MAAM,CAACC,OAAP,GAAiBC,MAAM,CAACC,MAAP,CAAcL,UAAU,CAACC,OAAzB,EAAkCH,aAAlC,CAAjB","sourcesContent":["// @ts-nocheck\nconst moduleExports = require('./index');\nglobalThis.loaders = globalThis.loaders || {};\nmodule.exports = Object.assign(globalThis.loaders, moduleExports);\n"],"file":"bundle.js"}

package/dist/flatgeobuf-loader.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/flatgeobuf-loader.ts"],"names":["VERSION","FlatGeobufLoader","id","name","module","version","worker","extensions","mimeTypes","category","options","flatgeobuf","_typecheckFlatGeobufLoader"],"mappings":"AAIA,MAAMA,OAAO,GAAG,2BAAuB,WAAvB,qBAAmD,QAAnE;AAEA,OAAO,MAAMC,gBAAgB,GAAG;AAC9BC,EAAAA,EAAE,EAAE,YAD0B;AAE9BC,EAAAA,IAAI,EAAE,YAFwB;AAG9BC,EAAAA,MAAM,EAAE,YAHsB;AAI9BC,EAAAA,OAAO,EAAEL,OAJqB;AAK9BM,EAAAA,MAAM,EAAE,IALsB;AAM9BC,EAAAA,UAAU,EAAE,CAAC,KAAD,CANkB;AAO9BC,EAAAA,SAAS,EAAE,CAAC,0BAAD,CAPmB;AAQ9BC,EAAAA,QAAQ,EAAE,UARoB;AAS9BC,EAAAA,OAAO,EAAE;AACPC,IAAAA,UAAU,EAAE;AADL;AATqB,CAAzB;AAcP,OAAO,MAAMC,0BAAkC,GAAGX,gBAA3C","sourcesContent":["import type {Loader} from '@loaders.gl/loader-utils';\n\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\nexport const FlatGeobufLoader = {\n  id: 'flatgeobuf',\n  name: 'FlatGeobuf',\n  module: 'flatgeobuf',\n  version: VERSION,\n  worker: true,\n  extensions: ['fgb'],\n  mimeTypes: ['application/octet-stream'],\n  category: 'geometry',\n  options: {\n    flatgeobuf: {}\n  }\n};\n\nexport const _typecheckFlatGeobufLoader: Loader = FlatGeobufLoader;\n"],"file":"flatgeobuf-loader.js"}

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/index.ts"],"names":["FlatGeobufLoader","FlatGeobufWorkerLoader","parseFlatGeobuf","parseFlatGeobufInBatches","parse","arrayBuffer","options","parseSync","parseInBatchesFromStream","binary","_typecheckFlatGeobufLoader"],"mappings":"AACA,SAAQA,gBAAgB,IAAIC,sBAA5B,QAAyD,qBAAzD;AACA,OAAOC,eAAP,IAAyBC,wBAAzB,QAAwD,wBAAxD;AAEA,SAAQF,sBAAR;AAEA,OAAO,MAAMD,gBAAgB,GAAG,EAC9B,GAAGC,sBAD2B;AAE9BG,EAAAA,KAAK,EAAE,OAAOC,WAAP,EAAoBC,OAApB,KAAgCJ,eAAe,CAACG,WAAD,EAAcC,OAAd,CAFxB;AAG9BC,EAAAA,SAAS,EAAEL,eAHmB;AAI9BM,EAAAA,wBAAwB,EAAEL,wBAJI;AAK9BM,EAAAA,MAAM,EAAE;AALsB,CAAzB;AAQP,OAAO,MAAMC,0BAA4C,GAAGV,gBAArD","sourcesContent":["import type {LoaderWithParser} from '@loaders.gl/loader-utils';\nimport {FlatGeobufLoader as FlatGeobufWorkerLoader} from './flatgeobuf-loader';\nimport parseFlatGeobuf, {parseFlatGeobufInBatches} from './lib/parse-flatgeobuf';\n\nexport {FlatGeobufWorkerLoader};\n\nexport const FlatGeobufLoader = {\n  ...FlatGeobufWorkerLoader,\n  parse: async (arrayBuffer, options) => parseFlatGeobuf(arrayBuffer, options),\n  parseSync: parseFlatGeobuf,\n  parseInBatchesFromStream: parseFlatGeobufInBatches,\n  binary: true\n};\n\nexport const _typecheckFlatGeobufLoader: LoaderWithParser = FlatGeobufLoader;\n"],"file":"index.js"}

package/dist/lib/parse-flatgeobuf.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/lib/parse-flatgeobuf.ts"],"names":["deserialize","deserializeStream","parseFlatGeobuf","input","options","byteLength","arr","Uint8Array","features","parseFlatGeobufInBatches","stream","iterator"],"mappings":"AACA,SAAQA,WAAR,EAAqBC,iBAArB,QAA6C,wCAA7C;AAQA,eAAe,SAASC,eAAT,CAAyBC,KAAzB,EAAgCC,OAAhC,EAAyC;AACtD,MAAID,KAAK,CAACE,UAAN,KAAqB,CAAzB,EAA4B;AAC1B,WAAO,EAAP;AACD;;AAED,QAAMC,GAAG,GAAG,IAAIC,UAAJ,CAAeJ,KAAf,CAAZ;AACA,QAAM;AAACK,IAAAA;AAAD,MAAaR,WAAW,CAACM,GAAD,CAA9B;AACA,SAAOE,QAAP;AACD;AAQD,OAAO,SAASC,wBAAT,CAAkCC,MAAlC,EAA0CN,OAA1C,EAAmD;AACxD,QAAMO,QAAQ,GAAGV,iBAAiB,CAACS,MAAD,CAAlC;AACA,SAAOC,QAAP;AACD","sourcesContent":["// import {deserialize} from 'flatgeobuf/lib/geojson/featurecollection';\nimport {deserialize, deserializeStream} from 'flatgeobuf/dist/flatgeobuf-geojson.min';\n\n/*\n * Parse FlatGeobuf arrayBuffer and return GeoJSON.\n *\n * @param {arrayBuffer} _ A FlatGeobuf arrayBuffer\n * @return {?Object} A GeoJSON geometry object\n */\nexport default function parseFlatGeobuf(input, options) {\n  if (input.byteLength === 0) {\n    return [];\n  }\n\n  const arr = new Uint8Array(input);\n  const {features} = deserialize(arr);\n  return features;\n}\n\n/*\n * Parse FlatGeobuf arrayBuffer and return GeoJSON.\n *\n * @param {ReadableStream} _ A FlatGeobuf arrayBuffer\n * @return  A GeoJSON geometry object iterator\n */\nexport function parseFlatGeobufInBatches(stream, options) {\n  const iterator = deserializeStream(stream);\n  return iterator;\n}\n"],"file":"parse-flatgeobuf.js"}

package/dist/workers/flatgeobuf-worker.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/workers/flatgeobuf-worker.ts"],"names":["createLoaderWorker","FlatGeobufLoader"],"mappings":"AAAA,SAAQA,kBAAR,QAAiC,0BAAjC;AACA,SAAQC,gBAAR,QAA+B,UAA/B;AAEAD,kBAAkB,CAACC,gBAAD,CAAlB","sourcesContent":["import {createLoaderWorker} from '@loaders.gl/loader-utils';\nimport {FlatGeobufLoader} from '../index';\n\ncreateLoaderWorker(FlatGeobufLoader);\n"],"file":"flatgeobuf-worker.js"}