@loaders.gl/pointclouds 5.0.0-beta.1 → 5.0.0-beta.2

package/dist/las-worker.js

@@ -6,23 +6,36 @@
       __defProp(target, name, { get: all[name], enumerable: true });
   };
 
-  // ../core/src/worker-utils/lib/node/worker_threads-browser.ts
+  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/node/worker_threads-browser.js
   var parentPort = null;
 
-  // ../core/src/worker-utils/lib/worker-utils/get-transfer-list.ts
+  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-utils/get-transfer-list.js
   function getTransferList(object, recursive = true, transfers) {
     const transfersSet = transfers || /* @__PURE__ */ new Set();
-    if (!object) {
-    } else if (isTransferable(object)) {
-      transfersSet.add(object);
-    } else if (isTransferable(object.buffer)) {
-      transfersSet.add(object.buffer);
-    } else if (ArrayBuffer.isView(object)) {
-    } else if (recursive && typeof object === "object") {
-      for (const key in object) {
-        getTransferList(object[key], recursive, transfersSet);
-      }
-    }
+    const seen = /* @__PURE__ */ new Set();
+    function visit(value) {
+      if (!value || typeof value !== "object" || seen.has(value))
+        return;
+      seen.add(value);
+      if (isTransferable(value))
+        transfersSet.add(value);
+      else if (ArrayBuffer.isView(value)) {
+        if (isTransferable(value.buffer))
+          transfersSet.add(value.buffer);
+      } else if (recursive && value instanceof Map) {
+        for (const [key, item] of value) {
+          visit(key);
+          visit(item);
+        }
+      } else if (recursive && value instanceof Set) {
+        for (const item of value)
+          visit(item);
+      } else if (recursive) {
+        for (const key of Object.keys(value))
+          visit(value[key]);
+      }
+    }
+    visit(object);
     return transfers === void 0 ? Array.from(transfersSet) : [];
   }
   function isTransferable(object) {
@@ -44,7 +57,7 @@
     return false;
   }
 
-  // ../core/src/worker-utils/lib/worker-farm/worker-body.ts
+  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-farm/worker-body.js
   async function getParentPort() {
     return parentPort;
   }
@@ -52,7 +65,8 @@
   var WorkerBody = class {
     /** Check that we are actually in a worker thread */
     static async inWorkerThread() {
-      return typeof self !== "undefined" || Boolean(await getParentPort());
+      const workerGlobalScope = globalThis.WorkerGlobalScope;
+      return typeof workerGlobalScope === "function" && globalThis instanceof workerGlobalScope || Boolean(await getParentPort());
     }
     /*
      * (type: WorkerMessageType, payload: WorkerMessagePayload) => any
@@ -130,11 +144,8 @@
     return messageData && typeof messageData.source === "string" && messageData.source.startsWith("loaders.gl") ? messageData : null;
   }
 
-  // ../core/src/worker-utils/lib/async-queue/async-queue.ts
+  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/async-queue/async-queue.js
   var AsyncQueue = class {
-    _values;
-    _settlers;
-    _closed;
     constructor() {
       this._values = [];
       this._settlers = [];
@@ -200,8 +211,48 @@
     }
   };
 
-  // ../core/src/worker-utils/lib/worker-api/create-worker.ts
+  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-api/shared-state.js
+  var SharedWorkerState = class {
+    constructor(buffer) {
+      if (typeof SharedArrayBuffer === "undefined" || !(buffer instanceof SharedArrayBuffer) || buffer.byteLength !== 16)
+        throw new Error("Expected a 16-byte shared worker control buffer");
+      this.buffer = buffer;
+      this.values = new Int32Array(buffer);
+    }
+    get snapshot() {
+      return {
+        cancelled: Atomics.load(this.values, 0) !== 0,
+        completed: Atomics.load(this.values, 1),
+        total: Atomics.load(this.values, 2),
+        revision: Atomics.load(this.values, 3)
+      };
+    }
+    cancel() {
+      Atomics.store(this.values, 0, 1);
+      Atomics.add(this.values, 3, 1);
+      Atomics.notify(this.values, 0);
+    }
+    throwIfCancelled() {
+      if (Atomics.load(this.values, 0) !== 0) {
+        const error = new Error("Shared worker task was cancelled");
+        error.name = "AbortError";
+        throw error;
+      }
+    }
+    /** Integer counters for application-defined work; messages still carry phase names and units. */
+    setProgress(completed, total = -1) {
+      if (!Number.isInteger(completed) || completed < 0 || completed > 2147483647 || !Number.isInteger(total) || total < -1 || total > 2147483647) {
+        throw new RangeError("Shared progress requires nonnegative int32 counts (or total -1)");
+      }
+      Atomics.store(this.values, 1, completed);
+      Atomics.store(this.values, 2, total);
+      Atomics.add(this.values, 3, 1);
+    }
+  };
+
+  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-api/create-worker.js
   var requestId = 0;
+  var activeController = null;
   var activeInputBatches = null;
   var activeOutputAcknowledgements = null;
   async function createWorker(process, processInBatches) {
@@ -212,27 +263,56 @@
       process: processOnMainThread
     };
     WorkerBody.onmessage = async (type, payload) => {
+      if (type === "cancel") {
+        activeController?.abort();
+        activeInputBatches?.close();
+        activeOutputAcknowledgements?.close();
+        return;
+      }
+      const controller = type === "process" || type === "process-in-batches" ? new AbortController() : void 0;
+      if (controller)
+        activeController = controller;
+      const startedAt = performance.now();
       const reporter = type === "process" || type === "process-in-batches" ? createProgressReporter() : void 0;
-      const jobContext = { ...context, reportProgress: reporter?.report };
+      let sharedState;
+      const throwIfAborted = () => {
+        controller?.signal.throwIfAborted();
+        sharedState?.throwIfCancelled();
+      };
+      const jobContext = {
+        ...context,
+        signal: controller?.signal,
+        sharedState,
+        throwIfAborted,
+        reportProgress: (progress) => {
+          if (!controller?.signal.aborted && !sharedState?.snapshot.cancelled)
+            reporter?.report(progress);
+        }
+      };
       try {
+        if (controller && payload.options?.["sharedState"]) {
+          sharedState = new SharedWorkerState(payload.options["sharedState"]);
+          jobContext.sharedState = sharedState;
+        }
         switch (type) {
           case "preload":
             WorkerBody.postMessage("done", {});
             break;
           case "process":
+            throwIfAborted();
             if (!process) {
               throw new Error("Worker does not support atomic processing");
             }
-            const result = await process(
-              payload.input,
-              payload.options || {},
-              jobContext,
-              payload.context || {}
-            );
+            const result = await process(payload.input, payload.options || {}, jobContext, payload.context || {});
+            throwIfAborted();
             reporter?.finish();
-            WorkerBody.postMessage("done", { result });
+            await WorkerBody.postMessage("done", {
+              result,
+              executionMs: performance.now() - startedAt
+            });
             break;
           case "process-in-batches":
+            throwIfAborted();
             if (!processInBatches) {
               throw new Error("Worker does not support batched processing");
             }
@@ -241,18 +321,15 @@
             activeInputBatches = inputBatches;
             activeOutputAcknowledgements = outputAcknowledgements;
             try {
-              const resultIterator = processInBatches(
-                createDemandDrivenIterator(inputBatches),
-                payload.options || {},
-                jobContext,
-                payload.context || {}
-              );
+              const resultIterator = processInBatches(createDemandDrivenIterator(inputBatches), payload.options || {}, jobContext, payload.context || {});
               for await (const batch of resultIterator) {
+                throwIfAborted();
                 await WorkerBody.postMessage("output-batch", { result: batch });
                 await outputAcknowledgements.next();
               }
+              throwIfAborted();
               reporter?.finish();
-              await WorkerBody.postMessage("done", {});
+              await WorkerBody.postMessage("done", { executionMs: performance.now() - startedAt });
             } finally {
               activeInputBatches = null;
               activeOutputAcknowledgements = null;
@@ -279,11 +356,18 @@
           default:
         }
       } catch (error) {
-        reporter?.finish();
+        reporter?.finish(controller?.signal.aborted || sharedState?.snapshot.cancelled);
         const message = error instanceof Error ? error.message : "";
-        WorkerBody.postMessage("error", { error: message });
+        await WorkerBody.postMessage("error", {
+          error: message,
+          errorName: error instanceof Error ? error.name : "Error"
+        });
+      } finally {
+        if (controller && activeController === controller)
+          activeController = null;
       }
     };
+    await WorkerBody.postMessage("ready", {});
   }
   async function* createDemandDrivenIterator(inputBatches) {
     while (true) {
@@ -296,27 +380,45 @@
     }
   }
   function processOnMainThread(arrayBuffer, options = {}, jobContext = {}) {
+    const signal = activeController?.signal;
+    signal?.throwIfAborted();
     return new Promise((resolve, reject) => {
       const id = requestId++;
-      const onMessage = (type, payload2) => {
-        if (payload2.id !== id) {
+      const cleanup = () => {
+        signal?.removeEventListener("abort", abort);
+        void WorkerBody.removeEventListener(onMessage);
+      };
+      const abort = () => {
+        cleanup();
+        reject(signal?.reason);
+      };
+      const onMessage = (type, payload) => {
+        if (payload.id !== id)
           return;
-        }
-        switch (type) {
-          case "done":
-            WorkerBody.removeEventListener(onMessage);
-            resolve(payload2.result);
-            break;
-          case "error":
-            WorkerBody.removeEventListener(onMessage);
-            reject(payload2.error);
-            break;
-          default:
+        if (type === "done") {
+          cleanup();
+          resolve(payload.result);
+        } else if (type === "error") {
+          cleanup();
+          reject(payload.error);
         }
       };
-      WorkerBody.addEventListener(onMessage);
-      const payload = { id, input: arrayBuffer, options, context: jobContext };
-      WorkerBody.postMessage("process", payload);
+      void WorkerBody.addEventListener(onMessage).then(async () => {
+        if (signal?.aborted) {
+          abort();
+          return;
+        }
+        signal?.addEventListener("abort", abort, { once: true });
+        await WorkerBody.postMessage("process", {
+          id,
+          input: arrayBuffer,
+          options,
+          context: jobContext
+        });
+      }).catch((error) => {
+        cleanup();
+        reject(error);
+      });
     });
   }
   function createProgressReporter() {
@@ -333,8 +435,10 @@
     return {
       /** Records progress while retaining phase transitions. */
       report(progress) {
-        if (finished) return;
-        if (pending && pending.phase !== progress.phase) flush();
+        if (finished)
+          return;
+        if (pending && pending.phase !== progress.phase)
+          flush();
         pending = { ...progress };
         if (!scheduled) {
           scheduled = true;
@@ -342,13 +446,20 @@
         }
       },
       /** Flushes final progress and suppresses reports from stale callbacks. */
-      finish() {
+      finish(discard = false) {
+        if (discard)
+          pending = void 0;
         flush();
         finished = true;
       }
     };
   }
 
+  // ../../node_modules/@math.gl/core/dist/worker-utils/index.js
+  var import_meta = {};
+  var path = typeof __filename === "string" ? __filename.replace(/\\/g, "/") : "";
+  var moduleUrl = path ? `file://${path.startsWith("/") ? "" : "/"}${encodeURI(path).replace(/#/g, "%23").replace(/\?/g, "%3F")}` : import_meta.url;
+
   // ../core/src/loader-utils/lib/worker-loader-utils/create-loader-worker.ts
   async function createLoaderWorker(loader, selectLoader = () => loader) {
     await createWorker(
@@ -17623,8 +17734,8 @@ return true;`);
       return new JSONVectorLoader(body, header.nodes, header.buffers, this.dictionaries, this.schema.metadataVersion, header.variadicBufferCounts).visitMany(types);
     }
   };
-  function shouldAutoDestroy(self2, options) {
-    return options && typeof options["autoDestroy"] === "boolean" ? options["autoDestroy"] : self2["autoDestroy"];
+  function shouldAutoDestroy(self, options) {
+    return options && typeof options["autoDestroy"] === "boolean" ? options["autoDestroy"] : self["autoDestroy"];
   }
   function* readAllSync(source) {
     const reader = RecordBatchReader.from(source);
@@ -19838,7 +19949,7 @@ return true;`);
   };
 
   // src/las/las-loader-shared.ts
-  var VERSION = true ? "5.0.0-beta.1" : "latest";
+  var VERSION = true ? "5.0.0-beta.2" : "latest";
   var DEFAULT_LAS_SHAPE = "arrow-table";
   function getLASShape(options) {
     return options?.las?.shape || DEFAULT_LAS_SHAPE;