@loaders.gl/core 5.0.0-alpha.1 → 5.0.0-alpha.2

package/LICENSE

@@ -24,8 +24,20 @@ THE SOFTWARE.
 
 Copyright (c) 2015 Uber Technologies, Inc.
 
-loaders.gl includes certain files from Cesium (https://github.com/AnalyticalGraphicsInc/cesium) 
-under the  Apache 2 License (found in the submodule: modules/3d-tiles):)
+Portions of modules/images/src/lib/category-api/binary-image-api.ts are based on
+binary-gltf-utils (https://github.com/Qantas94Heavy/binary-gltf-utils) under the
+MIT License reproduced above.
+
+Copyright (c) 2016-17 Karl Cheng
+
+Portions of modules/schema-utils/src/lib/utils/async-queue.ts are adapted from
+async-iter-demo (https://github.com/rauschma/async-iter-demo) under the MIT
+License reproduced above.
+
+Copyright (c) 2016 Axel Rauschmayer
+
+loaders.gl includes certain files from Cesium (https://github.com/CesiumGS/cesium)
+under the Apache 2.0 License, including files in modules/3d-tiles and modules/math.
 
 Copyright 2011-2018 CesiumJS Contributors
 
@@ -38,4 +50,3 @@ Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and limitations under the License.
-

package/dist/dist.dev.js

@@ -10,7 +10,6 @@ var __exports__ = (() => {
   var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   var __getOwnPropNames = Object.getOwnPropertyNames;
   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 });
@@ -24,10 +23,6 @@ var __exports__ = (() => {
     return to;
   };
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-  var __publicField = (obj, key, value) => {
-    __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-    return value;
-  };
 
   // bundle.ts
   var bundle_exports = {};
@@ -686,7 +681,7 @@ var __exports__ = (() => {
     }
     const options = { ...baseOptions };
     for (const [key, newValue] of Object.entries(newOptions)) {
-      if (newValue && typeof newValue === "object" && !Array.isArray(newValue)) {
+      if (isPureObject(newValue)) {
         options[key] = mergeOptionsRecursively(
           options[key] || {},
           newOptions[key],
@@ -784,7 +779,9 @@ var __exports__ = (() => {
      * Call to resolve the `result` Promise with the supplied value
      */
     done(value) {
-      assert3(this.isRunning);
+      if (!this.isRunning) {
+        return;
+      }
       this.isRunning = false;
       this._resolve(value);
     }
@@ -792,14 +789,35 @@ var __exports__ = (() => {
      * Call to reject the `result` Promise with the supplied error
      */
     error(error) {
-      assert3(this.isRunning);
+      if (!this.isRunning) {
+        return;
+      }
       this.isRunning = false;
       this._reject(error);
     }
+    /** Terminates the worker executing this job and rejects its result with an abort error. */
+    abort() {
+      if (!this.isRunning) {
+        return;
+      }
+      const error = new Error(`Worker job "${this.name}" was aborted`);
+      error.name = "AbortError";
+      this.workerThread.destroy();
+      this.error(error);
+    }
   };
 
   // ../worker-utils/src/lib/node/worker_threads-browser.ts
   var NodeWorker = class {
+    /** Restores the native worker constructor when this browser shim is embedded in a Node bundle. */
+    constructor(...arguments_) {
+      const runtimeProcess = globalThis.process;
+      const WorkerConstructor = runtimeProcess?.getBuiltinModule?.("node:worker_threads").Worker;
+      if (WorkerConstructor) {
+        return new WorkerConstructor(...arguments_);
+      }
+    }
+    /** No-op browser fallback matching the native Worker API. */
     terminate() {
     }
   };
@@ -998,8 +1016,9 @@ var __exports__ = (() => {
       if (this.url) {
         const absolute = this.url.includes(":/") || this.url.startsWith("/");
         const url = absolute ? this.url : `./${this.url}`;
+        const workerUrl = url.startsWith("file:") ? new URL(url) : url;
         const type = this.url.endsWith(".ts") || this.url.endsWith(".mjs") ? "module" : "commonjs";
-        worker = new NodeWorker(url, { eval: false, type });
+        worker = new NodeWorker(workerUrl, { eval: false, type });
       } else if (this.source) {
         worker = new NodeWorker(this.source, { eval: true });
       } else {
@@ -1124,13 +1143,16 @@ var __exports__ = (() => {
      */
     returnWorkerToQueue(worker) {
       const shouldDestroyWorker = (
-        // If the pool is destroyed, there is no reason to keep the worker around
+        // Aborted jobs terminate their worker immediately.
+        worker.terminated || // 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();
+        if (!worker.terminated) {
+          worker.destroy();
+        }
         this.count--;
       } else {
         worker.unref();
@@ -1167,9 +1189,11 @@ var __exports__ = (() => {
     onDebug: () => {
     }
   };
-  var _WorkerFarm = class {
+  var WorkerFarm = class _WorkerFarm {
     props;
     workerPools = /* @__PURE__ */ new Map();
+    // singleton
+    static _workerFarm;
     /** Checks if workers are supported on this platform */
     static isSupported() {
       return WorkerThread.isSupported();
@@ -1238,9 +1262,6 @@ var __exports__ = (() => {
       };
     }
   };
-  var WorkerFarm = _WorkerFarm;
-  // singleton
-  __publicField(WorkerFarm, "_workerFarm");
 
   // ../worker-utils/src/lib/worker-api/get-worker-url.ts
   var warnedWorkerVersionFallbacks = /* @__PURE__ */ new Set();
@@ -1252,6 +1273,9 @@ var __exports__ = (() => {
     const workerOptions = options[worker.id] || {};
     const workerFile = isBrowser3 ? `${worker.id}-worker.js` : `${worker.id}-worker-node.js`;
     let url = workerOptions.workerUrl;
+    if (!url && typeof worker.worker === "string") {
+      url = worker.worker;
+    }
     if (!url && worker.id === "compression") {
       url = options.workerUrl;
     }
@@ -1294,9 +1318,11 @@ var __exports__ = (() => {
     if (!WorkerFarm.isSupported()) {
       return false;
     }
-    return worker.worker && options?.worker;
+    const workerOptions = options?.[worker.id];
+    return Boolean((worker.worker || workerOptions?.workerUrl) && options?.worker);
   }
   async function processOnWorker(worker, data, options = {}, context = {}, jobContext = {}) {
+    throwIfAborted(options.signal);
     const name = getWorkerName(worker);
     const workerFarm = WorkerFarm.getWorkerFarm(options);
     const { source } = options;
@@ -1311,15 +1337,35 @@ var __exports__ = (() => {
       // eslint-disable-next-line
       onMessage.bind(null, context)
     );
-    const transferableOptions = getTransferListForWriter(options);
-    const transferableContext = getTransferListForWriter(jobContext);
-    job.postMessage("process", {
-      input: data,
-      options: transferableOptions,
-      context: transferableContext
-    });
-    const result = await job.result;
-    return result.result;
+    const abortJob = () => job.abort();
+    options.signal?.addEventListener("abort", abortJob, { once: true });
+    if (options.signal?.aborted) {
+      abortJob();
+    }
+    try {
+      const { signal: _signal, ...workerOptions } = options;
+      const transferableOptions = getTransferListForWriter(workerOptions);
+      const transferableContext = getTransferListForWriter(jobContext);
+      if (job.isRunning) {
+        job.postMessage("process", {
+          input: data,
+          options: transferableOptions,
+          context: transferableContext
+        });
+      }
+      const result = await job.result;
+      return result.result;
+    } finally {
+      options.signal?.removeEventListener("abort", abortJob);
+    }
+  }
+  function throwIfAborted(signal) {
+    if (!signal?.aborted) {
+      return;
+    }
+    const error = new Error("Worker job was aborted");
+    error.name = "AbortError";
+    throw error;
   }
   async function onMessage(context, job, type, payload) {
     switch (type) {
@@ -1374,10 +1420,11 @@ var __exports__ = (() => {
     return Boolean(canProcessOnWorker(loader, workerOptions));
   }
   async function parseWithWorker(loader, data, options, context, parseOnMainThread) {
+    const signal = getWorkerAbortSignal(options);
     const result = await processOnWorker(
       loader,
       data,
-      getWorkerOptions(options),
+      { ...getWorkerOptions(options), signal },
       {
         process: async (input, processOptions, _workerContext, parseContext) => {
           if (!parseOnMainThread) {
@@ -1396,6 +1443,13 @@ var __exports__ = (() => {
     );
     return isLoaderWithWorkerResultDeserializer(loader) ? loader.deserializeWorkerResult(result, options, context) : result;
   }
+  function getWorkerAbortSignal(options) {
+    const parquetSignal = options?.parquet?.signal;
+    if (typeof AbortSignal !== "undefined" && parquetSignal instanceof AbortSignal) {
+      return parquetSignal;
+    }
+    return void 0;
+  }
   function callParseOnMainThread(parseOnMainThread, input, options, context) {
     if (parseOnMainThread.length <= 2) {
       return parseOnMainThread(input, options);
@@ -1939,91 +1993,6 @@ var __exports__ = (() => {
     return filename2;
   }
 
-  // ../loader-utils/src/json-loader.ts
-  var VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-  var JSONLoader = {
-    dataType: null,
-    batchType: null,
-    name: "JSON",
-    id: "json",
-    module: "json",
-    version: VERSION4,
-    encoding: "json",
-    format: "json",
-    extensions: ["json", "geojson"],
-    mimeTypes: ["application/json"],
-    category: "json",
-    text: true,
-    parseTextSync,
-    parse: async (arrayBuffer) => parseTextSync(new TextDecoder().decode(arrayBuffer)),
-    options: {}
-  };
-  function parseTextSync(text) {
-    return JSON.parse(text);
-  }
-
-  // ../loader-utils/src/lib/node/buffer.browser.ts
-  function toArrayBuffer(buffer) {
-    return buffer;
-  }
-
-  // ../loader-utils/src/lib/binary-utils/memory-conversion-utils.ts
-  function isBuffer(value) {
-    return value && typeof value === "object" && value.isBuffer;
-  }
-  function toArrayBuffer2(data) {
-    if (isBuffer(data)) {
-      return toArrayBuffer(data);
-    }
-    if (data instanceof ArrayBuffer) {
-      return data;
-    }
-    if (isSharedArrayBuffer(data)) {
-      return copyToArrayBuffer2(data);
-    }
-    if (ArrayBuffer.isView(data)) {
-      const buffer = data.buffer;
-      if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {
-        return buffer;
-      }
-      return buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
-    }
-    if (typeof data === "string") {
-      const text = data;
-      const uint8Array = new TextEncoder().encode(text);
-      return uint8Array.buffer;
-    }
-    if (data && typeof data === "object" && data._toArrayBuffer) {
-      return data._toArrayBuffer();
-    }
-    throw new Error("toArrayBuffer");
-  }
-  function ensureArrayBuffer(bufferSource) {
-    if (bufferSource instanceof ArrayBuffer) {
-      return bufferSource;
-    }
-    if (isSharedArrayBuffer(bufferSource)) {
-      return copyToArrayBuffer2(bufferSource);
-    }
-    const { buffer, byteOffset, byteLength } = bufferSource;
-    if (buffer instanceof ArrayBuffer && byteOffset === 0 && byteLength === buffer.byteLength) {
-      return buffer;
-    }
-    return copyToArrayBuffer2(buffer, byteOffset, byteLength);
-  }
-  function copyToArrayBuffer2(buffer, byteOffset = 0, byteLength = buffer.byteLength - byteOffset) {
-    const view = new Uint8Array(buffer, byteOffset, byteLength);
-    const copy = new Uint8Array(view.length);
-    copy.set(view);
-    return copy.buffer;
-  }
-  function toArrayBufferView(data) {
-    if (ArrayBuffer.isView(data)) {
-      return data;
-    }
-    return new Uint8Array(data);
-  }
-
   // ../loader-utils/src/lib/path-utils/path.ts
   var path_exports = {};
   __export(path_exports, {
@@ -2167,6 +2136,91 @@ var __exports__ = (() => {
     return res;
   }
 
+  // ../loader-utils/src/json-loader.ts
+  var VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var JSONLoader = {
+    dataType: null,
+    batchType: null,
+    name: "JSON",
+    id: "json",
+    module: "json",
+    version: VERSION4,
+    encoding: "json",
+    format: "json",
+    extensions: ["json", "geojson"],
+    mimeTypes: ["application/json"],
+    category: "json",
+    text: true,
+    parseTextSync,
+    parse: async (arrayBuffer) => parseTextSync(new TextDecoder().decode(arrayBuffer)),
+    options: {}
+  };
+  function parseTextSync(text) {
+    return JSON.parse(text);
+  }
+
+  // ../loader-utils/src/lib/node/buffer.browser.ts
+  function toArrayBuffer(buffer) {
+    return buffer;
+  }
+
+  // ../loader-utils/src/lib/binary-utils/memory-conversion-utils.ts
+  function isBuffer(value) {
+    return value && typeof value === "object" && value.isBuffer;
+  }
+  function toArrayBuffer2(data) {
+    if (isBuffer(data)) {
+      return toArrayBuffer(data);
+    }
+    if (data instanceof ArrayBuffer) {
+      return data;
+    }
+    if (isSharedArrayBuffer(data)) {
+      return copyToArrayBuffer2(data);
+    }
+    if (ArrayBuffer.isView(data)) {
+      const buffer = data.buffer;
+      if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {
+        return buffer;
+      }
+      return buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+    }
+    if (typeof data === "string") {
+      const text = data;
+      const uint8Array = new TextEncoder().encode(text);
+      return uint8Array.buffer;
+    }
+    if (data && typeof data === "object" && data._toArrayBuffer) {
+      return data._toArrayBuffer();
+    }
+    throw new Error("toArrayBuffer");
+  }
+  function ensureArrayBuffer(bufferSource) {
+    if (bufferSource instanceof ArrayBuffer) {
+      return bufferSource;
+    }
+    if (isSharedArrayBuffer(bufferSource)) {
+      return copyToArrayBuffer2(bufferSource);
+    }
+    const { buffer, byteOffset, byteLength } = bufferSource;
+    if (buffer instanceof ArrayBuffer && byteOffset === 0 && byteLength === buffer.byteLength) {
+      return buffer;
+    }
+    return copyToArrayBuffer2(buffer, byteOffset, byteLength);
+  }
+  function copyToArrayBuffer2(buffer, byteOffset = 0, byteLength = buffer.byteLength - byteOffset) {
+    const view = new Uint8Array(buffer, byteOffset, byteLength);
+    const copy = new Uint8Array(view.length);
+    copy.set(view);
+    return copy.buffer;
+  }
+  function toArrayBufferView(data) {
+    if (ArrayBuffer.isView(data)) {
+      return data;
+    }
+    return new Uint8Array(data);
+  }
+
   // ../loader-utils/src/lib/files/blob-file.ts
   var BlobFile = class {
     handle;
@@ -2188,8 +2242,14 @@ var __exports__ = (() => {
         isDirectory: false
       };
     }
-    async read(start, length) {
+    async read(start, length, signal) {
+      if (signal?.aborted) {
+        throw new Error("Request aborted");
+      }
       const arrayBuffer = await this.handle.slice(Number(start), Number(start) + Number(length)).arrayBuffer();
+      if (signal?.aborted) {
+        throw new Error("Request aborted");
+      }
       return arrayBuffer;
     }
   };
@@ -3201,20 +3261,57 @@ var __exports__ = (() => {
   async function* makeBrowserStreamIterator(stream, options) {
     const reader = stream.getReader();
     let nextBatchPromise;
+    let streamFinished = false;
+    let streamReadFailed = false;
+    let iteratorFailed = false;
     try {
       while (true) {
         const currentBatchPromise = nextBatchPromise || reader.read();
-        if (options?._streamReadAhead) {
-          nextBatchPromise = reader.read();
+        nextBatchPromise = void 0;
+        let batch;
+        try {
+          batch = await currentBatchPromise;
+        } catch (error) {
+          streamReadFailed = true;
+          throw error;
         }
-        const { done, value } = await currentBatchPromise;
+        const { done, value } = batch;
         if (done) {
+          streamFinished = true;
           return;
         }
+        if (options?._streamReadAhead) {
+          nextBatchPromise = reader.read();
+          void nextBatchPromise.catch(() => {
+          });
+        }
         yield toArrayBuffer2(value);
       }
-    } catch (_error) {
-      reader.releaseLock();
+    } catch (error) {
+      iteratorFailed = true;
+      throw error;
+    } finally {
+      let cleanupFailed = false;
+      let cleanupError;
+      if (!streamFinished && !streamReadFailed) {
+        try {
+          await reader.cancel();
+        } catch (error) {
+          cleanupFailed = true;
+          cleanupError = error;
+        }
+      }
+      try {
+        reader.releaseLock();
+      } catch (error) {
+        if (!cleanupFailed) {
+          cleanupFailed = true;
+          cleanupError = error;
+        }
+      }
+      if (!iteratorFailed && cleanupFailed) {
+        throw cleanupError;
+      }
     }
   }
   async function* makeNodeStreamIterator(stream, options) {
@@ -3335,14 +3432,14 @@ var __exports__ = (() => {
   }
   function getIterableFromData(data) {
     if (ArrayBuffer.isView(data)) {
-      return function* oneChunk() {
+      return (function* oneChunk() {
         yield toArrayBuffer2(data);
-      }();
+      })();
     }
     if (isArrayBufferLike(data)) {
-      return function* oneChunk() {
+      return (function* oneChunk() {
         yield toArrayBuffer2(data);
-      }();
+      })();
     }
     if (isIterator(data)) {
       return data;
@@ -3451,12 +3548,7 @@ var __exports__ = (() => {
   function getLoaderImplementationCacheKey(loader, options) {
     const loaderOptions = options?.[loader.id];
     const defaultLoaderOptions = loader.options?.[loader.id];
-    return String(
-      loaderOptions?.backend || getDeprecatedImplementationBackend(loaderOptions?.implementation) || defaultLoaderOptions?.backend || ""
-    );
-  }
-  function getDeprecatedImplementationBackend(implementation) {
-    return implementation === "js" ? "typescript" : implementation;
+    return String(loaderOptions?.backend || defaultLoaderOptions?.backend || "");
   }
   async function importLoaderImplementation(implementationSpecifier, loaderId) {
     const moduleExports = await import(
@@ -3747,6 +3839,7 @@ var __exports__ = (() => {
       resolvedOptions = options;
     }
     if (!Array.isArray(resolvedLoaders) && isSourceLoader(resolvedLoaders)) {
+      const sourceLoader = await resolveSourceLoader(resolvedLoaders, url, resolvedOptions);
       const runtimeCoreApi = {
         fetchFile,
         parse,
@@ -3756,13 +3849,14 @@ var __exports__ = (() => {
         load,
         loadInBatches
       };
-      return resolvedLoaders.createDataSource(
+      return sourceLoader.createDataSource(
         url,
         resolvedOptions || {},
         runtimeCoreApi
       );
     }
     if (Array.isArray(resolvedLoaders) && resolvedLoaders.length === 1 && isSourceLoader(resolvedLoaders[0])) {
+      const sourceLoader = await resolveSourceLoader(resolvedLoaders[0], url, resolvedOptions);
       const runtimeCoreApi = {
         fetchFile,
         parse,
@@ -3772,7 +3866,7 @@ var __exports__ = (() => {
         load,
         loadInBatches
       };
-      return resolvedLoaders[0].createDataSource(
+      return sourceLoader.createDataSource(
         url,
         resolvedOptions || {},
         runtimeCoreApi
@@ -3784,7 +3878,8 @@ var __exports__ = (() => {
         core: { ...resolvedOptions?.core, nothrow: true }
       });
       if (selectedLoader && isSourceLoader(selectedLoader)) {
-        return selectedLoader.createDataSource(
+        const sourceLoader = await resolveSourceLoader(selectedLoader, url, resolvedOptions);
+        return sourceLoader.createDataSource(
           url,
           resolvedOptions || {},
           {
@@ -3821,6 +3916,16 @@ var __exports__ = (() => {
     }
     return Array.isArray(resolvedLoaders) ? await parse(data, resolvedLoaders, resolvedOptions, context) : await parse(data, resolvedLoaders, resolvedOptions, context);
   }
+  async function resolveSourceLoader(loader, url, options) {
+    if (!loader.preload) {
+      return loader;
+    }
+    const sourceLoader = await loader.preload(typeof url === "string" ? url : "", options);
+    if (!isSourceLoader(sourceLoader)) {
+      throw new Error(`${loader.id} source loader preload() did not return a runtime source loader`);
+    }
+    return sourceLoader;
+  }
 
   // src/lib/api/core-api.ts
   var coreApi = Object.freeze({
@@ -3913,6 +4018,9 @@ var __exports__ = (() => {
       data = await getArrayBufferFromData(data, options);
       return await parseWithWorker(loaderWithParser, data, options, context, parse);
     }
+    if (isBlob(data) && loaderWithParser.parseBlob) {
+      return await loaderWithParser.parseBlob(data, options, context);
+    }
     data = await getArrayBufferOrStringFromData(data, loader, options);
     return await parseWithLoaderImplementation(loaderWithParser, data, options, context);
   }