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

package/dist/flatgeobuf-loader.js

@@ -1,16 +1,23 @@
-const VERSION = typeof "4.0.0-alpha.5" !== 'undefined' ? "4.0.0-alpha.5" : 'latest';
-export const FlatGeobufLoader = {
-  id: 'flatgeobuf',
-  name: 'FlatGeobuf',
-  module: 'flatgeobuf',
-  version: VERSION,
-  worker: true,
-  extensions: ['fgb'],
-  mimeTypes: ['application/octet-stream'],
-  category: 'geometry',
-  options: {
-    flatgeobuf: {}
-  }
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._typecheckFlatGeobufLoader = exports.FlatGeobufLoader = void 0;
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
+exports.FlatGeobufLoader = {
+    id: 'flatgeobuf',
+    name: 'FlatGeobuf',
+    module: 'flatgeobuf',
+    version: VERSION,
+    worker: true,
+    extensions: ['fgb'],
+    mimeTypes: ['application/octet-stream'],
+    category: 'geometry',
+    options: {
+        flatgeobuf: {
+            // Set to GeoJSON for backwards compatibility
+            shape: 'geojson'
+        }
+    }
 };
-export const _typecheckFlatGeobufLoader = FlatGeobufLoader;
-//# sourceMappingURL=flatgeobuf-loader.js.map
+exports._typecheckFlatGeobufLoader = exports.FlatGeobufLoader;

package/dist/flatgeobuf-worker.js

@@ -3246,16 +3246,33 @@
   }
 
   // ../worker-utils/src/lib/worker-farm/worker-body.ts
+  function getParentPort() {
+    let parentPort;
+    try {
+      eval("globalThis.parentPort = require('worker_threads').parentPort");
+      parentPort = globalThis.parentPort;
+    } catch {
+    }
+    return parentPort;
+  }
   var onMessageWrapperMap = new Map();
   var WorkerBody = class {
+    static inWorkerThread() {
+      return typeof self !== "undefined" || Boolean(getParentPort());
+    }
     static set onmessage(onMessage) {
-      self.onmessage = (message) => {
-        if (!isKnownMessage(message)) {
-          return;
-        }
-        const { type, payload } = message.data;
+      function handleMessage(message) {
+        const parentPort3 = getParentPort();
+        const { type, payload } = parentPort3 ? message : message.data;
         onMessage(type, payload);
-      };
+      }
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        parentPort2.on("message", handleMessage);
+        parentPort2.on("exit", () => console.debug("Node worker closing"));
+      } else {
+        globalThis.onmessage = handleMessage;
+      }
     }
     static addEventListener(onMessage) {
       let onMessageWrapper = onMessageWrapperMap.get(onMessage);
@@ -3264,22 +3281,36 @@
           if (!isKnownMessage(message)) {
             return;
           }
-          const { type, payload } = message.data;
+          const parentPort3 = getParentPort();
+          const { type, payload } = parentPort3 ? message : message.data;
           onMessage(type, payload);
         };
       }
-      self.addEventListener("message", onMessageWrapper);
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        console.error("not implemented");
+      } else {
+        globalThis.addEventListener("message", onMessageWrapper);
+      }
     }
     static removeEventListener(onMessage) {
       const onMessageWrapper = onMessageWrapperMap.get(onMessage);
       onMessageWrapperMap.delete(onMessage);
-      self.removeEventListener("message", onMessageWrapper);
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        console.error("not implemented");
+      } else {
+        globalThis.removeEventListener("message", onMessageWrapper);
+      }
     }
     static postMessage(type, payload) {
-      if (self) {
-        const data = { source: "loaders.gl", type, payload };
-        const transferList = getTransferList(payload);
-        self.postMessage(data, transferList);
+      const data = { source: "loaders.gl", type, payload };
+      const transferList = getTransferList(payload);
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        parentPort2.postMessage(data, transferList);
+      } else {
+        globalThis.postMessage(data, transferList);
       }
     }
   };
@@ -3291,19 +3322,20 @@
   // ../loader-utils/src/lib/worker-loader-utils/create-loader-worker.ts
   var requestId = 0;
   function createLoaderWorker(loader) {
-    if (typeof self === "undefined") {
+    if (!WorkerBody.inWorkerThread()) {
       return;
     }
     WorkerBody.onmessage = async (type, payload) => {
       switch (type) {
         case "process":
           try {
-            const { input, options = {} } = payload;
+            const { input, options = {}, context = {} } = payload;
             const result = await parseData({
               loader,
               arrayBuffer: input,
               options,
               context: {
+                ...context,
                 parse: parseOnMainThread
               }
             });
@@ -3362,8 +3394,54 @@
     return await parser(data, { ...options }, context, loader);
   }
 
+  // ../../node_modules/@babel/runtime/helpers/esm/typeof.js
+  function _typeof(obj) {
+    "@babel/helpers - typeof";
+    return _typeof = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(obj2) {
+      return typeof obj2;
+    } : function(obj2) {
+      return obj2 && typeof Symbol == "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+    }, _typeof(obj);
+  }
+
+  // ../../node_modules/@babel/runtime/helpers/esm/toPrimitive.js
+  function _toPrimitive(input, hint) {
+    if (_typeof(input) !== "object" || input === null)
+      return input;
+    var prim = input[Symbol.toPrimitive];
+    if (prim !== void 0) {
+      var res = prim.call(input, hint || "default");
+      if (_typeof(res) !== "object")
+        return res;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (hint === "string" ? String : Number)(input);
+  }
+
+  // ../../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js
+  function _toPropertyKey(arg) {
+    var key = _toPrimitive(arg, "string");
+    return _typeof(key) === "symbol" ? key : String(key);
+  }
+
+  // ../../node_modules/@babel/runtime/helpers/esm/defineProperty.js
+  function _defineProperty(obj, key, value) {
+    key = _toPropertyKey(key);
+    if (key in obj) {
+      Object.defineProperty(obj, key, {
+        value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    } else {
+      obj[key] = value;
+    }
+    return obj;
+  }
+
   // src/flatgeobuf-loader.ts
-  var VERSION = true ? "4.0.0-alpha.5" : "latest";
+  var VERSION = true ? "4.0.0-alpha.6" : "latest";
   var FlatGeobufLoader = {
     id: "flatgeobuf",
     name: "FlatGeobuf",
@@ -3374,7 +3452,9 @@
     mimeTypes: ["application/octet-stream"],
     category: "geometry",
     options: {
-      flatgeobuf: {}
+      flatgeobuf: {
+        shape: "geojson"
+      }
     }
   };
 
@@ -3587,7 +3667,7 @@
   var ENDED = -1;
   var whitespace = /\s/;
   var latin = /[A-Za-z]/;
-  var keyword = /[A-Za-z84]/;
+  var keyword = /[A-Za-z84_]/;
   var endThings = /[,\]]/;
   var digets = /[\d\.E\-\+]/;
   function Parser(text) {
@@ -3885,15 +3965,14 @@
     if (wkt.AXIS) {
       var axisOrder = "";
       for (var i = 0, ii = wkt.AXIS.length; i < ii; ++i) {
-        var axis = wkt.AXIS[i];
-        var descriptor = axis[0].toLowerCase();
-        if (descriptor.indexOf("north") !== -1) {
+        var axis = [wkt.AXIS[i][0].toLowerCase(), wkt.AXIS[i][1].toLowerCase()];
+        if (axis[0].indexOf("north") !== -1 || (axis[0] === "y" || axis[0] === "lat") && axis[1] === "north") {
           axisOrder += "n";
-        } else if (descriptor.indexOf("south") !== -1) {
+        } else if (axis[0].indexOf("south") !== -1 || (axis[0] === "y" || axis[0] === "lat") && axis[1] === "south") {
           axisOrder += "s";
-        } else if (descriptor.indexOf("east") !== -1) {
+        } else if (axis[0].indexOf("east") !== -1 || (axis[0] === "x" || axis[0] === "lon") && axis[1] === "east") {
           axisOrder += "e";
-        } else if (descriptor.indexOf("west") !== -1) {
+        } else if (axis[0].indexOf("west") !== -1 || (axis[0] === "x" || axis[0] === "lon") && axis[1] === "west") {
           axisOrder += "w";
         }
       }
@@ -3989,12 +4068,22 @@
     };
     var list = [
       ["standard_parallel_1", "Standard_Parallel_1"],
+      ["standard_parallel_1", "Latitude of 1st standard parallel"],
       ["standard_parallel_2", "Standard_Parallel_2"],
+      ["standard_parallel_2", "Latitude of 2nd standard parallel"],
       ["false_easting", "False_Easting"],
+      ["false_easting", "False easting"],
+      ["false-easting", "Easting at false origin"],
       ["false_northing", "False_Northing"],
+      ["false_northing", "False northing"],
+      ["false_northing", "Northing at false origin"],
       ["central_meridian", "Central_Meridian"],
+      ["central_meridian", "Longitude of natural origin"],
+      ["central_meridian", "Longitude of false origin"],
       ["latitude_of_origin", "Latitude_Of_Origin"],
       ["latitude_of_origin", "Central_Parallel"],
+      ["latitude_of_origin", "Latitude of natural origin"],
+      ["latitude_of_origin", "Latitude of false origin"],
       ["scale_factor", "Scale_Factor"],
       ["k0", "scale_factor"],
       ["latitude_of_center", "Latitude_Of_Center"],
@@ -8692,7 +8781,7 @@
   projs_default(core_default);
   var lib_default = core_default;
 
-  // node_modules/@math.gl/proj4/dist/esm/lib/proj4-projection.js
+  // ../../node_modules/@math.gl/proj4/dist/esm/lib/proj4-projection.js
   var Proj4Projection = class {
     static defineProjectionAliases(aliases) {
       const aliasArray = [];
@@ -8705,12 +8794,19 @@
       from = "WGS84",
       to = "WGS84"
     }) {
-      const projection = lib_default(from, to);
-      if (!projection) {
+      _defineProperty(this, "_projection", void 0);
+      this._projection = lib_default(from, to);
+      if (!this._projection) {
         throw new Error("Invalid projection");
       }
-      this.project = projection.forward;
-      this.unproject = projection.inverse;
+      this.project = this.project.bind(this);
+      this.unproject = this.unproject.bind(this);
+    }
+    project(coord) {
+      return this._projection.forward(coord);
+    }
+    unproject(coord) {
+      return this._projection.inverse(coord);
     }
   };
 
@@ -8848,19 +8944,33 @@
     return parsedGeometry;
   }
   function parseFlatGeobuf(arrayBuffer, options) {
-    if (arrayBuffer.byteLength === 0) {
-      return [];
-    }
-    if (options && options.gis && options.gis.format === "binary") {
-      return parseFlatGeobufToBinary(arrayBuffer, options);
+    const shape = options?.gis?.format || options?.flatgeobuf?.shape;
+    switch (shape) {
+      case "geojson-row-table": {
+        const table = {
+          shape: "geojson-row-table",
+          data: parseFlatGeobufToGeoJSON(arrayBuffer, options)
+        };
+        return table;
+      }
+      case "columnar-table":
+        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);
     }
-    return parseFlatGeobufToGeoJSON(arrayBuffer, options);
   }
   function parseFlatGeobufToBinary(arrayBuffer, options) {
-    const arr = new Uint8Array(arrayBuffer);
-    return (0, import_generic.deserialize)(arr, binaryFromFeature);
+    const array = new Uint8Array(arrayBuffer);
+    return (0, import_generic.deserialize)(array, binaryFromFeature);
   }
   function parseFlatGeobufToGeoJSON(arrayBuffer, options) {
+    if (arrayBuffer.byteLength === 0) {
+      return [];
+    }
     const { reproject = false, _targetCrs = "WGS84" } = options && options.gis || {};
     const arr = new Uint8Array(arrayBuffer);
     let headerMeta;

package/dist/index.d.ts

@@ -3,7 +3,10 @@ import { FlatGeobufLoader as FlatGeobufWorkerLoader } from './flatgeobuf-loader'
 import { parseFlatGeobuf, parseFlatGeobufInBatches } from './lib/parse-flatgeobuf';
 export { FlatGeobufWorkerLoader };
 export declare const FlatGeobufLoader: {
-    parse: (arrayBuffer: any, options: any) => Promise<any>;
+    parse: (arrayBuffer: any, options: any) => Promise<any[] | import("@loaders.gl/schema").GeoJSONRowTable | AsyncGenerator<import("flatgeobuf/lib/cjs/generic/feature").IFeature, any, unknown> | {
+        shape: string;
+        data: any[] | AsyncGenerator<import("flatgeobuf/lib/cjs/generic/feature").IFeature, any, unknown>;
+    }>;
     parseSync: typeof parseFlatGeobuf;
     parseInBatchesFromStream: typeof parseFlatGeobufInBatches;
     binary: boolean;
@@ -16,7 +19,9 @@ export declare const FlatGeobufLoader: {
     mimeTypes: string[];
     category: string;
     options: {
-        flatgeobuf: {};
+        flatgeobuf: {
+            shape: string;
+        };
     };
 };
 export declare const _typecheckFlatGeobufLoader: LoaderWithParser;

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,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"}
+{"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,11 +1,14 @@
-import { FlatGeobufLoader as FlatGeobufWorkerLoader } from './flatgeobuf-loader';
-import { parseFlatGeobuf, parseFlatGeobufInBatches } from './lib/parse-flatgeobuf';
-export { FlatGeobufWorkerLoader };
-export const FlatGeobufLoader = { ...FlatGeobufWorkerLoader,
-  parse: async (arrayBuffer, options) => parseFlatGeobuf(arrayBuffer, options),
-  parseSync: parseFlatGeobuf,
-  parseInBatchesFromStream: parseFlatGeobufInBatches,
-  binary: true
+"use strict";
+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 = require("./lib/parse-flatgeobuf");
+exports.FlatGeobufLoader = {
+    ...flatgeobuf_loader_1.FlatGeobufLoader,
+    parse: async (arrayBuffer, options) => (0, parse_flatgeobuf_1.parseFlatGeobuf)(arrayBuffer, options),
+    parseSync: parse_flatgeobuf_1.parseFlatGeobuf,
+    parseInBatchesFromStream: parse_flatgeobuf_1.parseFlatGeobufInBatches,
+    binary: true
 };
-export const _typecheckFlatGeobufLoader = FlatGeobufLoader;
-//# sourceMappingURL=index.js.map
+exports._typecheckFlatGeobufLoader = exports.FlatGeobufLoader;

package/dist/lib/binary-geometries.js

@@ -1,144 +1,120 @@
-import { GeometryType } from 'flatgeobuf/lib/cjs/header_generated';
-
+"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
-  };
+    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);
-  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
-  };
+    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);
-  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
-  };
+    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) {
-  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;
-  const positionSize = parsedParts[0].positions.size;
-
-  for (const parsedPart of parsedParts) {
-    concatPositions.set(parsedPart.positions.value, positionCounter * positionSize);
-    concatPrimitivePolygonIndices.set(parsedPart.primitivePolygonIndices.value.subarray(1).map(x => x + positionCounter), primitivePolygonIndicesCounter);
-    concatPolygonIndices.set(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
+    // 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;
     }
-  };
-}
-
-function blitArrays(xy, z) {
-  if (!z) {
     return {
-      value: xy,
-      size: 2
+        positions: { value: concatPositions, size: positionSize },
+        primitivePolygonIndices: { value: concatPrimitivePolygonIndices, size: 1 },
+        polygonIndices: { value: concatPolygonIndices, size: 1 }
     };
-  }
-
-  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: ".concat(type));
-  }
+// 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}`);
+    }
 }
-//# sourceMappingURL=binary-geometries.js.map
+exports.fromGeometry = fromGeometry;

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

@@ -1,3 +1,8 @@
-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>;
+import { FlatGeobufLoaderOptions } from './types';
+import { GeoJSONRowTable } from '@loaders.gl/schema';
+export declare function parseFlatGeobuf(arrayBuffer: ArrayBuffer, options?: FlatGeobufLoaderOptions): any[] | GeoJSONRowTable | AsyncGenerator<import("flatgeobuf/lib/cjs/generic/feature").IFeature, any, unknown> | {
+    shape: string;
+    data: any[] | AsyncGenerator<import("flatgeobuf/lib/cjs/generic/feature").IFeature, any, unknown>;
+};
+export declare function parseFlatGeobufInBatches(stream: any, options: FlatGeobufLoaderOptions): any[] | AsyncGenerator<import("flatgeobuf/lib/cjs/generic/feature").IFeature, any, unknown> | AsyncGenerator<any, void, unknown>;
 //# sourceMappingURL=parse-flatgeobuf.d.ts.map