@loaders.gl/core 4.2.0-alpha.4 → 4.2.0-alpha.5

package/dist/dist.dev.js

@@ -2,8 +2,8 @@
   if (typeof exports === 'object' && typeof module === 'object')
     module.exports = factory();
   else if (typeof define === 'function' && define.amd) define([], factory);
-        else if (typeof exports === 'object') exports['loader'] = factory();
-  else root['loader'] = factory();})(globalThis, function () {
+        else if (typeof exports === 'object') exports['loaders'] = factory();
+  else root['loaders'] = factory();})(globalThis, function () {
 "use strict";
 var __exports__ = (() => {
   var __defProp = Object.defineProperty;
@@ -24,9 +24,9 @@ var __exports__ = (() => {
   };
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-  // src/index.ts
-  var src_exports = {};
-  __export(src_exports, {
+  // bundle.ts
+  var bundle_exports = {};
+  __export(bundle_exports, {
     JSONLoader: () => JSONLoader,
     NullLoader: () => NullLoader,
     NullWorkerLoader: () => NullWorkerLoader,
@@ -101,7 +101,10 @@ var __exports__ = (() => {
   var window_ = globals.window || globals.self || globals.global || {};
   var global_ = globals.global || globals.self || globals.window || {};
   var document_ = globals.document || {};
-  var isBrowser = Boolean(typeof process !== "object" || String(process) !== "[object process]" || process.browser);
+  var isBrowser = (
+    // @ts-ignore process does not exist on browser
+    Boolean(typeof process !== "object" || String(process) !== "[object process]" || process.browser)
+  );
   var isWorker = typeof importScripts === "function";
   var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
   var nodeVersion = matches && parseFloat(matches[1]) || 0;
@@ -114,12 +117,14 @@ var __exports__ = (() => {
     if (level > 3) {
       return newOptions;
     }
-    const options = {
-      ...baseOptions
-    };
+    const options = { ...baseOptions };
     for (const [key, newValue] of Object.entries(newOptions)) {
       if (newValue && typeof newValue === "object" && !Array.isArray(newValue)) {
-        options[key] = mergeOptionsRecursively(options[key] || {}, newOptions[key], level + 1);
+        options[key] = mergeOptionsRecursively(
+          options[key] || {},
+          newOptions[key],
+          level + 1
+        );
       } else {
         options[key] = newOptions[key];
       }
@@ -132,11 +137,13 @@ var __exports__ = (() => {
   function getVersion() {
     if (!globalThis._loadersgl_?.version) {
       globalThis._loadersgl_ = globalThis._loadersgl_ || {};
-      if (false) {
-        console.warn("loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN.");
+      if (typeof __VERSION__ === "undefined") {
+        console.warn(
+          "loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN."
+        );
         globalThis._loadersgl_.version = NPM_TAG;
       } else {
-        globalThis._loadersgl_.version = "4.2.0-alpha.4";
+        globalThis._loadersgl_.version = __VERSION__;
       }
     }
     return globalThis._loadersgl_.version;
@@ -161,19 +168,22 @@ var __exports__ = (() => {
   var window_2 = globals2.window || globals2.self || globals2.global || {};
   var global_2 = globals2.global || globals2.self || globals2.window || {};
   var document_2 = globals2.document || {};
-  var isBrowser2 = typeof process !== "object" || String(process) !== "[object process]" || process.browser;
+  var isBrowser2 = (
+    // @ts-ignore process.browser
+    typeof process !== "object" || String(process) !== "[object process]" || process.browser
+  );
   var isMobile = typeof window !== "undefined" && typeof window.orientation !== "undefined";
   var matches2 = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
   var nodeVersion2 = matches2 && parseFloat(matches2[1]) || 0;
 
   // ../worker-utils/src/lib/worker-farm/worker-job.ts
   var WorkerJob = class {
-    isRunning = true;
-    _resolve = () => {
-    };
-    _reject = () => {
-    };
     constructor(jobName, workerThread) {
+      this.isRunning = true;
+      this._resolve = () => {
+      };
+      this._reject = () => {
+      };
       this.name = jobName;
       this.workerThread = workerThread;
       this.result = new Promise((resolve2, reject) => {
@@ -181,18 +191,29 @@ var __exports__ = (() => {
         this._reject = reject;
       });
     }
+    /**
+     * Send a message to the job's worker thread
+     * @param data any data structure, ideally consisting mostly of transferrable objects
+     */
     postMessage(type, payload) {
       this.workerThread.postMessage({
         source: "loaders.gl",
+        // Lets worker ignore unrelated messages
         type,
         payload
       });
     }
+    /**
+     * Call to resolve the `result` Promise with the supplied value
+     */
     done(value) {
       assert2(this.isRunning);
       this.isRunning = false;
       this._resolve(value);
     }
+    /**
+     * Call to reject the `result` Promise with the supplied error
+     */
     error(error) {
       assert2(this.isRunning);
       this.isRunning = false;
@@ -232,9 +253,7 @@ var __exports__ = (() => {
     return getLoadableWorkerURLFromSource(workerSource);
   }
   function getLoadableWorkerURLFromSource(workerSource) {
-    const blob = new Blob([workerSource], {
-      type: "application/javascript"
-    });
+    const blob = new Blob([workerSource], { type: "application/javascript" });
     return URL.createObjectURL(blob);
   }
   function buildScriptSource(workerUrl) {
@@ -301,17 +320,10 @@ var __exports__ = (() => {
   var NOOP = () => {
   };
   var WorkerThread = class {
-    terminated = false;
-    _loadableURL = "";
-    static isSupported() {
-      return typeof Worker !== "undefined" && isBrowser2 || typeof NodeWorker !== "undefined" && !isBrowser2;
-    }
     constructor(props) {
-      const {
-        name,
-        source,
-        url
-      } = props;
+      this.terminated = false;
+      this._loadableURL = "";
+      const { name, source, url } = props;
       assert2(source || url);
       this.name = name;
       this.source = source;
@@ -320,6 +332,14 @@ var __exports__ = (() => {
       this.onError = (error) => console.log(error);
       this.worker = isBrowser2 ? this._createBrowserWorker() : this._createNodeWorker();
     }
+    /** Checks if workers are supported on this platform */
+    static isSupported() {
+      return typeof Worker !== "undefined" && isBrowser2 || typeof NodeWorker !== "undefined" && !isBrowser2;
+    }
+    /**
+     * Terminate this worker thread
+     * @note Can free up significant memory
+     */
     destroy() {
       this.onMessage = NOOP;
       this.onError = NOOP;
@@ -329,10 +349,20 @@ var __exports__ = (() => {
     get isRunning() {
       return Boolean(this.onMessage);
     }
+    /**
+     * Send a message to this worker thread
+     * @param data any data structure, ideally consisting mostly of transferrable objects
+     * @param transferList If not supplied, calculated automatically by traversing data
+     */
     postMessage(data, transferList) {
       transferList = transferList || getTransferList(data);
       this.worker.postMessage(data, transferList);
     }
+    // PRIVATE
+    /**
+     * Generate a standard Error from an ErrorEvent
+     * @param event
+     */
     _getErrorFromErrorEvent(event) {
       let message = "Failed to load ";
       message += `worker ${this.name} from ${this.url}. `;
@@ -344,14 +374,12 @@ var __exports__ = (() => {
       }
       return new Error(message);
     }
+    /**
+     * Creates a worker thread on the browser
+     */
     _createBrowserWorker() {
-      this._loadableURL = getLoadableWorkerURL({
-        source: this.source,
-        url: this.url
-      });
-      const worker = new Worker(this._loadableURL, {
-        name: this.name
-      });
+      this._loadableURL = getLoadableWorkerURL({ source: this.source, url: this.url });
+      const worker = new Worker(this._loadableURL, { name: this.name });
       worker.onmessage = (event) => {
         if (!event.data) {
           this.onError(new Error("No data received"));
@@ -366,18 +394,18 @@ var __exports__ = (() => {
       worker.onmessageerror = (event) => console.error(event);
       return worker;
     }
+    /**
+     * Creates a worker thread in node.js
+     * @todo https://nodejs.org/api/async_hooks.html#async-resource-worker-pool
+     */
     _createNodeWorker() {
       let worker;
       if (this.url) {
         const absolute = this.url.includes(":/") || this.url.startsWith("/");
         const url = absolute ? this.url : `./${this.url}`;
-        worker = new NodeWorker(url, {
-          eval: false
-        });
+        worker = new NodeWorker(url, { eval: false });
       } else if (this.source) {
-        worker = new NodeWorker(this.source, {
-          eval: true
-        });
+        worker = new NodeWorker(this.source, { eval: true });
       } else {
         throw new Error("no worker");
       }
@@ -395,34 +423,40 @@ var __exports__ = (() => {
 
   // ../worker-utils/src/lib/worker-farm/worker-pool.ts
   var WorkerPool = class {
-    name = "unnamed";
-    maxConcurrency = 1;
-    maxMobileConcurrency = 1;
-    onDebug = () => {
-    };
-    reuseWorkers = true;
-    props = {};
-    jobQueue = [];
-    idleQueue = [];
-    count = 0;
-    isDestroyed = false;
-    static isSupported() {
-      return WorkerThread.isSupported();
-    }
+    /**
+     * @param processor - worker function
+     * @param maxConcurrency - max count of workers
+     */
     constructor(props) {
+      this.name = "unnamed";
+      this.maxConcurrency = 1;
+      this.maxMobileConcurrency = 1;
+      this.onDebug = () => {
+      };
+      this.reuseWorkers = true;
+      this.props = {};
+      this.jobQueue = [];
+      this.idleQueue = [];
+      this.count = 0;
+      this.isDestroyed = false;
       this.source = props.source;
       this.url = props.url;
       this.setProps(props);
     }
+    /** Checks if workers are supported on this platform */
+    static isSupported() {
+      return WorkerThread.isSupported();
+    }
+    /**
+     * Terminates all workers in the pool
+     * @note Can free up significant memory
+     */
     destroy() {
       this.idleQueue.forEach((worker) => worker.destroy());
       this.isDestroyed = true;
     }
     setProps(props) {
-      this.props = {
-        ...this.props,
-        ...props
-      };
+      this.props = { ...this.props, ...props };
       if (props.name !== void 0) {
         this.name = props.name;
       }
@@ -441,17 +475,17 @@ var __exports__ = (() => {
     }
     async startJob(name, onMessage3 = (job, type, data) => job.done(data), onError = (job, error) => job.error(error)) {
       const startPromise = new Promise((onStart) => {
-        this.jobQueue.push({
-          name,
-          onMessage: onMessage3,
-          onError,
-          onStart
-        });
+        this.jobQueue.push({ name, onMessage: onMessage3, onError, onStart });
         return this;
       });
       this._startQueuedJob();
       return await startPromise;
     }
+    // PRIVATE
+    /**
+     * Starts first queued job if worker is available or can be created
+     * Called when job is started and whenever a worker returns to the idleQueue
+     */
     async _startQueuedJob() {
       if (!this.jobQueue.length) {
         return;
@@ -481,8 +515,23 @@ var __exports__ = (() => {
         }
       }
     }
+    /**
+     * Returns a worker to the idle queue
+     * Destroys the worker if
+     *  - pool is destroyed
+     *  - if this pool doesn't reuse workers
+     *  - if maxConcurrency has been lowered
+     * @param worker
+     */
     returnWorkerToQueue(worker) {
-      const shouldDestroyWorker = !isBrowser2 || this.isDestroyed || !this.reuseWorkers || this.count > this._getMaxConcurrency();
+      const shouldDestroyWorker = (
+        // Workers on Node.js prevent the process from exiting.
+        // Until we figure out how to close them before exit, we always destroy them
+        !isBrowser2 || // If the pool is destroyed, there is no reason to keep the worker around
+        this.isDestroyed || // If the app has disabled worker reuse, any completed workers should be destroyed
+        !this.reuseWorkers || // If concurrency has been lowered, this worker might be surplus to requirements
+        this.count > this._getMaxConcurrency()
+      );
       if (shouldDestroyWorker) {
         worker.destroy();
         this.count--;
@@ -493,6 +542,9 @@ var __exports__ = (() => {
         this._startQueuedJob();
       }
     }
+    /**
+     * Returns idle worker or creates new worker if maxConcurrency has not been reached
+     */
     _getAvailableWorker() {
       if (this.idleQueue.length > 0) {
         return this.idleQueue.shift() || null;
@@ -500,11 +552,7 @@ var __exports__ = (() => {
       if (this.count < this._getMaxConcurrency()) {
         this.count++;
         const name = `${this.name.toLowerCase()} (#${this.count} of ${this.maxConcurrency})`;
-        return new WorkerThread({
-          name,
-          source: this.source,
-          url: this.url
-        });
+        return new WorkerThread({ name, source: this.source, url: this.url });
       }
       return null;
     }
@@ -522,43 +570,54 @@ var __exports__ = (() => {
     }
   };
   var WorkerFarm = class {
-    workerPools = /* @__PURE__ */ new Map();
+    /** get global instance with WorkerFarm.getWorkerFarm() */
+    constructor(props) {
+      this.workerPools = /* @__PURE__ */ new Map();
+      this.props = { ...DEFAULT_PROPS };
+      this.setProps(props);
+      this.workerPools = /* @__PURE__ */ new Map();
+    }
+    /** Checks if workers are supported on this platform */
     static isSupported() {
       return WorkerThread.isSupported();
     }
+    /** Get the singleton instance of the global worker farm */
     static getWorkerFarm(props = {}) {
       WorkerFarm._workerFarm = WorkerFarm._workerFarm || new WorkerFarm({});
       WorkerFarm._workerFarm.setProps(props);
       return WorkerFarm._workerFarm;
     }
-    constructor(props) {
-      this.props = {
-        ...DEFAULT_PROPS
-      };
-      this.setProps(props);
-      this.workerPools = /* @__PURE__ */ new Map();
-    }
+    /**
+     * Terminate all workers in the farm
+     * @note Can free up significant memory
+     */
     destroy() {
       for (const workerPool of this.workerPools.values()) {
         workerPool.destroy();
       }
       this.workerPools = /* @__PURE__ */ new Map();
     }
+    /**
+     * Set props used when initializing worker pools
+     * @param props
+     */
     setProps(props) {
-      this.props = {
-        ...this.props,
-        ...props
-      };
+      this.props = { ...this.props, ...props };
       for (const workerPool of this.workerPools.values()) {
         workerPool.setProps(this._getWorkerPoolProps());
       }
     }
+    /**
+     * Returns a worker pool for the specified worker
+     * @param options - only used first time for a specific worker name
+     * @param options.name - the name of the worker - used to identify worker pool
+     * @param options.url -
+     * @param options.source -
+     * @example
+     *   const job = WorkerFarm.getWorkerFarm().getWorkerPool({name, url}).startJob(...);
+     */
     getWorkerPool(options) {
-      const {
-        name,
-        source,
-        url
-      } = options;
+      const { name, source, url } = options;
       let workerPool = this.workerPools.get(name);
       if (!workerPool) {
         workerPool = new WorkerPool({
@@ -616,24 +675,20 @@ var __exports__ = (() => {
   async function processOnWorker(worker, data, options = {}, context = {}) {
     const name = getWorkerName(worker);
     const workerFarm = WorkerFarm.getWorkerFarm(options);
-    const {
-      source
-    } = options;
-    const workerPoolProps = {
-      name,
-      source
-    };
+    const { source } = options;
+    const workerPoolProps = { name, source };
     if (!source) {
       workerPoolProps.url = getWorkerURL(worker, options);
     }
     const workerPool = workerFarm.getWorkerPool(workerPoolProps);
     const jobName = options.jobName || worker.name;
-    const job = await workerPool.startJob(jobName, onMessage.bind(null, context));
+    const job = await workerPool.startJob(
+      jobName,
+      // eslint-disable-next-line
+      onMessage.bind(null, context)
+    );
     const transferableOptions = getTransferListForWriter(options);
-    job.postMessage("process", {
-      input: data,
-      options: transferableOptions
-    });
+    job.postMessage("process", { input: data, options: transferableOptions });
     const result = await job.result;
     return result.result;
   }
@@ -646,30 +701,17 @@ var __exports__ = (() => {
         job.error(new Error(payload.error));
         break;
       case "process":
-        const {
-          id,
-          input,
-          options
-        } = payload;
+        const { id, input, options } = payload;
         try {
           if (!context.process) {
-            job.postMessage("error", {
-              id,
-              error: "Worker not set up to process on main thread"
-            });
+            job.postMessage("error", { id, error: "Worker not set up to process on main thread" });
             return;
           }
           const result = await context.process(input, options);
-          job.postMessage("done", {
-            id,
-            result
-          });
+          job.postMessage("done", { id, result });
         } catch (error) {
           const message = error instanceof Error ? error.message : "unknown error";
-          job.postMessage("error", {
-            id,
-            error: message
-          });
+          job.postMessage("error", { id, error: message });
         }
         break;
       default:
@@ -701,14 +743,17 @@ var __exports__ = (() => {
     const name = loader.id;
     const url = getWorkerURL(loader, options);
     const workerFarm = WorkerFarm.getWorkerFarm(options);
-    const workerPool = workerFarm.getWorkerPool({
-      name,
-      url
-    });
+    const workerPool = workerFarm.getWorkerPool({ name, url });
     options = JSON.parse(JSON.stringify(options));
     context = JSON.parse(JSON.stringify(context || {}));
-    const job = await workerPool.startJob("process-on-worker", onMessage2.bind(null, parseOnMainThread));
+    const job = await workerPool.startJob(
+      "process-on-worker",
+      // @ts-expect-error
+      onMessage2.bind(null, parseOnMainThread)
+      // eslint-disable-line @typescript-eslint/no-misused-promises
+    );
     job.postMessage("process", {
+      // @ts-ignore
       input: data,
       options,
       context
@@ -725,23 +770,13 @@ var __exports__ = (() => {
         job.error(new Error(payload.error));
         break;
       case "process":
-        const {
-          id,
-          input,
-          options
-        } = payload;
+        const { id, input, options } = payload;
         try {
           const result = await parseOnMainThread(input, options);
-          job.postMessage("done", {
-            id,
-            result
-          });
+          job.postMessage("done", { id, result });
         } catch (error) {
           const message = error instanceof Error ? error.message : "unknown error";
-          job.postMessage("error", {
-            id,
-            error: message
-          });
+          job.postMessage("error", { id, error: message });
         }
         break;
       default:
@@ -779,7 +814,9 @@ var __exports__ = (() => {
     return concatenateArrayBuffersFromArray(sources);
   }
   function concatenateArrayBuffersFromArray(sources) {
-    const sourceArrays = sources.map((source2) => source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2);
+    const sourceArrays = sources.map(
+      (source2) => source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2
+    );
     const byteLength = sourceArrays.reduce((length, typedArray) => length + typedArray.byteLength, 0);
     const result = new Uint8Array(byteLength);
     let offset = 0;
@@ -794,9 +831,7 @@ var __exports__ = (() => {
   async function* makeTextDecoderIterator(arrayBufferIterator, options = {}) {
     const textDecoder = new TextDecoder(void 0, options);
     for await (const arrayBuffer of arrayBufferIterator) {
-      yield typeof arrayBuffer === "string" ? arrayBuffer : textDecoder.decode(arrayBuffer, {
-        stream: true
-      });
+      yield typeof arrayBuffer === "string" ? arrayBuffer : textDecoder.decode(arrayBuffer, { stream: true });
     }
   }
   async function* makeTextEncoderIterator(textIterator) {
@@ -823,10 +858,7 @@ var __exports__ = (() => {
   async function* makeNumberedLineIterator(lineIterator) {
     let counter = 1;
     for await (const line of lineIterator) {
-      yield {
-        counter,
-        line
-      };
+      yield { counter, line };
       counter++;
     }
   }
@@ -834,10 +866,7 @@ var __exports__ = (() => {
   // ../loader-utils/src/lib/iterators/async-iteration.ts
   async function forEach(iterator, visitor) {
     while (true) {
-      const {
-        done,
-        value
-      } = await iterator.next();
+      const { done, value } = await iterator.next();
       if (done) {
         iterator.return();
         return;
@@ -1101,43 +1130,56 @@ var __exports__ = (() => {
   var STAT_ACTIVE_REQUESTS_EVER = "Active Requests Ever";
   var DEFAULT_PROPS2 = {
     id: "request-scheduler",
+    /** Specifies if the request scheduler should throttle incoming requests, mainly for comparative testing. */
     throttleRequests: true,
-    maxRequests: 6
+    /** The maximum number of simultaneous active requests. Un-throttled requests do not observe this limit. */
+    maxRequests: 6,
+    /**
+     * Specifies a debounce time, in milliseconds. All requests are queued, until no new requests have
+     * been added to the queue for this amount of time.
+     */
+    debounceTime: 0
   };
   var RequestScheduler = class {
-    activeRequestCount = 0;
-    requestQueue = [];
-    requestMap = /* @__PURE__ */ new Map();
-    deferredUpdate = null;
     constructor(props = {}) {
-      this.props = {
-        ...DEFAULT_PROPS2,
-        ...props
-      };
-      this.stats = new Stats({
-        id: this.props.id
-      });
+      this.activeRequestCount = 0;
+      /** Tracks the number of active requests and prioritizes/cancels queued requests. */
+      this.requestQueue = [];
+      this.requestMap = /* @__PURE__ */ new Map();
+      this.updateTimer = null;
+      this.props = { ...DEFAULT_PROPS2, ...props };
+      this.stats = new Stats({ id: this.props.id });
       this.stats.get(STAT_QUEUED_REQUESTS);
       this.stats.get(STAT_ACTIVE_REQUESTS);
       this.stats.get(STAT_CANCELLED_REQUESTS);
       this.stats.get(STAT_QUEUED_REQUESTS_EVER);
       this.stats.get(STAT_ACTIVE_REQUESTS_EVER);
     }
+    /**
+     * Called by an application that wants to issue a request, without having it deeply queued by the browser
+     *
+     * When the returned promise resolved, it is OK for the application to issue a request.
+     * The promise resolves to an object that contains a `done` method.
+     * When the application's request has completed (or failed), the application must call the `done` function
+     *
+     * @param handle
+     * @param getPriority will be called when request "slots" open up,
+     *    allowing the caller to update priority or cancel the request
+     *    Highest priority executes first, priority < 0 cancels the request
+     * @returns a promise
+     *   - resolves to a object (with a `done` field) when the request can be issued without queueing,
+     *   - resolves to `null` if the request has been cancelled (by the callback return < 0).
+     *     In this case the application should not issue the request
+     */
     scheduleRequest(handle, getPriority = () => 0) {
       if (!this.props.throttleRequests) {
-        return Promise.resolve({
-          done: () => {
-          }
-        });
+        return Promise.resolve({ done: () => {
+        } });
       }
       if (this.requestMap.has(handle)) {
         return this.requestMap.get(handle);
       }
-      const request = {
-        handle,
-        priority: 0,
-        getPriority
-      };
+      const request = { handle, priority: 0, getPriority };
       const promise = new Promise((resolve2) => {
         request.resolve = resolve2;
         return request;
@@ -1147,11 +1189,9 @@ var __exports__ = (() => {
       this._issueNewRequests();
       return promise;
     }
+    // PRIVATE
     _issueRequest(request) {
-      const {
-        handle,
-        resolve: resolve2
-      } = request;
+      const { handle, resolve: resolve2 } = request;
       let isDone = false;
       const done = () => {
         if (!isDone) {
@@ -1162,19 +1202,21 @@ var __exports__ = (() => {
         }
       };
       this.activeRequestCount++;
-      return resolve2 ? resolve2({
-        done
-      }) : Promise.resolve({
-        done
-      });
+      return resolve2 ? resolve2({ done }) : Promise.resolve({ done });
     }
+    /** We check requests asynchronously, to prevent multiple updates */
     _issueNewRequests() {
-      if (!this.deferredUpdate) {
-        this.deferredUpdate = setTimeout(() => this._issueNewRequestsAsync(), 0);
+      if (this.updateTimer !== null) {
+        clearTimeout(this.updateTimer);
       }
+      this.updateTimer = setTimeout(() => this._issueNewRequestsAsync(), this.props.debounceTime);
     }
+    /** Refresh all requests  */
     _issueNewRequestsAsync() {
-      this.deferredUpdate = null;
+      if (this.updateTimer !== null) {
+        clearTimeout(this.updateTimer);
+      }
+      this.updateTimer = null;
       const freeSlots = Math.max(this.props.maxRequests - this.activeRequestCount, 0);
       if (freeSlots === 0) {
         return;
@@ -1187,6 +1229,7 @@ var __exports__ = (() => {
         }
       }
     }
+    /** Ensure all requests have updated priorities, and that no longer valid requests are cancelled */
     _updateAllRequests() {
       const requestQueue = this.requestQueue;
       for (let i = 0; i < requestQueue.length; ++i) {
@@ -1199,6 +1242,7 @@ var __exports__ = (() => {
       }
       requestQueue.sort((a, b) => a.priority - b.priority);
     }
+    /** Update a single request by calling the callback */
     _updateRequest(request) {
       request.priority = request.getPriority(request.handle);
       if (request.priority < 0) {
@@ -1232,7 +1276,7 @@ var __exports__ = (() => {
   }
 
   // ../loader-utils/src/json-loader.ts
-  var VERSION2 = true ? "4.2.0-alpha.4" : "latest";
+  var VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
   var JSONLoader = {
     name: "JSON",
     id: "json",
@@ -1452,10 +1496,10 @@ var __exports__ = (() => {
   // ../loader-utils/src/lib/files/node-file-facade.ts
   var NOT_IMPLEMENTED = new Error("Not implemented");
   var NodeFileFacade = class {
-    size = 0;
-    bigsize = 0n;
-    url = "";
     constructor(url, flags, mode) {
+      this.size = 0;
+      this.bigsize = 0n;
+      this.url = "";
       if (globalThis.loaders?.NodeFile) {
         return new globalThis.loaders.NodeFile(url, flags, mode);
       }
@@ -1464,21 +1508,27 @@ var __exports__ = (() => {
       }
       throw new Error("Can't instantiate NodeFile. Make sure to import @loaders.gl/polyfills first.");
     }
+    /** Read data */
     async read(start, end) {
       throw NOT_IMPLEMENTED;
     }
+    /** Write to file. The number of bytes written will be returned */
     async write(arrayBuffer, offset, length) {
       throw NOT_IMPLEMENTED;
     }
+    /** Get information about file */
     async stat() {
       throw NOT_IMPLEMENTED;
     }
+    /** Truncates the file descriptor. Only available on NodeFile. */
     async truncate(length) {
       throw NOT_IMPLEMENTED;
     }
+    /** Append data to a file. Only available on NodeFile. */
     async append(data) {
       throw NOT_IMPLEMENTED;
     }
+    /** Close the file */
     async close() {
     }
   };
@@ -1604,12 +1654,8 @@ var __exports__ = (() => {
     if (typeof resource === "string") {
       resource = new TextEncoder().encode(resource);
     }
-    const response = new Response(resource, {
-      headers
-    });
-    Object.defineProperty(response, "url", {
-      value: url
-    });
+    const response = new Response(resource, { headers });
+    Object.defineProperty(response, "url", { value: url });
     return response;
   }
   async function checkResponse(response) {
@@ -2230,9 +2276,7 @@ var __exports__ = (() => {
   });
 
   // src/lib/loader-utils/loggers.ts
-  var probeLog = new Log({
-    id: "loaders.gl"
-  });
+  var probeLog = new Log({ id: "loaders.gl" });
   var NullLog = class {
     log() {
       return () => {
@@ -2271,29 +2315,39 @@ var __exports__ = (() => {
 
   // src/lib/loader-utils/option-defaults.ts
   var DEFAULT_LOADER_OPTIONS = {
+    // baseUri
     fetch: null,
     mimeType: void 0,
     nothrow: false,
     log: new ConsoleLog(),
+    // A probe.gl compatible (`log.log()()` syntax) that just logs to console
     useLocalLibraries: false,
     CDN: "https://unpkg.com/@loaders.gl",
     worker: true,
+    // By default, use worker if provided by loader.
     maxConcurrency: 3,
+    // How many worker instances should be created for each loader.
     maxMobileConcurrency: 1,
+    // How many worker instances should be created for each loader on mobile devices.
     reuseWorkers: isBrowser,
+    // By default reuse workers in browser (Node.js refuses to terminate if browsers are running)
     _nodeWorkers: false,
+    // By default do not support node workers
     _workerType: "",
+    // 'test' to use locally generated workers
     limit: 0,
     _limitMB: 0,
     batchSize: "auto",
     batchDebounceMs: 0,
     metadata: false,
+    // TODO - currently only implemented for parseInBatches, adds initial metadata batch,
     transforms: []
   };
   var REMOVED_LOADER_OPTIONS = {
     throws: "nothrow",
     dataType: "(no longer used)",
     uri: "baseUri",
+    // Warn if fetch options are used on top-level
     method: "fetch.method",
     headers: "fetch.headers",
     body: "fetch.body",
@@ -2311,17 +2365,15 @@ var __exports__ = (() => {
   // src/lib/loader-utils/option-utils.ts
   function getGlobalLoaderState() {
     globalThis.loaders = globalThis.loaders || {};
-    const {
-      loaders
-    } = globalThis;
-    loaders._state = loaders._state || {};
+    const { loaders } = globalThis;
+    if (!loaders._state) {
+      loaders._state = {};
+    }
     return loaders._state;
   }
   function getGlobalLoaderOptions() {
     const state = getGlobalLoaderState();
-    state.globalOptions = state.globalOptions || {
-      ...DEFAULT_LOADER_OPTIONS
-    };
+    state.globalOptions = state.globalOptions || { ...DEFAULT_LOADER_OPTIONS };
     return state.globalOptions;
   }
   function setGlobalOptions(options) {
@@ -2353,10 +2405,14 @@ var __exports__ = (() => {
       const isWorkerUrlOption = key === "workerUrl" && id;
       if (!(key in defaultOptions) && !isBaseUriOption && !isWorkerUrlOption) {
         if (key in deprecatedOptions) {
-          probeLog.warn(`${loaderName} loader option '${prefix}${key}' no longer supported, use '${deprecatedOptions[key]}'`)();
+          probeLog.warn(
+            `${loaderName} loader option '${prefix}${key}' no longer supported, use '${deprecatedOptions[key]}'`
+          )();
         } else if (!isSubOptions) {
           const suggestion = findSimilarOption(key, loaders);
-          probeLog.warn(`${loaderName} loader option '${prefix}${key}' not recognized. ${suggestion}`)();
+          probeLog.warn(
+            `${loaderName} loader option '${prefix}${key}' not recognized. ${suggestion}`
+          )();
         }
       }
     }
@@ -2380,9 +2436,7 @@ var __exports__ = (() => {
   }
   function normalizeOptionsInternal(loader, options, url) {
     const loaderDefaultOptions = loader.options || {};
-    const mergedOptions = {
-      ...loaderDefaultOptions
-    };
+    const mergedOptions = { ...loaderDefaultOptions };
     addUrlOptions(mergedOptions, url);
     if (mergedOptions.log === null) {
       mergedOptions.log = new NullLog();
@@ -2432,10 +2486,7 @@ var __exports__ = (() => {
       loader = loader[0];
       loader = {
         ...loader,
-        options: {
-          ...loader.options,
-          ...options
-        }
+        options: { ...loader.options, ...options }
       };
     }
     if (loader?.parseTextSync || loader?.parseText) {
@@ -2472,9 +2523,7 @@ var __exports__ = (() => {
   }
 
   // src/lib/utils/log.ts
-  var log = new Log({
-    id: "loaders.gl"
-  });
+  var log = new Log({ id: "loaders.gl" });
 
   // src/lib/api/select-loader.ts
   var EXT_PATTERN = /\.([^.]+)$/;
@@ -2482,10 +2531,7 @@ var __exports__ = (() => {
     if (!validHTTPResponse(data)) {
       return null;
     }
-    let loader = selectLoaderSync(data, loaders, {
-      ...options,
-      nothrow: true
-    }, context);
+    let loader = selectLoaderSync(data, loaders, { ...options, nothrow: true }, context);
     if (loader) {
       return loader;
     }
@@ -2682,9 +2728,7 @@ var __exports__ = (() => {
   // src/iterators/make-iterator/make-array-buffer-iterator.ts
   var DEFAULT_CHUNK_SIZE2 = 256 * 1024;
   function* makeArrayBufferIterator(arrayBuffer, options = {}) {
-    const {
-      chunkSize = DEFAULT_CHUNK_SIZE2
-    } = options;
+    const { chunkSize = DEFAULT_CHUNK_SIZE2 } = options;
     let byteOffset = 0;
     while (byteOffset < arrayBuffer.byteLength) {
       const chunkByteLength = Math.min(arrayBuffer.byteLength - byteOffset, chunkSize);
@@ -2723,10 +2767,7 @@ var __exports__ = (() => {
         if (options?._streamReadAhead) {
           nextBatchPromise = reader.read();
         }
-        const {
-          done,
-          value
-        } = await currentBatchPromise;
+        const { done, value } = await currentBatchPromise;
         if (done) {
           return;
         }
@@ -2922,11 +2963,12 @@ var __exports__ = (() => {
       return null;
     }
     options = normalizeOptions(options, loader, candidateLoaders, url);
-    context = getLoaderContext({
-      url,
-      _parse: parse,
-      loaders: candidateLoaders
-    }, options, context || null);
+    context = getLoaderContext(
+      // @ts-expect-error
+      { url, _parse: parse, loaders: candidateLoaders },
+      options,
+      context || null
+    );
     return await parseWithLoader(loader, data, options, context);
   }
   async function parseWithLoader(loader, data, options, context) {
@@ -2934,24 +2976,9 @@ var __exports__ = (() => {
     options = mergeLoaderOptions(loader.options, options);
     if (isResponse(data)) {
       const response = data;
-      const {
-        ok,
-        redirected,
-        status,
-        statusText,
-        type,
-        url
-      } = response;
+      const { ok, redirected, status, statusText, type, url } = response;
       const headers = Object.fromEntries(response.headers.entries());
-      context.response = {
-        headers,
-        ok,
-        redirected,
-        status,
-        statusText,
-        type,
-        url
-      };
+      context.response = { headers, ok, redirected, status, statusText, type, url };
     }
     data = await getArrayBufferOrStringFromData(data, loader, options);
     const loaderWithParser = loader;
@@ -2990,12 +3017,11 @@ var __exports__ = (() => {
     const parse2 = () => {
       throw new Error("parseSync called parse (which is async");
     };
-    context = getLoaderContext({
-      url,
-      _parseSync: parse2,
-      _parse: parse2,
-      loaders
-    }, options, context || null);
+    context = getLoaderContext(
+      { url, _parseSync: parse2, _parse: parse2, loaders },
+      options,
+      context || null
+    );
     return parseWithLoaderSync(loader, data, options, context);
   }
   function parseWithLoaderSync(loader, data, options, context) {
@@ -3006,7 +3032,9 @@ var __exports__ = (() => {
     if (loader.parseSync && data instanceof ArrayBuffer) {
       return loader.parseSync(data, options, context);
     }
-    throw new Error(`${loader.name} loader: 'parseSync' not supported by this loader, use 'parse' instead. ${context.url || ""}`);
+    throw new Error(
+      `${loader.name} loader: 'parseSync' not supported by this loader, use 'parse' instead. ${context.url || ""}`
+    );
   }
 
   // ../schema/src/lib/table/simple-table/table-accessors.ts
@@ -3048,11 +3076,7 @@ var __exports__ = (() => {
 
   // ../schema/src/lib/table/simple-table/make-table-from-batches.ts
   function makeBatchFromTable(table) {
-    return {
-      ...table,
-      length: getTableLength(table),
-      batchType: "data"
-    };
+    return { ...table, length: getTableLength(table), batchType: "data" };
   }
 
   // src/lib/api/parse-in-batches.ts
@@ -3071,12 +3095,11 @@ var __exports__ = (() => {
       return [];
     }
     options = normalizeOptions(options, loader, loaderArray, url);
-    context = getLoaderContext({
-      url,
-      _parseInBatches: parseInBatches,
-      _parse: parse,
-      loaders: loaderArray
-    }, options, context || null);
+    context = getLoaderContext(
+      { url, _parseInBatches: parseInBatches, _parse: parse, loaders: loaderArray },
+      options,
+      context || null
+    );
     return await parseWithLoaderInBatches(loader, data, options, context);
   }
   async function parseWithLoaderInBatches(loader, data, options, context) {
@@ -3091,6 +3114,7 @@ var __exports__ = (() => {
         _loader: loader,
         _context: context
       },
+      // Populate with some default fields to avoid crashing
       data: [],
       bytesUsed: 0
     };
@@ -3110,10 +3134,13 @@ var __exports__ = (() => {
   }
   async function* parseChunkInBatches(transformedIterator, loader, options, context) {
     const arrayBuffer = await concatenateArrayBuffersAsync(transformedIterator);
-    const parsedData = await parse(arrayBuffer, loader, {
-      ...options,
-      mimeType: loader.mimeTypes[0]
-    }, context);
+    const parsedData = await parse(
+      arrayBuffer,
+      loader,
+      // TODO - Hack: supply loaders MIME type to ensure we match it
+      { ...options, mimeType: loader.mimeTypes[0] },
+      context
+    );
     const batch = convertDataToBatch(parsedData, loader);
     yield batch;
   }
@@ -3172,7 +3199,9 @@ var __exports__ = (() => {
     if (!Array.isArray(files)) {
       return loadOneFileInBatches(files, loadersArray, options || {}, fetch2);
     }
-    const promises = files.map((file) => loadOneFileInBatches(file, loadersArray, options || {}, fetch2));
+    const promises = files.map(
+      (file) => loadOneFileInBatches(file, loadersArray, options || {}, fetch2)
+    );
     return promises;
   }
   async function loadOneFileInBatches(file, loaders, options, fetch2) {
@@ -3221,21 +3250,14 @@ var __exports__ = (() => {
     throw new Error("Writer could not encode data in batches");
   }
   function getIterator(data) {
-    const dataIterator = [{
-      ...data,
-      start: 0,
-      end: data.length
-    }];
+    const dataIterator = [{ ...data, start: 0, end: data.length }];
     return dataIterator;
   }
 
   // src/lib/api/encode.ts
   async function encode(data, writer, options) {
     const globalOptions = getGlobalLoaderOptions();
-    options = {
-      ...globalOptions,
-      ...options
-    };
+    options = { ...globalOptions, ...options };
     if (writer.encodeURLtoURL) {
       return encodeWithCommandLineTool(writer, data, options);
     }
@@ -3305,11 +3327,7 @@ var __exports__ = (() => {
     return response.arrayBuffer();
   }
   function getIterator2(data) {
-    const dataIterator = [{
-      ...data,
-      start: 0,
-      end: data.length
-    }];
+    const dataIterator = [{ ...data, start: 0, end: data.length }];
     return dataIterator;
   }
   function getTemporaryFilename(filename2) {
@@ -3322,34 +3340,40 @@ var __exports__ = (() => {
       return globalThis.loaders.makeNodeStream(source, options);
     }
     const iterator = source[Symbol.asyncIterator] ? source[Symbol.asyncIterator]() : source[Symbol.iterator]();
-    return new ReadableStream({
-      type: "bytes",
-      async pull(controller) {
-        try {
-          const {
-            done,
-            value
-          } = await iterator.next();
-          if (done) {
-            controller.close();
-          } else {
-            controller.enqueue(new Uint8Array(value));
+    return new ReadableStream(
+      {
+        // Create a byte stream (enables `Response(stream).arrayBuffer()`)
+        // Only supported on Chrome
+        // See: https://developer.mozilla.org/en-US/docs/Web/API/ReadableByteStreamController
+        // @ts-ignore
+        type: "bytes",
+        async pull(controller) {
+          try {
+            const { done, value } = await iterator.next();
+            if (done) {
+              controller.close();
+            } else {
+              controller.enqueue(new Uint8Array(value));
+            }
+          } catch (error) {
+            controller.error(error);
           }
-        } catch (error) {
-          controller.error(error);
+        },
+        async cancel() {
+          await iterator?.return?.();
         }
       },
-      async cancel() {
-        await iterator?.return?.();
+      // options: QueingStrategy<Uint8Array>
+      {
+        // This is bytes, not chunks
+        highWaterMark: 2 ** 24,
+        ...options
       }
-    }, {
-      highWaterMark: 2 ** 24,
-      ...options
-    });
+    );
   }
 
   // src/null-loader.ts
-  var VERSION4 = true ? "4.2.0-alpha.4" : "latest";
+  var VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
   var NullWorkerLoader = {
     name: "Null loader",
     id: "null",
@@ -3416,10 +3440,7 @@ var __exports__ = (() => {
   }
   async function read(controller, reader, loadedBytes, totalBytes, onProgress, onDone, onError) {
     try {
-      const {
-        done,
-        value
-      } = await reader.read();
+      const { done, value } = await reader.read();
       if (done) {
         onDone();
         controller.close();
@@ -3427,10 +3448,7 @@ var __exports__ = (() => {
       }
       loadedBytes += value.byteLength;
       const percent = Math.round(loadedBytes / totalBytes * 100);
-      onProgress(percent, {
-        loadedBytes,
-        totalBytes
-      });
+      onProgress(percent, { loadedBytes, totalBytes });
       controller.enqueue(value);
       await read(controller, reader, loadedBytes, totalBytes, onProgress, onDone, onError);
     } catch (error) {
@@ -3441,10 +3459,15 @@ var __exports__ = (() => {
 
   // src/lib/filesystems/browser-filesystem.ts
   var BrowserFileSystem = class {
-    files = {};
-    lowerCaseFiles = {};
-    usedFiles = {};
+    /**
+     * A FileSystem API wrapper around a list of browser 'File' objects
+     * @param files
+     * @param options
+     */
     constructor(files, options) {
+      this.files = {};
+      this.lowerCaseFiles = {};
+      this.usedFiles = {};
       this._fetch = options?.fetch || fetch;
       for (let i = 0; i < files.length; ++i) {
         const file = files[i];
@@ -3454,16 +3477,18 @@ var __exports__ = (() => {
       }
       this.fetch = this.fetch.bind(this);
     }
+    // implements IFileSystem
+    /**
+     * Implementation of fetch against this file system
+     * Delegates to global fetch for http{s}:// or data://
+     */
     async fetch(path, options) {
       if (path.includes("://")) {
         return this._fetch(path, options);
       }
       const file = this.files[path];
       if (!file) {
-        return new Response(path, {
-          status: 400,
-          statusText: "NOT FOUND"
-        });
+        return new Response(path, { status: 400, statusText: "NOT FOUND" });
       }
       const headers = new Headers(options?.headers);
       const range = headers.get("Range");
@@ -3473,17 +3498,18 @@ var __exports__ = (() => {
         const end = parseInt(bytes[2]);
         const data = await file.slice(start, end).arrayBuffer();
         const response2 = new Response(data);
-        Object.defineProperty(response2, "url", {
-          value: path
-        });
+        Object.defineProperty(response2, "url", { value: path });
         return response2;
       }
       const response = new Response(file);
-      Object.defineProperty(response, "url", {
-        value: path
-      });
+      Object.defineProperty(response, "url", { value: path });
       return response;
     }
+    /**
+     * List filenames in this filesystem
+     * @param dirname
+     * @returns
+     */
     async readdir(dirname2) {
       const files = [];
       for (const path in this.files) {
@@ -3491,23 +3517,31 @@ var __exports__ = (() => {
       }
       return files;
     }
+    /**
+     * Return information (size) about files in this file system
+     */
     async stat(path, options) {
       const file = this.files[path];
       if (!file) {
         throw new Error(path);
       }
-      return {
-        size: file.size
-      };
+      return { size: file.size };
     }
+    /**
+     * Just removes the file from the list
+     */
     async unlink(path) {
       delete this.files[path];
       delete this.lowerCaseFiles[path];
       this.usedFiles[path] = true;
     }
+    // implements IRandomAccessFileSystem
+    // RANDOM ACCESS
     async openReadableFile(pathname, flags) {
       return new BlobFile(this.files[pathname]);
     }
+    // PRIVATE
+    // Supports case independent paths, and file usage tracking
     _getFile(path, used) {
       const file = this.files[path] || this.lowerCaseFiles[path];
       if (file && used) {
@@ -3516,7 +3550,7 @@ var __exports__ = (() => {
       return file;
     }
   };
-  return __toCommonJS(src_exports);
+  return __toCommonJS(bundle_exports);
 })();
       return __exports__;
       });