@loaders.gl/tiles 4.0.0-alpha.8 → 4.0.0-beta.1

package/dist/dist.min.js

@@ -1,5 +1,10 @@
 (() => {
+  var __create = Object.create;
   var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
   var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
   var __esm = (fn, res) => function __init() {
     return fn && (res = (0, fn[Object.keys(fn)[0]])(fn = 0)), res;
@@ -12,6 +17,17 @@
     for (var name in all)
       __defProp(target, name, { get: all[name], enumerable: true });
   };
+  var __reExport = (target, module, desc) => {
+    if (module && typeof module === "object" || typeof module === "function") {
+      for (let key of __getOwnPropNames(module))
+        if (!__hasOwnProp.call(target, key) && key !== "default")
+          __defProp(target, key, { get: () => module[key], enumerable: !(desc = __getOwnPropDesc(module, key)) || desc.enumerable });
+    }
+    return target;
+  };
+  var __toModule = (module) => {
+    return __reExport(__markAsModule(__defProp(module != null ? __create(__getProtoOf(module)) : {}, "default", module && module.__esModule && "default" in module ? { get: () => module.default, enumerable: true } : { value: module, enumerable: true })), module);
+  };
 
   // ../../node_modules/@math.gl/core/dist/esm/lib/assert.js
   function assert(condition, message) {
@@ -3643,16 +3659,45 @@
     }
   });
 
+  // ../loader-utils/src/lib/option-utils/merge-loader-options.ts
+  function mergeLoaderOptions(baseOptions, newOptions) {
+    return mergeOptionsRecursively(baseOptions || {}, newOptions);
+  }
+  function mergeOptionsRecursively(baseOptions, newOptions) {
+    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]);
+      } else {
+        options[key] = newOptions[key];
+      }
+    }
+    return options;
+  }
+  var init_merge_loader_options = __esm({
+    "../loader-utils/src/lib/option-utils/merge-loader-options.ts"() {
+    }
+  });
+
   // ../worker-utils/src/lib/env-utils/version.ts
-  var DEFAULT_VERSION, VERSION;
-  var init_version = __esm({
-    "../worker-utils/src/lib/env-utils/version.ts"() {
-      DEFAULT_VERSION = "beta";
-      VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : DEFAULT_VERSION;
+  function getVersion() {
+    if (!globalThis._loadersgl_?.version) {
+      globalThis._loadersgl_ = globalThis._loadersgl_ || {};
       if (typeof __VERSION__ === "undefined") {
         console.error("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 = __VERSION__;
       }
     }
+    return globalThis._loadersgl_.version;
+  }
+  var NPM_TAG, VERSION;
+  var init_version = __esm({
+    "../worker-utils/src/lib/env-utils/version.ts"() {
+      NPM_TAG = "beta";
+      VERSION = getVersion();
+    }
   });
 
   // ../worker-utils/src/lib/env-utils/assert.ts
@@ -4116,12 +4161,11 @@
     assert3(url);
     return url;
   }
-  var NPM_TAG;
   var init_get_worker_url = __esm({
     "../worker-utils/src/lib/worker-api/get-worker-url.ts"() {
       init_assert3();
       init_globals2();
-      NPM_TAG = "beta";
+      init_version();
     }
   });
 
@@ -4793,6 +4837,7 @@
     "../loader-utils/src/index.ts"() {
       init_assert2();
       init_globals();
+      init_merge_loader_options();
       init_parse_with_worker();
       init_array_buffer_utils();
       init_async_iteration();
@@ -4832,55 +4877,55 @@
           return this._length;
         }
         add(item) {
-          const node2 = new DoublyLinkedListNode(item, this.tail, null);
+          const node3 = new DoublyLinkedListNode(item, this.tail, null);
           if (this.tail) {
-            this.tail.next = node2;
-            this.tail = node2;
+            this.tail.next = node3;
+            this.tail = node3;
           } else {
-            this.head = node2;
-            this.tail = node2;
+            this.head = node3;
+            this.tail = node3;
           }
           ++this._length;
-          return node2;
+          return node3;
         }
-        remove(node2) {
-          if (!node2) {
+        remove(node3) {
+          if (!node3) {
             return;
           }
-          if (node2.previous && node2.next) {
-            node2.previous.next = node2.next;
-            node2.next.previous = node2.previous;
-          } else if (node2.previous) {
-            node2.previous.next = null;
-            this.tail = node2.previous;
-          } else if (node2.next) {
-            node2.next.previous = null;
-            this.head = node2.next;
+          if (node3.previous && node3.next) {
+            node3.previous.next = node3.next;
+            node3.next.previous = node3.previous;
+          } else if (node3.previous) {
+            node3.previous.next = null;
+            this.tail = node3.previous;
+          } else if (node3.next) {
+            node3.next.previous = null;
+            this.head = node3.next;
           } else {
             this.head = null;
             this.tail = null;
           }
-          node2.next = null;
-          node2.previous = null;
+          node3.next = null;
+          node3.previous = null;
           --this._length;
         }
-        splice(node2, nextNode) {
-          if (node2 === nextNode) {
+        splice(node3, nextNode) {
+          if (node3 === nextNode) {
             return;
           }
           this.remove(nextNode);
-          this._insert(node2, nextNode);
+          this._insert(node3, nextNode);
         }
-        _insert(node2, nextNode) {
-          const oldNodeNext = node2.next;
-          node2.next = nextNode;
-          if (this.tail === node2) {
+        _insert(node3, nextNode) {
+          const oldNodeNext = node3.next;
+          node3.next = nextNode;
+          if (this.tail === node3) {
             this.tail = nextNode;
           } else {
             oldNodeNext.previous = nextNode;
           }
           nextNode.next = oldNodeNext;
-          nextNode.previous = node2;
+          nextNode.previous = node3;
           ++this._length;
         }
       };
@@ -4902,9 +4947,9 @@
           this._list.splice(this._list.tail, this._sentinel);
         }
         touch(tile) {
-          const node2 = tile._cacheNode;
-          if (node2) {
-            this._list.splice(this._sentinel, node2);
+          const node3 = tile._cacheNode;
+          if (node3) {
+            this._list.splice(this._sentinel, node3);
           }
         }
         add(tileset, tile, addCallback) {
@@ -4916,11 +4961,11 @@
           }
         }
         unloadTile(tileset, tile, unloadCallback) {
-          const node2 = tile._cacheNode;
-          if (!node2) {
+          const node3 = tile._cacheNode;
+          if (!node3) {
             return;
           }
-          this._list.remove(node2);
+          this._list.remove(node3);
           tile._cacheNode = null;
           if (unloadCallback) {
             unloadCallback(tileset, tile);
@@ -4932,10 +4977,10 @@
           const list = this._list;
           const maximumMemoryUsageInBytes = tileset.maximumMemoryUsage * 1024 * 1024;
           const sentinel = this._sentinel;
-          let node2 = list.head;
-          while (node2 !== sentinel && (tileset.gpuMemoryUsageInBytes > maximumMemoryUsageInBytes || trimTiles)) {
-            const tile = node2.item;
-            node2 = node2.next;
+          let node3 = list.head;
+          while (node3 !== sentinel && (tileset.gpuMemoryUsageInBytes > maximumMemoryUsageInBytes || trimTiles)) {
+            const tile = node3.item;
+            node3 = node3.next;
             this.unloadTile(tileset, tile, unloadCallback);
           }
         }
@@ -5713,7 +5758,7 @@
       isFunction = (x) => typeof x === "function";
       isObject = (x) => x !== null && typeof x === "object";
       isPureObject = (x) => isObject(x) && x.constructor === {}.constructor;
-      isIterable = (x) => x && typeof x[Symbol.iterator] === "function";
+      isIterable = (x) => Boolean(x) && typeof x[Symbol.iterator] === "function";
       isAsyncIterable = (x) => x && typeof x[Symbol.asyncIterator] === "function";
       isResponse = (x) => typeof Response !== "undefined" && x instanceof Response || x && x.arrayBuffer && x.text && x.json;
       isBlob = (x) => typeof Blob !== "undefined" && x instanceof Blob;
@@ -5902,22 +5947,38 @@
     }
   });
 
+  // (disabled):../core/src/lib/fetch/fetch-file.node
+  var require_fetch_file = __commonJS({
+    "(disabled):../core/src/lib/fetch/fetch-file.node"() {
+    }
+  });
+
   // ../core/src/lib/fetch/fetch-file.ts
-  async function fetchFile(url, options) {
-    if (typeof url === "string") {
-      url = resolvePath(url);
-      let fetchOptions = options;
-      if (options?.fetch && typeof options?.fetch !== "function") {
-        fetchOptions = options.fetch;
+  function isNodePath(url) {
+    return !isRequestURL(url) && !isDataURL(url);
+  }
+  function isRequestURL(url) {
+    return url.startsWith("http:") || url.startsWith("https:");
+  }
+  function isDataURL(url) {
+    return url.startsWith("data:");
+  }
+  async function fetchFile(urlOrData, fetchOptions) {
+    if (typeof urlOrData === "string") {
+      const url = resolvePath(urlOrData);
+      if (isNodePath(url) && node2?.fetchFileNode) {
+        return node2.fetchFileNode(url, fetchOptions);
       }
       return await fetch(url, fetchOptions);
     }
-    return await makeResponse(url);
+    return await makeResponse(urlOrData);
   }
+  var node2;
   var init_fetch_file = __esm({
     "../core/src/lib/fetch/fetch-file.ts"() {
       init_src2();
       init_response_utils();
+      node2 = __toModule(require_fetch_file());
     }
   });
 
@@ -6581,6 +6642,7 @@
         mimeType: void 0,
         nothrow: false,
         log: new ConsoleLog(),
+        useLocalLibraries: false,
         CDN: "https://unpkg.com/@loaders.gl",
         worker: true,
         maxConcurrency: 3,
@@ -6622,6 +6684,11 @@
     loaders._state = loaders._state || {};
     return loaders._state;
   }
+  function getGlobalLoaderOptions() {
+    const state = getGlobalLoaderState();
+    state.globalOptions = state.globalOptions || { ...DEFAULT_LOADER_OPTIONS };
+    return state.globalOptions;
+  }
   function normalizeOptions(options, loader, loaders, url) {
     loaders = loaders || [];
     loaders = Array.isArray(loaders) ? loaders : [loaders];
@@ -6702,17 +6769,11 @@
       options.baseUri = url;
     }
   }
-  var getGlobalLoaderOptions;
   var init_option_utils = __esm({
     "../core/src/lib/loader-utils/option-utils.ts"() {
       init_is_type();
       init_loggers();
       init_option_defaults();
-      getGlobalLoaderOptions = () => {
-        const state = getGlobalLoaderState();
-        state.globalOptions = state.globalOptions || { ...DEFAULT_LOADER_OPTIONS };
-        return state.globalOptions;
-      };
     }
   });
 
@@ -6833,8 +6894,10 @@
     reason = reason || (loader ? `matched MIME type ${type}` : "");
     loader = loader || findLoaderByInitialBytes(loaders, data);
     reason = reason || (loader ? `matched initial data ${getFirstCharacters(data)}` : "");
-    loader = loader || findLoaderByMIMEType(loaders, options?.fallbackMimeType);
-    reason = reason || (loader ? `matched fallback MIME type ${type}` : "");
+    if (options?.fallbackMimeType) {
+      loader = loader || findLoaderByMIMEType(loaders, options?.fallbackMimeType);
+      reason = reason || (loader ? `matched fallback MIME type ${type}` : "");
+    }
     if (reason) {
       log.log(1, `selectLoader selected ${loader?.name}: ${reason}.`);
     }
@@ -6930,7 +6993,7 @@
     }
     switch (typeof test) {
       case "function":
-        return test(data, loader);
+        return test(data);
       case "string":
         const magic = getMagicString(data, byteOffset, test.length);
         return test === magic;
@@ -7161,12 +7224,12 @@
   // ../core/src/lib/loader-utils/get-fetch-function.ts
   function getFetchFunction(options, context) {
     const globalOptions = getGlobalLoaderOptions();
-    const fetchOptions = options || globalOptions;
-    if (typeof fetchOptions.fetch === "function") {
-      return fetchOptions.fetch;
+    const loaderOptions = options || globalOptions;
+    if (typeof loaderOptions.fetch === "function") {
+      return loaderOptions.fetch;
     }
-    if (isObject(fetchOptions.fetch)) {
-      return (url) => fetchFile(url, fetchOptions);
+    if (isObject(loaderOptions.fetch)) {
+      return (url) => fetchFile(url, loaderOptions.fetch);
     }
     if (context?.fetch) {
       return context?.fetch;
@@ -7203,7 +7266,7 @@
     return newContext;
   }
   function getLoadersFromContext(loaders, context) {
-    if (!context && loaders && !Array.isArray(loaders)) {
+    if (loaders && !Array.isArray(loaders)) {
       return loaders;
     }
     let candidateLoaders;
@@ -7214,7 +7277,7 @@
       const contextLoaders = Array.isArray(context.loaders) ? context.loaders : [context.loaders];
       candidateLoaders = candidateLoaders ? [...candidateLoaders, ...contextLoaders] : contextLoaders;
     }
-    return candidateLoaders && candidateLoaders.length ? candidateLoaders : null;
+    return candidateLoaders && candidateLoaders.length ? candidateLoaders : void 0;
   }
   var init_loader_context = __esm({
     "../core/src/lib/loader-utils/loader-context.ts"() {
@@ -7226,7 +7289,6 @@
 
   // ../core/src/lib/api/parse.ts
   async function parse(data, loaders, options, context) {
-    assert3(!context || typeof context === "object");
     if (loaders && !Array.isArray(loaders) && !isLoaderObject(loaders)) {
       context = void 0;
       options = loaders;
@@ -7242,11 +7304,12 @@
       return null;
     }
     options = normalizeOptions(options, loader, candidateLoaders, url);
-    context = getLoaderContext({ url, parse, loaders: candidateLoaders }, options, context || null);
+    context = getLoaderContext({ url, _parse: parse, loaders: candidateLoaders }, options, context || null);
     return await parseWithLoader(loader, data, options, context);
   }
   async function parseWithLoader(loader, data, options, context) {
     validateWorkerVersion(loader);
+    options = mergeLoaderOptions(loader.options, options);
     if (isResponse(data)) {
       const response = data;
       const { ok, redirected, status, statusText, type, url } = response;
@@ -7254,29 +7317,30 @@
       context.response = { headers, ok, redirected, status, statusText, type, url };
     }
     data = await getArrayBufferOrStringFromData(data, loader, options);
-    if (loader.parseTextSync && typeof data === "string") {
-      options.dataType = "text";
-      return loader.parseTextSync(data, options, context, loader);
+    const loaderWithParser = loader;
+    if (loaderWithParser.parseTextSync && typeof data === "string") {
+      return loaderWithParser.parseTextSync(data, options, context);
     }
     if (canParseWithWorker(loader, options)) {
       return await parseWithWorker(loader, data, options, context, parse);
     }
-    if (loader.parseText && typeof data === "string") {
-      return await loader.parseText(data, options, context, loader);
+    if (loaderWithParser.parseText && typeof data === "string") {
+      return await loaderWithParser.parseText(data, options, context);
     }
-    if (loader.parse) {
-      return await loader.parse(data, options, context, loader);
+    if (loaderWithParser.parse) {
+      return await loaderWithParser.parse(data, options, context);
     }
-    assert3(!loader.parseSync);
+    assert3(!loaderWithParser.parseSync);
     throw new Error(`${loader.id} loader - no parser found and worker is disabled`);
   }
   var init_parse = __esm({
     "../core/src/lib/api/parse.ts"() {
-      init_src();
       init_src2();
+      init_src();
       init_normalize_loader();
       init_is_type();
       init_option_utils();
+      init_src2();
       init_get_data();
       init_loader_context();
       init_resource_utils();
@@ -7950,7 +8014,7 @@
                 }
                 stack.push(child);
               }
-            } else if (!tile.contentAvailable) {
+            } else if (!tile.contentAvailable && !tile.hasEmptyContent) {
               allDescendantsLoaded = false;
             }
           }