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

package/dist/index.cjs

@@ -270,17 +270,24 @@ var WorkerJob = class {
     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 {
@@ -748,7 +755,7 @@ function getWorkerName(worker) {
 function getWorkerURL(worker, options = {}) {
   var _a;
   const workerOptions = options[worker.id] || {};
-  const workerFile = isBrowser2 ? `${worker.id}-worker.js` : `${worker.id}-worker-node.js`;
+  const workerFile = isBrowser2 ? `${worker.id}-worker.js` : worker.workerNode || `${worker.id}-worker-node.js`;
   let url = workerOptions.workerUrl;
   if (!url && typeof worker.worker === "string") {
     url = worker.worker;
@@ -815,7 +822,7 @@ async function processOnWorker(worker, data, options = {}, context = {}, jobCont
     // eslint-disable-next-line
     onMessage.bind(null, context)
   );
-  const abortJob = () => job.abort();
+  const abortJob = () => job.abort(getAbortReason(options.signal));
   (_a = options.signal) == null ? void 0 : _a.addEventListener("abort", abortJob, { once: true });
   if ((_b = options.signal) == null ? void 0 : _b.aborted) {
     abortJob();
@@ -841,9 +848,15 @@ function throwIfAborted(signal) {
   if (!(signal == null ? void 0 : signal.aborted)) {
     return;
   }
-  const error = new Error("Worker job was aborted");
+  throw getAbortReason(signal);
+}
+function getAbortReason(signal) {
+  return (signal == null ? void 0 : 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) {
@@ -898,12 +911,12 @@ function canParseWithWorker(loader, options) {
   }
   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) {
@@ -1261,6 +1274,115 @@ var RequestScheduler = class {
   }
 };
 
+// ../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 = {}) => {
+    var _a, _b, _c;
+    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 ((_a = requestOptions.signal) == null ? void 0 : _a.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 ((_b = response.body) == null ? void 0 : _b.cancel().catch(() => {
+    }));
+    if ((_c = requestOptions.signal) == null ? void 0 : _c.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 = {};
@@ -2742,20 +2864,33 @@ function getIterableFromData(data) {
 
 // dist/lib/loader-utils/get-fetch-function.js
 function getFetchFunction(options, context) {
-  var _a;
+  var _a, _b;
   const globalOptions = getGlobalLoaderOptions();
   const loaderOptions = options || globalOptions;
   const fetchOption = loaderOptions.fetch ?? ((_a = loaderOptions.core) == null ? void 0 : _a.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 == null ? void 0 : context.fetch) {
+    fetchFunction = context.fetch;
+  } else {
+    fetchFunction = fetchFile;
   }
-  if (context == null ? void 0 : context.fetch) {
-    return context == null ? void 0 : context.fetch;
+  return createAuthenticatedFetch({
+    fetch: fetchFunction,
+    credentials: ((_b = loaderOptions.core) == null ? void 0 : _b.credentials) || []
+  });
+}
+function mergeFetchOptions(defaultOptions, requestOptions) {
+  const options = { ...defaultOptions, ...requestOptions };
+  if (defaultOptions.headers || (requestOptions == null ? void 0 : requestOptions.headers)) {
+    const headers = new Headers(defaultOptions.headers);
+    new Headers(requestOptions == null ? void 0 : requestOptions.headers).forEach((value, key) => headers.set(key, value));
+    options.headers = headers;
   }
-  return fetchFile;
+  return options;
 }
 
 // dist/lib/api/load-loader.js
@@ -2952,7 +3087,7 @@ function isTable(table) {
     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(((_a = table == null ? void 0 : table.data) == null ? void 0 : _a.numRows) !== void 0);
     default:
@@ -3148,6 +3283,12 @@ async function load(url, loaders, options, context) {
         loadInBatches
       });
     }
+    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;
@@ -3510,7 +3651,7 @@ function makeStream(source, options) {
 }
 
 // dist/null-loader.js
-var VERSION4 = true ? "5.0.0-alpha.2" : "latest";
+var VERSION4 = true ? "5.0.0-alpha.4" : "latest";
 var NullWorkerLoader = {
   dataType: null,
   batchType: null,
@@ -3628,18 +3769,29 @@ var BrowserFileSystem = class {
     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 == null ? void 0 : 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;
     }
@@ -3663,7 +3815,7 @@ var BrowserFileSystem = class {
    * 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);
     }
@@ -3673,19 +3825,22 @@ var BrowserFileSystem = class {
    * 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;
     }