@loaders.gl/flatgeobuf 4.2.0-alpha.5 → 4.2.0-beta.1

package/dist/index.cjs

@@ -5,6 +5,7 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -26,6 +27,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
 
 // dist/index.js
 var dist_exports = {};
@@ -264,10 +269,8 @@ var GeometryType2;
 // dist/flatgeobuf/3.27.2/flat-geobuf/geometry.js
 var flatbuffers = __toESM(require("flatbuffers"), 1);
 var Geometry = class {
-  constructor() {
-    this.bb = null;
-    this.bb_pos = 0;
-  }
+  bb = null;
+  bb_pos = 0;
   __init(i, bb) {
     this.bb_pos = i;
     this.bb = bb;
@@ -580,10 +583,8 @@ var flatbuffers3 = __toESM(require("flatbuffers"), 1);
 // dist/flatgeobuf/3.27.2/flat-geobuf/column.js
 var flatbuffers2 = __toESM(require("flatbuffers"), 1);
 var Column = class {
-  constructor() {
-    this.bb = null;
-    this.bb_pos = 0;
-  }
+  bb = null;
+  bb_pos = 0;
   __init(i, bb) {
     this.bb_pos = i;
     this.bb = bb;
@@ -700,10 +701,8 @@ var Column = class {
 
 // dist/flatgeobuf/3.27.2/flat-geobuf/feature.js
 var Feature = class {
-  constructor() {
-    this.bb = null;
-    this.bb_pos = 0;
-  }
+  bb = null;
+  bb_pos = 0;
   __init(i, bb) {
     this.bb_pos = i;
     this.bb = bb;
@@ -910,10 +909,8 @@ var flatbuffers6 = __toESM(require("flatbuffers"), 1);
 // dist/flatgeobuf/3.27.2/flat-geobuf/crs.js
 var flatbuffers5 = __toESM(require("flatbuffers"), 1);
 var Crs = class {
-  constructor() {
-    this.bb = null;
-    this.bb_pos = 0;
-  }
+  bb = null;
+  bb_pos = 0;
   __init(i, bb) {
     this.bb_pos = i;
     this.bb = bb;
@@ -989,10 +986,8 @@ var Crs = class {
 
 // dist/flatgeobuf/3.27.2/flat-geobuf/header.js
 var Header = class {
-  constructor() {
-    this.bb = null;
-    this.bb_pos = 0;
-  }
+  bb = null;
+  bb_pos = 0;
   __init(i, bb) {
     this.bb_pos = i;
     this.bb = bb;
@@ -1203,10 +1198,8 @@ var flatbuffers7 = __toESM(require("flatbuffers"), 1);
 var import_repeater = require("@repeaterjs/repeater");
 
 // dist/flatgeobuf/3.27.2/config.js
-var Config = class {
-  constructor() {
-    this._extraRequestThreshold = 256 * 1024;
-  }
+var _Config = class {
+  _extraRequestThreshold = 256 * 1024;
   /**
    * Fetch up to this many extra bytes if it will eliminate an extra request
    */
@@ -1220,8 +1213,8 @@ var Config = class {
     this._extraRequestThreshold = bytes;
   }
 };
-Config.global = new Config();
-var config_default = Config;
+var Config = _Config;
+__publicField(Config, "global", new _Config());
 
 // dist/flatgeobuf/3.27.2/logger.js
 var LogLevel;
@@ -1268,8 +1261,7 @@ var Logger = class {
     }
   }
 };
-Logger.logLevel = LogLevel.Warn;
-var logger_default = Logger;
+__publicField(Logger, "logLevel", LogLevel.Warn);
 
 // dist/flatgeobuf/3.27.2/packedrtree.js
 var NODE_ITEM_BYTE_LEN = 8 * 4 + 8;
@@ -1310,6 +1302,8 @@ function generateLevelBounds(numItems, nodeSize) {
 }
 async function* streamSearch(numItems, nodeSize, rect, readNode) {
   class NodeRange {
+    _level;
+    nodes;
     constructor(nodes, level) {
       this._level = level;
       this.nodes = nodes;
@@ -1332,7 +1326,7 @@ async function* streamSearch(numItems, nodeSize, rect, readNode) {
     }
   }
   const { minX, minY, maxX, maxY } = rect;
-  logger_default.info(`tree items: ${numItems}, nodeSize: ${nodeSize}`);
+  Logger.info(`tree items: ${numItems}, nodeSize: ${nodeSize}`);
   const levelBounds = generateLevelBounds(numItems, nodeSize);
   const firstLeafNodeIdx = levelBounds[0][0];
   const rootNodeRange = (() => {
@@ -1341,10 +1335,10 @@ async function* streamSearch(numItems, nodeSize, rect, readNode) {
     return new NodeRange(range, level);
   })();
   const queue = [rootNodeRange];
-  logger_default.debug(`starting stream search with queue: ${queue}, numItems: ${numItems}, nodeSize: ${nodeSize}, levelBounds: ${levelBounds}`);
+  Logger.debug(`starting stream search with queue: ${queue}, numItems: ${numItems}, nodeSize: ${nodeSize}, levelBounds: ${levelBounds}`);
   while (queue.length != 0) {
     const nodeRange = queue.shift();
-    logger_default.debug(`popped node: ${nodeRange}, queueLength: ${queue.length}`);
+    Logger.debug(`popped node: ${nodeRange}, queueLength: ${queue.length}`);
     const nodeRangeStartIdx = nodeRange.startNodeIdx();
     const isLeafNode = nodeRangeStartIdx >= firstLeafNodeIdx;
     const nodeRangeEndIdx = (() => {
@@ -1385,10 +1379,10 @@ async function* streamSearch(numItems, nodeSize, rect, readNode) {
         continue;
       }
       const firstChildNodeIdx = offset;
-      const extraRequestThresholdNodes = config_default.global.extraRequestThreshold() / NODE_ITEM_BYTE_LEN;
+      const extraRequestThresholdNodes = Config.global.extraRequestThreshold() / NODE_ITEM_BYTE_LEN;
       const nearestNodeRange = queue[queue.length - 1];
       if (nearestNodeRange !== void 0 && nearestNodeRange.level() == nodeRange.level() - 1 && firstChildNodeIdx < nearestNodeRange.endNodeIdx() + extraRequestThresholdNodes) {
-        logger_default.debug(`Merging "nodeRange" request into existing range: ${nearestNodeRange}, newEndNodeIdx: ${nearestNodeRange.endNodeIdx()} -> ${firstChildNodeIdx}`);
+        Logger.debug(`Merging "nodeRange" request into existing range: ${nearestNodeRange}, newEndNodeIdx: ${nearestNodeRange.endNodeIdx()} -> ${firstChildNodeIdx}`);
         nearestNodeRange.extendEndNodeIdx(Number(firstChildNodeIdx));
         continue;
       }
@@ -1398,9 +1392,9 @@ async function* streamSearch(numItems, nodeSize, rect, readNode) {
         return new NodeRange(range, level);
       })();
       if (nearestNodeRange !== void 0 && nearestNodeRange.level() == newNodeRange.level()) {
-        logger_default.info(`Same level, but too far away. Pushing new request for nodeIdx: ${firstChildNodeIdx} rather than merging with distant ${nearestNodeRange}`);
+        Logger.info(`Same level, but too far away. Pushing new request for nodeIdx: ${firstChildNodeIdx} rather than merging with distant ${nearestNodeRange}`);
       } else {
-        logger_default.info(`Pushing new level for ${newNodeRange} onto queue with nearestNodeRange: ${nearestNodeRange} since there's not already a range for this level.`);
+        Logger.info(`Pushing new level for ${newNodeRange} onto queue with nearestNodeRange: ${nearestNodeRange} since there's not already a range for this level.`);
       }
       queue.push(newNodeRange);
     }
@@ -1422,6 +1416,10 @@ var SIZE_PREFIX_LEN = 4;
 
 // dist/flatgeobuf/3.27.2/http-reader.js
 var HttpReader = class {
+  headerClient;
+  header;
+  headerLength;
+  indexLength;
   constructor(headerClient, header, headerLength, indexLength) {
     this.headerClient = headerClient;
     this.header = header;
@@ -1446,14 +1444,14 @@ var HttpReader = class {
       return result;
     })();
     const minReqLength = assumedHeaderLength + assumedIndexLength;
-    logger_default.debug(`fetching header. minReqLength: ${minReqLength} (assumedHeaderLength: ${assumedHeaderLength}, assumedIndexLength: ${assumedIndexLength})`);
+    Logger.debug(`fetching header. minReqLength: ${minReqLength} (assumedHeaderLength: ${assumedHeaderLength}, assumedIndexLength: ${assumedIndexLength})`);
     {
       const bytes2 = new Uint8Array(await headerClient.getRange(0, 8, minReqLength, "header"));
       if (!bytes2.subarray(0, 3).every((v, i) => magicbytes[i] === v)) {
-        logger_default.error(`bytes: ${bytes2} != ${magicbytes}`);
+        Logger.error(`bytes: ${bytes2} != ${magicbytes}`);
         throw new Error("Not a FlatGeobuf file");
       }
-      logger_default.debug("magic bytes look good");
+      Logger.debug("magic bytes look good");
     }
     let headerLength;
     {
@@ -1463,13 +1461,13 @@ var HttpReader = class {
       if (headerLength > HEADER_MAX_BUFFER_SIZE || headerLength < 8) {
         throw new Error("Invalid header size");
       }
-      logger_default.debug(`headerLength: ${headerLength}`);
+      Logger.debug(`headerLength: ${headerLength}`);
     }
     const bytes = await headerClient.getRange(12, headerLength, minReqLength, "header");
     const bb = new flatbuffers7.ByteBuffer(new Uint8Array(bytes));
     const header = fromByteBuffer(bb);
     const indexLength = calcTreeSize(header.featuresCount, header.indexNodeSize);
-    logger_default.debug("completed: opening http reader");
+    Logger.debug("completed: opening http reader");
     return new HttpReader(headerClient, header, headerLength, indexLength);
   }
   async *selectBbox(rect) {
@@ -1485,7 +1483,7 @@ var HttpReader = class {
       const [featureOffset, ,] = searchResult;
       let [, , featureLength] = searchResult;
       if (!featureLength) {
-        logger_default.info("final feature");
+        Logger.info("final feature");
         featureLength = 4;
       }
       if (currentBatch.length == 0) {
@@ -1494,8 +1492,8 @@ var HttpReader = class {
       }
       const prevFeature = currentBatch[currentBatch.length - 1];
       const gap = featureOffset - (prevFeature[0] + prevFeature[1]);
-      if (gap > config_default.global.extraRequestThreshold()) {
-        logger_default.info(`Pushing new feature batch, since gap ${gap} was too large`);
+      if (gap > Config.global.extraRequestThreshold()) {
+        Logger.info(`Pushing new feature batch, since gap ${gap} was too large`);
         batches.push(currentBatch);
         currentBatch = [];
       }
@@ -1553,11 +1551,14 @@ var HttpReader = class {
   }
 };
 var BufferedHttpRangeClient = class {
+  httpClient;
+  bytesEverUsed = 0;
+  bytesEverFetched = 0;
+  buffer = new ArrayBuffer(0);
+  // Byte offset of `buffer` with respect to the beginning of the file being
+  // buffered
+  head = 0;
   constructor(source) {
-    this.bytesEverUsed = 0;
-    this.bytesEverFetched = 0;
-    this.buffer = new ArrayBuffer(0);
-    this.head = 0;
     if (typeof source === "string") {
       this.httpClient = new HttpRangeClient(source);
     } else if (source instanceof HttpRangeClient) {
@@ -1575,7 +1576,7 @@ var BufferedHttpRangeClient = class {
     }
     const lengthToFetch = Math.max(length, minReqLength);
     this.bytesEverFetched += lengthToFetch;
-    logger_default.debug(`requesting for new Range: ${start}-${start + lengthToFetch - 1}`);
+    Logger.debug(`requesting for new Range: ${start}-${start + lengthToFetch - 1}`);
     this.buffer = await this.httpClient.getRange(start, lengthToFetch, purpose);
     this.head = start;
     return this.buffer.slice(0, length);
@@ -1585,20 +1586,21 @@ var BufferedHttpRangeClient = class {
     const used = this.bytesEverUsed;
     const requested = this.bytesEverFetched;
     const efficiency = (100 * used / requested).toFixed(2);
-    logger_default.info(`${category} bytes used/requested: ${used} / ${requested} = ${efficiency}%`);
+    Logger.info(`${category} bytes used/requested: ${used} / ${requested} = ${efficiency}%`);
   }
 };
 var HttpRangeClient = class {
+  url;
+  requestsEverMade = 0;
+  bytesEverRequested = 0;
   constructor(url) {
-    this.requestsEverMade = 0;
-    this.bytesEverRequested = 0;
     this.url = url;
   }
   async getRange(begin, length, purpose) {
     this.requestsEverMade += 1;
     this.bytesEverRequested += length;
     const range = `bytes=${begin}-${begin + length - 1}`;
-    logger_default.info(`request: #${this.requestsEverMade}, purpose: ${purpose}), bytes: (this_request: ${length}, ever: ${this.bytesEverRequested}), Range: ${range}`);
+    Logger.info(`request: #${this.requestsEverMade}, purpose: ${purpose}), bytes: (this_request: ${length}, ever: ${this.bytesEverRequested}), Range: ${range}`);
     const response = await fetch(this.url, {
       headers: {
         Range: range
@@ -1684,7 +1686,7 @@ async function* deserializeStream(stream, fromFeature2, headerMetaFn) {
 }
 async function* deserializeFiltered(url, rect, fromFeature2, headerMetaFn) {
   const reader = await HttpReader.open(url);
-  logger_default.debug("opened reader");
+  Logger.debug("opened reader");
   if (headerMetaFn)
     headerMetaFn(reader.header);
   for await (const feature of reader.selectBbox(rect)) {
@@ -1835,9 +1837,11 @@ async function* parseFlatGeobufInBatchesToGeoJSON(stream, options) {
 }
 
 // dist/flatgeobuf-loader.js
-var VERSION = true ? "4.2.0-alpha.4" : "latest";
+var VERSION = true ? "4.2.0-alpha.6" : "latest";
 var FGB_MAGIC_NUMBER = [102, 103, 98, 3, 102, 103, 98, 1];
 var FlatGeobufWorkerLoader = {
+  dataType: null,
+  batchType: null,
   id: "flatgeobuf",
   name: "FlatGeobuf",
   module: "flatgeobuf",