@loaders.gl/splats 5.0.0-alpha.7 → 5.0.0-alpha.9

package/dist/index.cjs

@@ -221,23 +221,98 @@ var init_async_iteration = __esm({
   }
 });
 
+// ../loader-utils/src/lib/request-utils/authentication.ts
+function resolveCredentials(credentials, authentications = []) {
+  if (credentials.every(isAuthentication)) return credentials;
+  return credentials.map((credential, index) => {
+    if (isAuthentication(credential)) return credential;
+    const AuthenticationClass = authentications.find(
+      (authentication2) => authentication2.type === (credential == null ? void 0 : credential.type)
+    );
+    if (!AuthenticationClass) {
+      throw new Error(`No authentication class registered for credential at index ${index}.`);
+    }
+    let authentication;
+    try {
+      authentication = new AuthenticationClass(credential);
+    } catch {
+      throw new Error(`Invalid authentication configuration at index ${index}.`);
+    }
+    if (!isAuthentication(authentication)) {
+      throw new Error(`Authentication class returned an invalid credential at index ${index}.`);
+    }
+    return authentication;
+  });
+}
+function resolveAuthenticationOptions(options) {
+  var _a, _b;
+  if (!((_b = (_a = options.core) == null ? void 0 : _a.credentials) == null ? void 0 : _b.length)) return options;
+  const credentials = resolveCredentials(options.core.credentials, options.core.authentications);
+  if (credentials === options.core.credentials) return options;
+  return { ...options, core: { ...options.core, credentials } };
+}
+function isAuthentication(credential) {
+  if (!credential || typeof credential !== "object") return false;
+  if (typeof credential.id !== "string" || !Array.isArray(credential.origins)) return false;
+  if (credential.type === "request") return typeof credential.authenticate === "function";
+  return (credential.type === "header" || credential.type === "query-parameter") && typeof credential.name === "string" && (typeof credential.token === "string" || typeof credential.token === "function") && Array.isArray(credential.refreshStatusCodes);
+}
+var init_authentication = __esm({
+  "../loader-utils/src/lib/request-utils/authentication.ts"() {
+    "use strict";
+  }
+});
+
 // ../loader-utils/src/lib/request-utils/request-credentials.ts
 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 suppliedFetch = options.fetch || ((url, requestOptions) => fetch(url, requestOptions));
+  const existingMetadata = suppliedFetch[AUTHENTICATED_FETCH];
+  const credentialResolutions = new Map(existingMetadata == null ? void 0 : existingMetadata.credentialResolutions);
+  const resolvedCredentials = resolveCredentials(
+    options.credentials.map((credential) => credentialResolutions.get(credential) || credential),
+    options.authentications
+  );
+  options.credentials.forEach((credential, index) => {
+    credentialResolutions.set(credential, resolvedCredentials[index]);
+  });
+  if (!options.fetchOptions && (!resolvedCredentials.length || (existingMetadata == null ? void 0 : existingMetadata.credentials.length) === resolvedCredentials.length && resolvedCredentials.every(
+    (credential, index) => credential === existingMetadata.credentials[index]
+  )))
+    return suppliedFetch;
+  const baseFetch = (existingMetadata == null ? void 0 : existingMetadata.fetch) || suppliedFetch;
+  const credentials = existingMetadata ? [.../* @__PURE__ */ new Set([...resolvedCredentials, ...existingMetadata.credentials])] : resolvedCredentials;
+  const fetchOptions = mergeFetchOptions(
+    (existingMetadata == null ? void 0 : existingMetadata.fetchOptions) || {},
+    options.fetchOptions
+  );
+  const tokenCredentials = credentials.filter(
+    (credential) => credential.type !== "request"
+  );
+  const requestCredentials = credentials.filter(
+    (credential) => credential.type === "request"
+  );
+  for (const credential of requestCredentials) normalizeRequestOrigins(credential.origins);
   const authenticatedFetch = async (url, requestOptions = {}) => {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
+    requestOptions = mergeFetchOptions(fetchOptions, requestOptions);
+    if ((_a = requestOptions.signal) == null ? void 0 : _a.aborted) throw createAbortError();
+    if (!credentials.length) return baseFetch(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 authorization = resolvedURL ? await authorizeRequest(resolvedURL, requestOptions, tokenCredentials) : { url, options: requestOptions, credentials: [] };
+    const signedRequest = await authenticateRequest(authorization, requestCredentials, "request");
+    const response = await baseFetch(signedRequest.url, signedRequest.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 createAbortError();
+    const shouldRetrySignature = signedRequest.credentials.some(
+      (credential) => {
+        var _a2;
+        return (_a2 = credential.refreshStatusCodes) == null ? void 0 : _a2.includes(response.status);
+      }
+    );
+    if (!refreshableCredentials.length && !shouldRetrySignature || !isReplayableRequest(requestOptions) || !isReplayableRequest(signedRequest.options))
+      return response;
+    if ((_b = requestOptions.signal) == null ? void 0 : _b.aborted) throw createAbortError();
     const refreshedTokens = /* @__PURE__ */ new Map();
     await Promise.all(
       refreshableCredentials.map(async ({ credential }) => {
@@ -245,24 +320,111 @@ function createAuthenticatedFetch(options) {
         if (token) refreshedTokens.set(credential, token);
       })
     );
-    if (!refreshedTokens.size) return response;
-    await ((_b = response.body) == null ? void 0 : _b.cancel().catch(() => {
+    if (!refreshedTokens.size && !shouldRetrySignature) return response;
+    await ((_c = response.body) == null ? void 0 : _c.cancel().catch(() => {
     }));
-    if ((_c = requestOptions.signal) == null ? void 0 : _c.aborted) throw createAbortError();
-    const replayAuthorization = await authorizeRequest(
+    if ((_d = requestOptions.signal) == null ? void 0 : _d.aborted) throw createAbortError();
+    const replayAuthorization = resolvedURL ? await authorizeRequest(
       resolvedURL,
       requestOptions,
-      options.credentials,
+      tokenCredentials,
       refreshedTokens,
       authorization.credentials
+    ) : { url, options: requestOptions };
+    const replayRequest = await authenticateRequest(
+      replayAuthorization,
+      requestCredentials,
+      "retry",
+      response
     );
-    return baseFetch(replayAuthorization.url, replayAuthorization.options);
+    return baseFetch(replayRequest.url, replayRequest.options);
   };
   Object.defineProperty(authenticatedFetch, AUTHENTICATED_FETCH, {
-    value: options.credentials
+    value: {
+      fetch: baseFetch,
+      credentials,
+      credentialResolutions,
+      fetchOptions
+    }
   });
   return authenticatedFetch;
 }
+function getAuthenticatedFetch(options = {}) {
+  var _a, _b, _c;
+  const fetchOption = options.fetch ?? ((_a = options.core) == null ? void 0 : _a.fetch);
+  let fetchFunction;
+  if (typeof fetchOption === "function") {
+    fetchFunction = fetchOption;
+  } else {
+    fetchFunction = (url, requestOptions) => fetch(url, requestOptions);
+  }
+  return createAuthenticatedFetch({
+    fetch: fetchFunction,
+    fetchOptions: typeof fetchOption === "object" && fetchOption ? fetchOption : void 0,
+    credentials: ((_b = options.core) == null ? void 0 : _b.credentials) || [],
+    authentications: (_c = options.core) == null ? void 0 : _c.authentications
+  });
+}
+function mergeFetchOptions(defaultOptions, requestOptions) {
+  const mergedOptions = { ...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));
+    mergedOptions.headers = headers;
+  }
+  return mergedOptions;
+}
+async function authenticateRequest(request, credentials, reason, response) {
+  const appliedCredentials = [];
+  const signal = request.options.signal;
+  for (const credential of credentials) {
+    const origin = getRequestOrigin(request.url);
+    if (!origin || !normalizeRequestOrigins(credential.origins).includes(origin)) continue;
+    if (signal == null ? void 0 : signal.aborted) throw createAbortError();
+    const authenticatedRequest = await credential.authenticate({
+      url: request.url,
+      options: { ...request.options, headers: new Headers(request.options.headers) },
+      reason,
+      response: response ? { status: response.status, headers: new Headers(response.headers) } : void 0
+    });
+    if (!authenticatedRequest || typeof authenticatedRequest.url !== "string" || !authenticatedRequest.options || typeof authenticatedRequest.options !== "object") {
+      throw new Error("Authentication callback returned an invalid request.");
+    }
+    request = {
+      url: authenticatedRequest.url,
+      options: { ...authenticatedRequest.options, ...signal ? { signal } : {} }
+    };
+    appliedCredentials.push(credential);
+  }
+  if (signal == null ? void 0 : signal.aborted) throw createAbortError();
+  return { ...request, credentials: appliedCredentials };
+}
+function getRequestOrigin(url) {
+  try {
+    const parsedURL = new URL(url);
+    if (!parsedURL.host || parsedURL.username || parsedURL.password) return null;
+    return parsedURL.origin !== "null" ? parsedURL.origin : `${parsedURL.protocol}//${parsedURL.host}`;
+  } catch {
+    return null;
+  }
+}
+function normalizeRequestOrigins(origins) {
+  if (!origins.length)
+    throw new Error("Request authentication requires at least one exact origin.");
+  return origins.map((origin) => {
+    const resolvedOrigin = getRequestOrigin(origin);
+    let url;
+    try {
+      url = new URL(origin);
+    } catch {
+      throw new Error("Invalid request authentication origin.");
+    }
+    if (!resolvedOrigin || url.pathname && url.pathname !== "/" || url.search || url.hash) {
+      throw new Error("Invalid request authentication origin.");
+    }
+    return resolvedOrigin;
+  });
+}
 async function authorizeRequest(sourceURL, requestOptions, credentials, tokenOverrides = /* @__PURE__ */ new Map(), previousCredentials = []) {
   const url = new URL(sourceURL);
   const headers = new Headers(requestOptions.headers);
@@ -331,6 +493,7 @@ var AUTHENTICATED_FETCH, refreshPromises;
 var init_request_credentials = __esm({
   "../loader-utils/src/lib/request-utils/request-credentials.ts"() {
     "use strict";
+    init_authentication();
     AUTHENTICATED_FETCH = /* @__PURE__ */ Symbol("loaders.gl.authenticated-fetch");
     refreshPromises = /* @__PURE__ */ new WeakMap();
   }
@@ -387,39 +550,25 @@ var init_memory_conversion_utils = __esm({
 
 // ../loader-utils/src/lib/sources/data-source.ts
 function getFetchFunction(options) {
-  var _a, _b;
-  const fetchOption = (options == null ? void 0 : options.fetch) ?? ((_a = options == null ? void 0 : options.core) == null ? void 0 : _a.fetch);
-  let fetchFunction;
-  if (typeof fetchOption === "function") {
-    fetchFunction = (url, fetchOptions) => fetchOption(url, fetchOptions);
-  } else if (fetchOption) {
-    fetchFunction = (url, requestOptions) => fetch(url, mergeFetchOptions(fetchOption, requestOptions));
-  } else {
-    fetchFunction = (url, requestOptions) => fetch(url, requestOptions);
-  }
-  return createAuthenticatedFetch({
-    fetch: fetchFunction,
-    credentials: ((_b = options == null ? void 0 : options.core) == null ? void 0 : _b.credentials) || []
-  });
+  return getAuthenticatedFetch(options);
 }
-function mergeFetchOptions(fetchOptions, requestOptions) {
-  const mergedOptions = { ...fetchOptions, ...requestOptions };
-  if (fetchOptions.headers || (requestOptions == null ? void 0 : requestOptions.headers)) {
-    mergedOptions.headers = mergeHeaders(fetchOptions.headers, requestOptions == null ? void 0 : requestOptions.headers);
-  }
-  return mergedOptions;
-}
-function mergeHeaders(defaultHeaders, requestHeaders) {
-  const headers = new Headers(defaultHeaders);
-  if (requestHeaders) {
-    new Headers(requestHeaders).forEach((value, key) => headers.set(key, value));
+function getSourceLoaderOptions(options) {
+  var _a;
+  if (options.loadOptions !== void 0 || ((_a = options.core) == null ? void 0 : _a.loadOptions) !== void 0) {
+    throw new Error(
+      "Source loadOptions and core.loadOptions were removed. Use core and root loader namespaces directly."
+    );
   }
-  return headers;
-}
-function normalizeDirectLoaderOptions(options) {
   const loadOptions = { ...options };
   if (options == null ? void 0 : options.core) {
     loadOptions.core = { ...options.core };
+    const parserCore = loadOptions.core;
+    for (const key of ["type", "attributions", "loaders", "onError", "loadOptions"]) {
+      delete parserCore[key];
+    }
+    if (Object.keys(parserCore).length === 0) {
+      delete loadOptions.core;
+    }
   }
   const topLevelBaseUri = typeof loadOptions.baseUri === "string" ? loadOptions.baseUri : void 0;
   const topLevelBaseUrl = typeof loadOptions.baseUrl === "string" ? loadOptions.baseUrl : void 0;
@@ -457,6 +606,7 @@ var init_data_source = __esm({
     init_file_aliases();
     init_log();
     init_request_credentials();
+    init_authentication();
     UNAVAILABLE_CORE_API = {
       fetchFile: unavailableCoreApiMethod("fetchFile"),
       parse: unavailableCoreApiMethod("parse"),
@@ -471,7 +621,6 @@ var init_data_source = __esm({
         core: {
           type: "auto",
           attributions: [],
-          loadOptions: {},
           loaders: [],
           onError: void 0
         }
@@ -480,9 +629,9 @@ var init_data_source = __esm({
       options;
       data;
       url;
-      /** The actual load options, if calling a loaders.gl loader */
+      /** Shared parser options derived from the source options, excluding source-only core controls. */
       loadOptions;
-      /** A resolved fetch function extracted from loadOptions prop */
+      /** A resolved fetch function extracted from the shared core options. */
       fetch;
       /** Shared source-level runtime hooks, when supplied by the source factory. */
       coreApi;
@@ -490,15 +639,13 @@ var init_data_source = __esm({
       hasCoreApi;
       _needsRefresh = true;
       constructor(data, options, defaultOptions, coreApi) {
-        var _a;
-        if (defaultOptions) {
-          this.options = mergeOptions({ ...defaultOptions, core: _DataSource.defaultOptions }, options);
-        } else {
-          this.options = { ...options };
-        }
+        this.options = mergeOptions(
+          mergeOptions(_DataSource.defaultOptions, defaultOptions || {}),
+          options
+        );
         this.data = data;
         this.url = typeof data === "string" ? resolvePath(data) : "";
-        const loadOptions = normalizeDirectLoaderOptions((_a = this.options.core) == null ? void 0 : _a.loadOptions);
+        const loadOptions = resolveAuthenticationOptions(getSourceLoaderOptions(this.options));
         this.loadOptions = loadOptions;
         const fetch2 = getFetchFunction(loadOptions);
         this.coreApi = coreApi || UNAVAILABLE_CORE_API;
@@ -506,7 +653,11 @@ var init_data_source = __esm({
         this.fetch = fetch2;
       }
       setProps(options) {
-        this.options = Object.assign(this.options, options);
+        const mergedOptions = mergeOptions(this.options, options);
+        const loadOptions = resolveAuthenticationOptions(getSourceLoaderOptions(mergedOptions));
+        this.options = mergedOptions;
+        this.loadOptions = loadOptions;
+        this.fetch = getFetchFunction(loadOptions);
         this.setNeedsRefresh();
       }
       /** Mark this data source as needing a refresh (redraw) */
@@ -1900,7 +2051,7 @@ var init_splat_loader_types = __esm({
   "dist/splat-loader-types.js"() {
     "use strict";
     init_splats_format();
-    VERSION2 = true ? "5.0.0-alpha.7" : "latest";
+    VERSION2 = true ? "5.0.0-alpha.9" : "latest";
     SPLATLoader = {
       dataType: null,
       batchType: null,
@@ -2225,7 +2376,7 @@ var init_ksplat_loader_types = __esm({
   "dist/ksplat-loader-types.js"() {
     "use strict";
     init_splats_format();
-    VERSION3 = true ? "5.0.0-alpha.7" : "latest";
+    VERSION3 = true ? "5.0.0-alpha.9" : "latest";
     KSPLATLoader = {
       dataType: null,
       batchType: null,
@@ -2270,7 +2421,7 @@ var init_spz_loader_types = __esm({
   "dist/spz-loader-types.js"() {
     "use strict";
     init_splats_format();
-    VERSION4 = true ? "5.0.0-alpha.7" : "latest";
+    VERSION4 = true ? "5.0.0-alpha.9" : "latest";
     SPZLoader = {
       dataType: null,
       batchType: null,
@@ -3021,7 +3172,7 @@ var init_rad_loader_types = __esm({
   "dist/rad-loader-types.js"() {
     "use strict";
     init_splats_format();
-    VERSION5 = true ? "5.0.0-alpha.7" : "latest";
+    VERSION5 = true ? "5.0.0-alpha.9" : "latest";
     RADLoader = {
       dataType: null,
       batchType: null,
@@ -3066,7 +3217,7 @@ init_parse_rad_chunk();
 init_splats_arrow_table();
 var DEFAULT_RAD_HEADER_BYTE_LENGTHS = [64 * 1024, 256 * 1024, 1024 * 1024];
 var DEFAULT_RAD_MAX_CONCURRENT_CHUNK_REQUESTS = 4;
-var VERSION6 = true ? "5.0.0-alpha.7" : "latest";
+var VERSION6 = true ? "5.0.0-alpha.9" : "latest";
 var RADSourceLoader = {
   dataType: null,
   batchType: null,