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

package/LICENSE

@@ -37,7 +37,7 @@ 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.
+under the Apache 2.0 License, including files in modules/3d-tiles.
 
 Copyright 2011-2018 CesiumJS Contributors
 

package/dist/dist.dev.js

@@ -795,17 +795,24 @@ var __exports__ = (() => {
       this.isRunning = false;
       this._reject(error);
     }
-    /** Terminates the worker executing this job and rejects its result with an abort error. */
-    abort() {
+    /**
+     * Terminates the worker executing this job and rejects its result.
+     * @param reason Abort reason supplied by the caller, or a cross-runtime `AbortError`.
+     */
+    abort(reason) {
       if (!this.isRunning) {
         return;
       }
-      const error = new Error(`Worker job "${this.name}" was aborted`);
-      error.name = "AbortError";
+      const error = reason ?? createAbortError(`Worker job "${this.name}" was aborted`);
       this.workerThread.destroy();
       this.error(error);
     }
   };
+  function createAbortError(message) {
+    const error = new Error(message);
+    error.name = "AbortError";
+    return error;
+  }
 
   // ../worker-utils/src/lib/node/worker_threads-browser.ts
   var NodeWorker = class {
@@ -1271,7 +1278,7 @@ var __exports__ = (() => {
   }
   function getWorkerURL(worker, options = {}) {
     const workerOptions = options[worker.id] || {};
-    const workerFile = isBrowser3 ? `${worker.id}-worker.js` : `${worker.id}-worker-node.js`;
+    const workerFile = isBrowser3 ? `${worker.id}-worker.js` : worker.workerNode || `${worker.id}-worker-node.js`;
     let url = workerOptions.workerUrl;
     if (!url && typeof worker.worker === "string") {
       url = worker.worker;
@@ -1337,7 +1344,7 @@ var __exports__ = (() => {
       // eslint-disable-next-line
       onMessage.bind(null, context)
     );
-    const abortJob = () => job.abort();
+    const abortJob = () => job.abort(getAbortReason(options.signal));
     options.signal?.addEventListener("abort", abortJob, { once: true });
     if (options.signal?.aborted) {
       abortJob();
@@ -1363,9 +1370,15 @@ var __exports__ = (() => {
     if (!signal?.aborted) {
       return;
     }
-    const error = new Error("Worker job was aborted");
+    throw getAbortReason(signal);
+  }
+  function getAbortReason(signal) {
+    return signal?.reason ?? createAbortError2("Worker job was aborted");
+  }
+  function createAbortError2(message) {
+    const error = new Error(message);
     error.name = "AbortError";
-    throw error;
+    return error;
   }
   async function onMessage(context, job, type, payload) {
     switch (type) {
@@ -1419,12 +1432,12 @@ var __exports__ = (() => {
     }
     return Boolean(canProcessOnWorker(loader, workerOptions));
   }
-  async function parseWithWorker(loader, data, options, context, parseOnMainThread) {
-    const signal = getWorkerAbortSignal(options);
+  async function parseWithWorker(loader, data, options, context, parseOnMainThread, signal) {
+    const workerSignal = signal || getWorkerAbortSignal(options);
     const result = await processOnWorker(
       loader,
       data,
-      { ...getWorkerOptions(options), signal },
+      { ...getWorkerOptions(options), signal: workerSignal },
       {
         process: async (input, processOptions, _workerContext, parseContext) => {
           if (!parseOnMainThread) {
@@ -1971,6 +1984,114 @@ var __exports__ = (() => {
     }
   };
 
+  // ../loader-utils/src/lib/request-utils/request-credentials.ts
+  var AUTHENTICATED_FETCH = /* @__PURE__ */ Symbol("loaders.gl.authenticated-fetch");
+  var refreshPromises = /* @__PURE__ */ new WeakMap();
+  function createAuthenticatedFetch(options) {
+    const baseFetch = options.fetch || ((url, requestOptions) => fetch(url, requestOptions));
+    if (!options.credentials.length) return baseFetch;
+    const existingMetadata = baseFetch[AUTHENTICATED_FETCH];
+    if (existingMetadata === options.credentials) return baseFetch;
+    const authenticatedFetch = async (url, requestOptions = {}) => {
+      const resolvedURL = parseHTTPURL(url);
+      if (!resolvedURL) return baseFetch(url, requestOptions);
+      const authorization = await authorizeRequest(resolvedURL, requestOptions, options.credentials);
+      const response = await baseFetch(authorization.url, authorization.options);
+      const refreshableCredentials = authorization.credentials.filter(
+        ({ credential }) => typeof credential.token === "function" && credential.refreshStatusCodes.includes(response.status)
+      );
+      if (!refreshableCredentials.length || !isReplayableRequest(requestOptions)) return response;
+      if (requestOptions.signal?.aborted) throw createAbortError3();
+      const refreshedTokens = /* @__PURE__ */ new Map();
+      await Promise.all(
+        refreshableCredentials.map(async ({ credential }) => {
+          const token = await refreshCredential(credential, url, response);
+          if (token) refreshedTokens.set(credential, token);
+        })
+      );
+      if (!refreshedTokens.size) return response;
+      await response.body?.cancel().catch(() => {
+      });
+      if (requestOptions.signal?.aborted) throw createAbortError3();
+      const replayAuthorization = await authorizeRequest(
+        resolvedURL,
+        requestOptions,
+        options.credentials,
+        refreshedTokens,
+        authorization.credentials
+      );
+      return baseFetch(replayAuthorization.url, replayAuthorization.options);
+    };
+    Object.defineProperty(authenticatedFetch, AUTHENTICATED_FETCH, {
+      value: options.credentials
+    });
+    return authenticatedFetch;
+  }
+  async function authorizeRequest(sourceURL, requestOptions, credentials, tokenOverrides = /* @__PURE__ */ new Map(), previousCredentials = []) {
+    const url = new URL(sourceURL);
+    const headers = new Headers(requestOptions.headers);
+    const resolvedCredentials = [];
+    const previousTokens = new Map(
+      previousCredentials.map(({ credential, token }) => [credential, token])
+    );
+    for (const credential of credentials) {
+      if (!credential.origins.includes(url.origin)) continue;
+      const overrideToken = tokenOverrides.get(credential);
+      const previousToken = previousTokens.get(credential);
+      const ownsQueryParameter = credential.type === "query-parameter" && previousToken !== void 0;
+      const ownsHeader = credential.type === "header" && previousToken !== void 0;
+      if (credential.type === "query-parameter" && url.searchParams.has(credential.name) && !ownsQueryParameter || credential.type === "header" && headers.has(credential.name) && !ownsHeader) {
+        continue;
+      }
+      const token = overrideToken ?? previousToken ?? await resolveToken(credential.token, { url: sourceURL.toString(), reason: "request" });
+      if (!token) continue;
+      if (credential.type === "query-parameter") {
+        url.searchParams.set(credential.name, token);
+      } else {
+        headers.set(credential.name, `${credential.prefix || ""}${token}`);
+      }
+      resolvedCredentials.push({ credential, token });
+    }
+    return {
+      url: url.toString(),
+      options: { ...requestOptions, headers },
+      credentials: resolvedCredentials
+    };
+  }
+  async function refreshCredential(credential, url, response) {
+    const existingPromise = refreshPromises.get(credential);
+    if (existingPromise) return existingPromise;
+    const tokenProvider = credential.token;
+    const promise = Promise.resolve(
+      tokenProvider({
+        url,
+        reason: "refresh",
+        response: { status: response.status, headers: response.headers }
+      })
+    ).finally(() => refreshPromises.delete(credential));
+    refreshPromises.set(credential, promise);
+    return promise;
+  }
+  async function resolveToken(token, context) {
+    return typeof token === "function" ? token(context) : token;
+  }
+  function parseHTTPURL(url) {
+    try {
+      const parsedURL = new URL(url);
+      return ["http:", "https:"].includes(parsedURL.protocol) ? parsedURL : null;
+    } catch {
+      return null;
+    }
+  }
+  function isReplayableRequest(options) {
+    const method = (options.method || "GET").toUpperCase();
+    if (!["GET", "HEAD", "OPTIONS", "PUT", "DELETE"].includes(method)) return false;
+    return !(options.body && typeof ReadableStream !== "undefined" && options.body instanceof ReadableStream);
+  }
+  function createAbortError3() {
+    return new DOMException("The operation was aborted.", "AbortError");
+  }
+
   // ../loader-utils/src/lib/path-utils/file-aliases.ts
   var pathPrefix = "";
   var fileAliases = {};
@@ -3455,16 +3576,29 @@ var __exports__ = (() => {
     const globalOptions = getGlobalLoaderOptions();
     const loaderOptions = options || globalOptions;
     const fetchOption = loaderOptions.fetch ?? loaderOptions.core?.fetch;
+    let fetchFunction;
     if (typeof fetchOption === "function") {
-      return fetchOption;
-    }
-    if (isObject(fetchOption)) {
-      return (url) => fetchFile(url, fetchOption);
+      fetchFunction = fetchOption;
+    } else if (isObject(fetchOption)) {
+      fetchFunction = (url, requestOptions) => fetchFile(url, mergeFetchOptions(fetchOption, requestOptions));
+    } else if (context?.fetch) {
+      fetchFunction = context.fetch;
+    } else {
+      fetchFunction = fetchFile;
     }
-    if (context?.fetch) {
-      return context?.fetch;
+    return createAuthenticatedFetch({
+      fetch: fetchFunction,
+      credentials: loaderOptions.core?.credentials || []
+    });
+  }
+  function mergeFetchOptions(defaultOptions, requestOptions) {
+    const options = { ...defaultOptions, ...requestOptions };
+    if (defaultOptions.headers || requestOptions?.headers) {
+      const headers = new Headers(defaultOptions.headers);
+      new Headers(requestOptions?.headers).forEach((value, key) => headers.set(key, value));
+      options.headers = headers;
     }
-    return fetchFile;
+    return options;
   }
 
   // src/lib/api/load-loader.ts
@@ -3679,7 +3813,7 @@ var __exports__ = (() => {
       case "geojson-table":
         return Array.isArray(table.features);
       case "columnar-table":
-        return table.data && typeof table.data === "object";
+        return Boolean(table.data && typeof table.data === "object");
       case "arrow-table":
         return Boolean(table?.data?.numRows !== void 0);
       default:
@@ -3893,6 +4027,15 @@ var __exports__ = (() => {
           }
         );
       }
+      if (selectedLoader && typeof url === "string") {
+        const loaderImplementation = await getLoaderImplementation(
+          selectedLoader,
+          resolvedOptions,
+          url
+        );
+        const parseUrl = loaderImplementation.parseUrl;
+        if (parseUrl) return await parseUrl(url, resolvedOptions, context);
+      }
     }
     const fetch2 = getFetchFunction(resolvedOptions);
     let data = url;
@@ -4375,18 +4518,29 @@ var __exports__ = (() => {
       if (path.includes("://")) {
         return this._fetch(path, options);
       }
-      const file = this.files[path];
+      const file = this._getFile(path, true);
       if (!file) {
         return new Response(path, { status: 400, statusText: "NOT FOUND" });
       }
       const headers = new Headers(options?.headers);
       const range = headers.get("Range");
-      const bytes = range && /bytes=($1)-($2)/.exec(range);
+      const bytes = range && /bytes=(\d+)-(\d+)/.exec(range);
       if (bytes) {
         const start = parseInt(bytes[1]);
-        const end = parseInt(bytes[2]);
-        const data = await file.slice(start, end).arrayBuffer();
-        const response2 = new Response(data);
+        const end = Math.min(parseInt(bytes[2]), file.size - 1);
+        if (start > end) {
+          const response3 = new Response(null, {
+            status: 416,
+            headers: { "Content-Range": `bytes */${file.size}` }
+          });
+          Object.defineProperty(response3, "url", { value: path });
+          return response3;
+        }
+        const data = await file.slice(start, end + 1).arrayBuffer();
+        const response2 = new Response(data, {
+          status: 206,
+          headers: { "Content-Range": `bytes ${start}-${end}/${file.size}` }
+        });
         Object.defineProperty(response2, "url", { value: path });
         return response2;
       }
@@ -4410,7 +4564,7 @@ var __exports__ = (() => {
      * Return information (size) about files in this file system
      */
     async stat(path, options) {
-      const file = this.files[path];
+      const file = this._getFile(path, false);
       if (!file) {
         throw new Error(path);
       }
@@ -4420,19 +4574,22 @@ var __exports__ = (() => {
      * Just removes the file from the list
      */
     async unlink(path) {
-      delete this.files[path];
-      delete this.lowerCaseFiles[path];
-      this.usedFiles[path] = true;
+      const file = this._getFile(path, false);
+      if (file) {
+        delete this.files[file.name];
+        delete this.lowerCaseFiles[file.name.toLowerCase()];
+        this.usedFiles[file.name] = true;
+      }
     }
     // implements IRandomAccessFileSystem
     // RANDOM ACCESS
     async openReadableFile(pathname, flags) {
-      return new BlobFile(this.files[pathname]);
+      return new BlobFile(this._getFile(pathname, true));
     }
     // PRIVATE
     // Supports case independent paths, and file usage tracking
     _getFile(path, used) {
-      const file = this.files[path] || this.lowerCaseFiles[path];
+      const file = this.files[path] || this.lowerCaseFiles[path.toLowerCase()];
       if (file && used) {
         this.usedFiles[path] = true;
       }