@loaders.gl/schema 4.4.0-alpha.9 → 4.4.0

package/dist/dist.dev.js

@@ -147,7 +147,139 @@ var __exports__ = (() => {
   }
 
   // ../../node_modules/@probe.gl/env/dist/index.js
-  var VERSION = true ? "4.0.7" : "untranspiled source";
+  var VERSION = true ? "4.1.1" : "untranspiled source";
+
+  // ../../node_modules/@probe.gl/log/dist/utils/assert.js
+  function assert2(condition, message) {
+    if (!condition) {
+      throw new Error(message || "Assertion failed");
+    }
+  }
+
+  // ../../node_modules/@probe.gl/log/dist/loggers/log-utils.js
+  function normalizeLogLevel(logLevel) {
+    if (!logLevel) {
+      return 0;
+    }
+    let resolvedLevel;
+    switch (typeof logLevel) {
+      case "number":
+        resolvedLevel = logLevel;
+        break;
+      case "object":
+        resolvedLevel = logLevel.logLevel || logLevel.priority || 0;
+        break;
+      default:
+        return 0;
+    }
+    assert2(Number.isFinite(resolvedLevel) && resolvedLevel >= 0);
+    return resolvedLevel;
+  }
+  function normalizeArguments(opts) {
+    const { logLevel, message } = opts;
+    opts.logLevel = normalizeLogLevel(logLevel);
+    const args = opts.args ? Array.from(opts.args) : [];
+    while (args.length && args.shift() !== message) {
+    }
+    switch (typeof logLevel) {
+      case "string":
+      case "function":
+        if (message !== void 0) {
+          args.unshift(message);
+        }
+        opts.message = logLevel;
+        break;
+      case "object":
+        Object.assign(opts, logLevel);
+        break;
+      default:
+    }
+    if (typeof opts.message === "function") {
+      opts.message = opts.message();
+    }
+    const messageType = typeof opts.message;
+    assert2(messageType === "string" || messageType === "object");
+    return Object.assign(opts, { args }, opts.opts);
+  }
+
+  // ../../node_modules/@probe.gl/log/dist/loggers/base-log.js
+  var noop = () => {
+  };
+  var BaseLog = class {
+    constructor({ level = 0 } = {}) {
+      this.userData = {};
+      this._onceCache = /* @__PURE__ */ new Set();
+      this._level = level;
+    }
+    set level(newLevel) {
+      this.setLevel(newLevel);
+    }
+    get level() {
+      return this.getLevel();
+    }
+    setLevel(level) {
+      this._level = level;
+      return this;
+    }
+    getLevel() {
+      return this._level;
+    }
+    // Unconditional logging
+    warn(message, ...args) {
+      return this._log("warn", 0, message, args, { once: true });
+    }
+    error(message, ...args) {
+      return this._log("error", 0, message, args);
+    }
+    // Conditional logging
+    log(logLevel, message, ...args) {
+      return this._log("log", logLevel, message, args);
+    }
+    info(logLevel, message, ...args) {
+      return this._log("info", logLevel, message, args);
+    }
+    once(logLevel, message, ...args) {
+      return this._log("once", logLevel, message, args, { once: true });
+    }
+    _log(type, logLevel, message, args, options = {}) {
+      const normalized = normalizeArguments({
+        logLevel,
+        message,
+        args: this._buildArgs(logLevel, message, args),
+        opts: options
+      });
+      return this._createLogFunction(type, normalized, options);
+    }
+    _buildArgs(logLevel, message, args) {
+      return [logLevel, message, ...args];
+    }
+    _createLogFunction(type, normalized, options) {
+      if (!this._shouldLog(normalized.logLevel)) {
+        return noop;
+      }
+      const tag = this._getOnceTag(options.tag ?? normalized.tag ?? normalized.message);
+      if ((options.once || normalized.once) && tag !== void 0) {
+        if (this._onceCache.has(tag)) {
+          return noop;
+        }
+        this._onceCache.add(tag);
+      }
+      return this._emit(type, normalized);
+    }
+    _shouldLog(logLevel) {
+      return this.getLevel() >= normalizeLogLevel(logLevel);
+    }
+    _getOnceTag(tag) {
+      if (tag === void 0) {
+        return void 0;
+      }
+      try {
+        return typeof tag === "string" ? tag : String(tag);
+      } catch {
+        return void 0;
+      }
+    }
+  };
 
   // ../../node_modules/@probe.gl/log/dist/utils/local-storage.js
   function getStorage(type) {
@@ -266,13 +398,6 @@ var __exports__ = (() => {
     }
   }
 
-  // ../../node_modules/@probe.gl/log/dist/utils/assert.js
-  function assert2(condition, message) {
-    if (!condition) {
-      throw new Error(message || "Assertion failed");
-    }
-  }
-
   // ../../node_modules/@probe.gl/log/dist/utils/hi-res-timestamp.js
   function getHiResTimestamp() {
     let timestamp;
@@ -287,7 +412,7 @@ var __exports__ = (() => {
     return timestamp;
   }
 
-  // ../../node_modules/@probe.gl/log/dist/log.js
+  // ../../node_modules/@probe.gl/log/dist/loggers/probe-log.js
   var originalConsole = {
     debug: isBrowser2() ? console.debug || console.log : console.log,
     log: console.log,
@@ -299,12 +424,9 @@ var __exports__ = (() => {
     enabled: true,
     level: 0
   };
-  function noop() {
-  }
-  var cache = {};
-  var ONCE = { once: true };
-  var Log = class {
+  var ProbeLog = class extends BaseLog {
     constructor({ id } = { id: "" }) {
+      super({ level: 0 });
       this.VERSION = VERSION;
       this._startTs = getHiResTimestamp();
       this._deltaTs = getHiResTimestamp();
@@ -312,22 +434,16 @@ var __exports__ = (() => {
       this.LOG_THROTTLE_TIMEOUT = 0;
       this.id = id;
       this.userData = {};
-      this._storage = new LocalStorage(`__probe-${this.id}__`, DEFAULT_LOG_CONFIGURATION);
+      this._storage = new LocalStorage(`__probe-${this.id}__`, { [this.id]: DEFAULT_LOG_CONFIGURATION });
       this.timeStamp(`${this.id} started`);
       autobind(this);
       Object.seal(this);
     }
-    set level(newLevel) {
-      this.setLevel(newLevel);
-    }
-    get level() {
-      return this.getLevel();
-    }
     isEnabled() {
-      return this._storage.config.enabled;
+      return this._getConfiguration().enabled;
     }
     getLevel() {
-      return this._storage.config.level;
+      return this._getConfiguration().level;
     }
     /** @return milliseconds, with fractions */
     getTotal() {
@@ -351,20 +467,20 @@ var __exports__ = (() => {
     }
     // Configure
     enable(enabled = true) {
-      this._storage.setConfiguration({ enabled });
+      this._updateConfiguration({ enabled });
       return this;
     }
     setLevel(level) {
-      this._storage.setConfiguration({ level });
+      this._updateConfiguration({ level });
       return this;
     }
     /** return the current status of the setting */
     get(setting) {
-      return this._storage.config[setting];
+      return this._getConfiguration()[setting];
     }
     // update the status of the setting
     set(setting, value) {
-      this._storage.setConfiguration({ [setting]: value });
+      this._updateConfiguration({ [setting]: value });
     }
     /** Logs the current settings as a table */
     settings() {
@@ -380,11 +496,16 @@ var __exports__ = (() => {
         throw new Error(message || "Assertion failed");
       }
     }
-    warn(message) {
-      return this._getLogFunction(0, message, originalConsole.warn, arguments, ONCE);
+    warn(message, ...args) {
+      return this._log("warn", 0, message, args, {
+        method: originalConsole.warn,
+        once: true
+      });
     }
-    error(message) {
-      return this._getLogFunction(0, message, originalConsole.error, arguments);
+    error(message, ...args) {
+      return this._log("error", 0, message, args, {
+        method: originalConsole.error
+      });
     }
     /** Print a deprecation warning */
     deprecated(oldUsage, newUsage) {
@@ -394,50 +515,63 @@ var __exports__ = (() => {
     removed(oldUsage, newUsage) {
       return this.error(`\`${oldUsage}\` has been removed. Use \`${newUsage}\` instead`);
     }
-    probe(logLevel, message) {
-      return this._getLogFunction(logLevel, message, originalConsole.log, arguments, {
+    probe(logLevel, message, ...args) {
+      return this._log("log", logLevel, message, args, {
+        method: originalConsole.log,
         time: true,
         once: true
       });
     }
-    log(logLevel, message) {
-      return this._getLogFunction(logLevel, message, originalConsole.debug, arguments);
+    log(logLevel, message, ...args) {
+      return this._log("log", logLevel, message, args, {
+        method: originalConsole.debug
+      });
     }
-    info(logLevel, message) {
-      return this._getLogFunction(logLevel, message, console.info, arguments);
+    info(logLevel, message, ...args) {
+      return this._log("info", logLevel, message, args, { method: console.info });
     }
-    once(logLevel, message) {
-      return this._getLogFunction(logLevel, message, originalConsole.debug || originalConsole.info, arguments, ONCE);
+    once(logLevel, message, ...args) {
+      return this._log("once", logLevel, message, args, {
+        method: originalConsole.debug || originalConsole.info,
+        once: true
+      });
     }
     /** Logs an object as a table */
     table(logLevel, table, columns) {
       if (table) {
-        return this._getLogFunction(logLevel, table, console.table || noop, columns && [columns], {
+        return this._log("table", logLevel, table, columns && [columns] || [], {
+          method: console.table || noop,
           tag: getTableHeader(table)
         });
       }
       return noop;
     }
     time(logLevel, message) {
-      return this._getLogFunction(logLevel, message, console.time ? console.time : console.info);
+      return this._log("time", logLevel, message, [], {
+        method: console.time ? console.time : console.info
+      });
     }
     timeEnd(logLevel, message) {
-      return this._getLogFunction(logLevel, message, console.timeEnd ? console.timeEnd : console.info);
+      return this._log("time", logLevel, message, [], {
+        method: console.timeEnd ? console.timeEnd : console.info
+      });
     }
     timeStamp(logLevel, message) {
-      return this._getLogFunction(logLevel, message, console.timeStamp || noop);
+      return this._log("time", logLevel, message, [], {
+        method: console.timeStamp || noop
+      });
     }
     group(logLevel, message, opts = { collapsed: false }) {
-      const options = normalizeArguments({ logLevel, message, opts });
-      const { collapsed } = opts;
-      options.method = (collapsed ? console.groupCollapsed : console.group) || console.info;
-      return this._getLogFunction(options);
+      const method = (opts.collapsed ? console.groupCollapsed : console.group) || console.info;
+      return this._log("group", logLevel, message, [], { method });
     }
     groupCollapsed(logLevel, message, opts = {}) {
       return this.group(logLevel, message, Object.assign({}, opts, { collapsed: true }));
     }
     groupEnd(logLevel) {
-      return this._getLogFunction(logLevel, "", console.groupEnd || noop);
+      return this._log("groupEnd", logLevel, "", [], {
+        method: console.groupEnd || noop
+      });
     }
     // EXPERIMENTAL
     withGroup(logLevel, message, func) {
@@ -453,78 +587,34 @@ var __exports__ = (() => {
         console.trace();
       }
     }
-    // PRIVATE METHODS
-    /** Deduces log level from a variety of arguments */
     _shouldLog(logLevel) {
-      return this.isEnabled() && this.getLevel() >= normalizeLogLevel(logLevel);
-    }
-    _getLogFunction(logLevel, message, method, args, opts) {
-      if (this._shouldLog(logLevel)) {
-        opts = normalizeArguments({ logLevel, message, args, opts });
-        method = method || opts.method;
-        assert2(method);
-        opts.total = this.getTotal();
-        opts.delta = this.getDelta();
-        this._deltaTs = getHiResTimestamp();
-        const tag = opts.tag || opts.message;
-        if (opts.once && tag) {
-          if (!cache[tag]) {
-            cache[tag] = getHiResTimestamp();
-          } else {
-            return noop;
-          }
-        }
-        message = decorateMessage(this.id, opts.message, opts);
-        return method.bind(console, message, ...opts.args);
-      }
-      return noop;
-    }
-  };
-  Log.VERSION = VERSION;
-  function normalizeLogLevel(logLevel) {
-    if (!logLevel) {
-      return 0;
-    }
-    let resolvedLevel;
-    switch (typeof logLevel) {
-      case "number":
-        resolvedLevel = logLevel;
-        break;
-      case "object":
-        resolvedLevel = logLevel.logLevel || logLevel.priority || 0;
-        break;
-      default:
-        return 0;
+      return this.isEnabled() && super._shouldLog(logLevel);
     }
-    assert2(Number.isFinite(resolvedLevel) && resolvedLevel >= 0);
-    return resolvedLevel;
-  }
-  function normalizeArguments(opts) {
-    const { logLevel, message } = opts;
-    opts.logLevel = normalizeLogLevel(logLevel);
-    const args = opts.args ? Array.from(opts.args) : [];
-    while (args.length && args.shift() !== message) {
+    _emit(_type, normalized) {
+      const method = normalized.method;
+      assert2(method);
+      normalized.total = this.getTotal();
+      normalized.delta = this.getDelta();
+      this._deltaTs = getHiResTimestamp();
+      const message = decorateMessage(this.id, normalized.message, normalized);
+      return method.bind(console, message, ...normalized.args);
     }
-    switch (typeof logLevel) {
-      case "string":
-      case "function":
-        if (message !== void 0) {
-          args.unshift(message);
-        }
-        opts.message = logLevel;
-        break;
-      case "object":
-        Object.assign(opts, logLevel);
-        break;
-      default:
+    _getConfiguration() {
+      if (!this._storage.config[this.id]) {
+        this._updateConfiguration(DEFAULT_LOG_CONFIGURATION);
+      }
+      return this._storage.config[this.id];
     }
-    if (typeof opts.message === "function") {
-      opts.message = opts.message();
+    _updateConfiguration(configuration) {
+      const currentConfiguration = this._storage.config[this.id] || {
+        ...DEFAULT_LOG_CONFIGURATION
+      };
+      this._storage.setConfiguration({
+        [this.id]: { ...currentConfiguration, ...configuration }
+      });
     }
-    const messageType = typeof opts.message;
-    assert2(messageType === "string" || messageType === "object");
-    return Object.assign(opts, { args }, opts.opts);
-  }
+  };
+  ProbeLog.VERSION = VERSION;
   function decorateMessage(id, message, opts) {
     if (typeof message === "string") {
       const time = opts.time ? leftPad(formatTime(opts.total)) : "";
@@ -546,17 +636,17 @@ var __exports__ = (() => {
   globalThis.probe = {};
 
   // ../../node_modules/@probe.gl/log/dist/index.js
-  var dist_default = new Log({ id: "@probe.gl/log" });
+  var dist_default = new ProbeLog({ id: "@probe.gl/log" });
 
   // ../loader-utils/src/lib/log-utils/log.ts
   var VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
   var version = VERSION2[0] >= "0" && VERSION2[0] <= "9" ? `v${VERSION2}` : "";
   function createLog() {
-    const log2 = new Log({ id: "loaders.gl" });
-    globalThis.loaders = globalThis.loaders || {};
+    const log2 = new ProbeLog({ id: "loaders.gl" });
+    globalThis.loaders ||= {};
     globalThis.loaders.log = log2;
     globalThis.loaders.version = version;
-    globalThis.probe = globalThis.probe || {};
+    globalThis.probe ||= {};
     globalThis.probe.loaders = log2;
     return log2;
   }
@@ -2321,7 +2411,7 @@ var __exports__ = (() => {
   }
 
   // ../core/src/lib/loader-utils/loggers.ts
-  var probeLog = new Log({ id: "loaders.gl" });
+  var probeLog = new ProbeLog({ id: "loaders.gl" });
   var NullLog = class {
     log() {
       return () => {
@@ -2362,8 +2452,8 @@ var __exports__ = (() => {
   // ../core/src/lib/loader-utils/option-defaults.ts
   var DEFAULT_LOADER_OPTIONS = {
     core: {
-      baseUri: void 0,
-      // baseUri
+      baseUrl: void 0,
+      // baseUrl
       fetch: null,
       mimeType: void 0,
       fallbackMimeType: void 0,
@@ -2395,8 +2485,8 @@ var __exports__ = (() => {
     }
   };
   var REMOVED_LOADER_OPTIONS = {
-    // baseUri
-    baseUri: "core.baseUri",
+    // deprecated top-level alias
+    baseUri: "core.baseUrl",
     fetch: "core.fetch",
     mimeType: "core.mimeType",
     fallbackMimeType: "core.fallbackMimeType",
@@ -2421,25 +2511,25 @@ var __exports__ = (() => {
     // Older deprecations
     throws: "nothrow",
     dataType: "(no longer used)",
-    uri: "baseUri",
+    uri: "core.baseUrl",
     // Warn if fetch options are used on toplevel
-    method: "fetch.method",
-    headers: "fetch.headers",
-    body: "fetch.body",
-    mode: "fetch.mode",
-    credentials: "fetch.credentials",
-    cache: "fetch.cache",
-    redirect: "fetch.redirect",
-    referrer: "fetch.referrer",
-    referrerPolicy: "fetch.referrerPolicy",
-    integrity: "fetch.integrity",
-    keepalive: "fetch.keepalive",
-    signal: "fetch.signal"
+    method: "core.fetch.method",
+    headers: "core.fetch.headers",
+    body: "core.fetch.body",
+    mode: "core.fetch.mode",
+    credentials: "core.fetch.credentials",
+    cache: "core.fetch.cache",
+    redirect: "core.fetch.redirect",
+    referrer: "core.fetch.referrer",
+    referrerPolicy: "core.fetch.referrerPolicy",
+    integrity: "core.fetch.integrity",
+    keepalive: "core.fetch.keepalive",
+    signal: "core.fetch.signal"
   };
 
   // ../core/src/lib/loader-utils/option-utils.ts
   var CORE_LOADER_OPTION_KEYS = [
-    "baseUri",
+    "baseUrl",
     "fetch",
     "mimeType",
     "fallbackMimeType",
@@ -2520,14 +2610,18 @@ 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]}'`
-          )();
+          if (probeLog.level > 0) {
+            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}`
-          )();
+          if (probeLog.level > 0) {
+            const suggestion = findSimilarOption(key, loaders);
+            probeLog.warn(
+              `${loaderName} loader option '${prefix}${key}' not recognized. ${suggestion}`
+            )();
+          }
         }
       }
     }
@@ -2585,11 +2679,10 @@ var __exports__ = (() => {
     if (!url) {
       return;
     }
-    const hasTopLevelBaseUri = options.baseUri !== void 0;
-    const hasCoreBaseUri = options.core?.baseUri !== void 0;
-    if (!hasTopLevelBaseUri && !hasCoreBaseUri) {
+    const hasCoreBaseUrl = options.core?.baseUrl !== void 0;
+    if (!hasCoreBaseUrl) {
       options.core ||= {};
-      options.core.baseUri = url;
+      options.core.baseUrl = path_exports.dirname(stripQueryString(url));
     }
   }
   function cloneLoaderOptions(options) {
@@ -2600,6 +2693,12 @@ var __exports__ = (() => {
     return clonedOptions;
   }
   function moveDeprecatedTopLevelOptionsToCore(options) {
+    if (options.baseUri !== void 0) {
+      options.core ||= {};
+      if (options.core.baseUrl === void 0) {
+        options.core.baseUrl = options.baseUri;
+      }
+    }
     for (const key of CORE_LOADER_OPTION_KEYS) {
       if (options[key] !== void 0) {
         const coreOptions = options.core = options.core || {};
@@ -2693,6 +2792,18 @@ var __exports__ = (() => {
     }
     const normalizedOptions = normalizeLoaderOptions(options || {});
     normalizedOptions.core ||= {};
+    if (data instanceof Response && mayContainText(data)) {
+      const text = await data.clone().text();
+      const textLoader = selectLoaderSync(
+        text,
+        loaders,
+        { ...normalizedOptions, core: { ...normalizedOptions.core, nothrow: true } },
+        context
+      );
+      if (textLoader) {
+        return textLoader;
+      }
+    }
     let loader = selectLoaderSync(
       data,
       loaders,
@@ -2706,11 +2817,21 @@ var __exports__ = (() => {
       data = await data.slice(0, 10).arrayBuffer();
       loader = selectLoaderSync(data, loaders, normalizedOptions, context);
     }
+    if (!loader && data instanceof Response && mayContainText(data)) {
+      const text = await data.clone().text();
+      loader = selectLoaderSync(text, loaders, normalizedOptions, context);
+    }
     if (!loader && !normalizedOptions.core.nothrow) {
       throw new Error(getNoValidLoaderMessage(data));
     }
     return loader;
   }
+  function mayContainText(response) {
+    const mimeType = getResourceMIMEType(response);
+    return Boolean(
+      mimeType && (mimeType.startsWith("text/") || mimeType === "application/json" || mimeType.endsWith("+json"))
+    );
+  }
   function selectLoaderSync(data, loaders = [], options, context) {
     if (!validHTTPResponse(data)) {
       return null;
@@ -3351,6 +3472,18 @@ var __exports__ = (() => {
     if (isBlob(url)) {
       data = await fetch2(url);
     }
+    if (typeof url === "string") {
+      const normalizedOptions = normalizeLoaderOptions(resolvedOptions || {});
+      if (!normalizedOptions.core?.baseUrl) {
+        resolvedOptions = {
+          ...resolvedOptions,
+          core: {
+            ...resolvedOptions?.core,
+            baseUrl: url
+          }
+        };
+      }
+    }
     return Array.isArray(resolvedLoaders) ? await parse(data, resolvedLoaders, resolvedOptions) : await parse(data, resolvedLoaders, resolvedOptions);
   }