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

package/dist/dist.dev.js

@@ -1700,6 +1700,10 @@ var __exports__ = (() => {
 
   // ../loader-utils/src/lib/worker-loader-utils/parse-with-worker.ts
   function canParseWithWorker(loader, options) {
+    if (options?.core?.credentials?.some(
+      (credential) => credential.type === "request" || "token" in credential && typeof credential.token === "function"
+    ))
+      return false;
     const workerOptions = getWorkerOptions(options);
     const nodeWorkers = workerOptions._nodeWorkers;
     if (!isBrowser3 && !nodeWorkers) {
@@ -1794,7 +1798,12 @@ var __exports__ = (() => {
     return parseOnMainThread(input, void 0, options, context);
   }
   function getWorkerOptions(options = {}, loader) {
-    const serializedOptions = JSON.parse(JSON.stringify(options));
+    const serializedOptions = JSON.parse(
+      JSON.stringify({
+        ...options,
+        ...options.core ? { core: { ...options.core, authentications: void 0 } } : {}
+      })
+    );
     const workerOptions = {
       ...serializedOptions.core,
       ...serializedOptions
@@ -1867,6 +1876,19 @@ var __exports__ = (() => {
     return result.buffer;
   }
 
+  // ../loader-utils/src/lib/binary-utils/encode-array-buffer-to-base64.ts
+  function encodeArrayBufferToBase64(arrayBuffer) {
+    const bytes = new Uint8Array(arrayBuffer);
+    const encodedChunks = [];
+    const chunkByteLength = 3 * 4096;
+    for (let byteOffset = 0; byteOffset < bytes.length; byteOffset += chunkByteLength) {
+      encodedChunks.push(
+        btoa(String.fromCharCode(...bytes.subarray(byteOffset, byteOffset + chunkByteLength)))
+      );
+    }
+    return encodedChunks.join("");
+  }
+
   // ../loader-utils/src/lib/iterators/text-iterators.ts
   async function* makeTextDecoderIterator(arrayBufferIterator, options = {}) {
     const textDecoder = new TextDecoder(void 0, options);
@@ -2193,6 +2215,7 @@ var __exports__ = (() => {
     /** Tracks the number of active requests and prioritizes/cancels queued requests. */
     requestQueue = [];
     requestMap = /* @__PURE__ */ new Map();
+    /** Pending arrival debounce or next-tick refill; only new arrivals replace this timer. */
     updateTimer = null;
     constructor(props = {}) {
       this.props = { ...DEFAULT_PROPS2, ...props };
@@ -2260,20 +2283,27 @@ var __exports__ = (() => {
           isDone = true;
           this.requestMap.delete(handle);
           this.activeRequestCount--;
-          this._issueNewRequests();
+          this.scheduleRefill();
         }
       };
       this.activeRequestCount++;
       return resolve2 ? resolve2({ done }) : Promise.resolve({ done });
     }
-    /** We check requests asynchronously, to prevent multiple updates */
+    /** Refills freed slots on the next tick while preserving any pending arrival debounce. */
+    scheduleRefill() {
+      if (this.updateTimer !== null) {
+        return;
+      }
+      this.updateTimer = setTimeout(() => this._issueNewRequestsAsync(), 0);
+    }
+    /** Restarts the quiet period when a new request enters the queue. */
     _issueNewRequests() {
       if (this.updateTimer !== null) {
         clearTimeout(this.updateTimer);
       }
       this.updateTimer = setTimeout(() => this._issueNewRequestsAsync(), this.props.debounceTime);
     }
-    /** Refresh all requests  */
+    /** Clears timer ownership before updating priorities and dispatching queued requests. */
     _issueNewRequestsAsync() {
       if (this.updateTimer !== null) {
         clearTimeout(this.updateTimer);
@@ -2315,23 +2345,103 @@ var __exports__ = (() => {
     }
   };
 
+  // ../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?.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) {
+    if (!options.core?.credentials?.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 } };
+  }
+  async function resolveLoaderAuthenticationOptions(loader, url, options) {
+    if (!options.core?.credentials?.length || options.core.credentials.every(isAuthentication)) {
+      return options;
+    }
+    const contributions = await loader?.getAuthentications?.(url, options);
+    if (!contributions?.length) return resolveAuthenticationOptions(options);
+    return resolveAuthenticationOptions({
+      ...options,
+      core: {
+        ...options.core,
+        authentications: [...options.core?.authentications || [], ...contributions]
+      }
+    });
+  }
+  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);
+  }
+
   // ../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 suppliedFetch = options.fetch || ((url, requestOptions) => fetch(url, requestOptions));
+    const existingMetadata = suppliedFetch[AUTHENTICATED_FETCH];
+    const credentialResolutions = new Map(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?.credentials.length === resolvedCredentials.length && resolvedCredentials.every(
+      (credential, index) => credential === existingMetadata.credentials[index]
+    )))
+      return suppliedFetch;
+    const baseFetch = existingMetadata?.fetch || suppliedFetch;
+    const credentials = existingMetadata ? [.../* @__PURE__ */ new Set([...resolvedCredentials, ...existingMetadata.credentials])] : resolvedCredentials;
+    const fetchOptions = mergeFetchOptions(
+      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 = {}) => {
+      requestOptions = mergeFetchOptions(fetchOptions, requestOptions);
+      if (requestOptions.signal?.aborted) throw createAbortError3();
+      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;
+      const shouldRetrySignature = signedRequest.credentials.some(
+        (credential) => credential.refreshStatusCodes?.includes(response.status)
+      );
+      if (!refreshableCredentials.length && !shouldRetrySignature || !isReplayableRequest(requestOptions) || !isReplayableRequest(signedRequest.options))
+        return response;
       if (requestOptions.signal?.aborted) throw createAbortError3();
       const refreshedTokens = /* @__PURE__ */ new Map();
       await Promise.all(
@@ -2340,24 +2450,95 @@ var __exports__ = (() => {
           if (token) refreshedTokens.set(credential, token);
         })
       );
-      if (!refreshedTokens.size) return response;
+      if (!refreshedTokens.size && !shouldRetrySignature) return response;
       await response.body?.cancel().catch(() => {
       });
       if (requestOptions.signal?.aborted) throw createAbortError3();
-      const replayAuthorization = await authorizeRequest(
+      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 mergeFetchOptions(defaultOptions, requestOptions) {
+    const mergedOptions = { ...defaultOptions, ...requestOptions };
+    if (defaultOptions.headers || requestOptions?.headers) {
+      const headers = new Headers(defaultOptions.headers);
+      new Headers(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?.aborted) throw createAbortError3();
+      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?.aborted) throw createAbortError3();
+    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);
@@ -2922,19 +3103,11 @@ var __exports__ = (() => {
     }
     if (resource instanceof ArrayBuffer) {
       const slice = resource.slice(0, INITIAL_DATA_LENGTH);
-      const base64 = arrayBufferToBase64(slice);
+      const base64 = encodeArrayBufferToBase64(slice);
       return `data:base64,${base64}`;
     }
     return null;
   }
-  function arrayBufferToBase64(buffer) {
-    let binary = "";
-    const bytes = new Uint8Array(buffer);
-    for (let i = 0; i < bytes.byteLength; i++) {
-      binary += String.fromCharCode(bytes[i]);
-    }
-    return btoa(binary);
-  }
 
   // src/lib/fetch/fetch-file.ts
   function isNodePath(url) {
@@ -3044,6 +3217,7 @@ var __exports__ = (() => {
 
   // src/lib/loader-utils/option-defaults.ts
   var DEFAULT_LOADER_OPTIONS = {
+    searchParams: void 0,
     core: {
       baseUrl: void 0,
       // baseUrl
@@ -3150,6 +3324,27 @@ var __exports__ = (() => {
     "metadata",
     "transforms"
   ];
+  function applySearchParamsToUrl(url, options) {
+    const searchParams = options?.searchParams;
+    if (!searchParams || Object.keys(searchParams).length === 0 || /^(?:data|blob):/i.test(url)) {
+      return url;
+    }
+    const hashIndex = url.indexOf("#");
+    const hash = hashIndex >= 0 ? url.slice(hashIndex) : "";
+    const urlWithoutHash = hashIndex >= 0 ? url.slice(0, hashIndex) : url;
+    const queryIndex = urlWithoutHash.indexOf("?");
+    const path = queryIndex >= 0 ? urlWithoutHash.slice(0, queryIndex) : urlWithoutHash;
+    const query = queryIndex >= 0 ? urlWithoutHash.slice(queryIndex + 1) : "";
+    const existingSearchParams = new URLSearchParams(query);
+    const appendedSearchParams = new URLSearchParams();
+    for (const [key, value] of Object.entries(searchParams)) {
+      if (!existingSearchParams.has(key)) {
+        appendedSearchParams.set(key, String(value));
+      }
+    }
+    const serializedAppendedSearchParams = appendedSearchParams.toString();
+    return `${path}${queryIndex >= 0 ? `?${query}` : ""}${serializedAppendedSearchParams ? `${queryIndex >= 0 ? "&" : "?"}${serializedAppendedSearchParams}` : ""}${hash}`;
+  }
   function getGlobalLoaderState() {
     globalThis.loaders = globalThis.loaders || {};
     const { loaders } = globalThis;
@@ -3922,8 +4117,7 @@ var __exports__ = (() => {
     if (typeof fetchOption === "function") {
       fetchFunction = fetchOption;
     } else if (isObject(fetchOption)) {
-      const baseFetch = context?.fetch || fetchFile;
-      fetchFunction = (url, requestOptions) => baseFetch(url, mergeFetchOptions(fetchOption, requestOptions));
+      fetchFunction = context?.fetch || fetchFile;
     } else if (context?.fetch) {
       fetchFunction = context.fetch;
     } else {
@@ -3931,18 +4125,11 @@ var __exports__ = (() => {
     }
     return createAuthenticatedFetch({
       fetch: fetchFunction,
-      credentials: loaderOptions.core?.credentials || []
+      credentials: loaderOptions.core?.credentials || [],
+      authentications: loaderOptions.core?.authentications,
+      fetchOptions: isObject(fetchOption) ? fetchOption : void 0
     });
   }
-  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 options;
-  }
 
   // src/lib/api/load-loader.ts
   var loaderImplementationPromises = /* @__PURE__ */ new Map();
@@ -4063,7 +4250,13 @@ var __exports__ = (() => {
         `${loader.id} is a SourceLoader. Use load() to create a runtime source object instead of parseFile().`
       );
     }
-    const strictOptions = normalizeOptions(options, loader, candidateLoaders, url);
+    const normalizedOptions = normalizeOptions(options, loader, candidateLoaders, url);
+    const authenticationLoader = !loader.getAuthentications && normalizedOptions.core?.credentials?.length ? await getLoaderImplementation(loader, normalizedOptions, url || context?.url) : loader;
+    const strictOptions = await resolveLoaderAuthenticationOptions(
+      authenticationLoader,
+      url,
+      normalizedOptions
+    );
     context = getLoaderContext(
       // @ts-expect-error candidateLoaders may be a single forced loader
       { url, _parse: parse, loaders: candidateLoaders },
@@ -4203,7 +4396,13 @@ var __exports__ = (() => {
     if (!loader) {
       return [];
     }
-    const strictOptions = normalizeOptions(options, loader, loaderArray, url);
+    const normalizedOptions = normalizeOptions(options, loader, loaderArray, url);
+    const authenticationLoader = !loader.getAuthentications && normalizedOptions.core?.credentials?.length ? await getLoaderImplementation(loader, normalizedOptions, url || context?.url) : loader;
+    const strictOptions = await resolveLoaderAuthenticationOptions(
+      authenticationLoader,
+      url || "",
+      normalizedOptions
+    );
     context = getLoaderContext(
       { url, _parseInBatches: parseInBatches, _parse: parse, loaders: loaderArray },
       strictOptions,
@@ -4288,19 +4487,23 @@ var __exports__ = (() => {
     } else {
       loadersArray = loaders;
     }
-    const fetch2 = getFetchFunction(options || {});
     if (!Array.isArray(files)) {
-      return loadOneFileInBatches(files, loadersArray, options || {}, fetch2);
+      return loadOneFileInBatches(files, loadersArray, options || {});
     }
-    const promises = files.map(
-      (file) => loadOneFileInBatches(file, loadersArray, options || {}, fetch2)
-    );
+    const promises = files.map((file) => loadOneFileInBatches(file, loadersArray, options || {}));
     return promises;
   }
-  async function loadOneFileInBatches(file, loaders, options, fetch2) {
+  async function loadOneFileInBatches(file, loaders, options) {
     if (typeof file === "string") {
       const url = file;
-      const response = await fetch2(url);
+      const loader = await selectLoader(url, loaders, {
+        ...options,
+        core: { ...options.core, nothrow: true }
+      });
+      const authenticationLoader = loader && !loader.getAuthentications && options.core?.credentials?.length ? await getLoaderImplementation(loader, options, url) : loader;
+      options = await resolveLoaderAuthenticationOptions(authenticationLoader, url, options);
+      const fetch2 = getFetchFunction(options);
+      const response = await fetch2(applySearchParamsToUrl(url, options));
       return Array.isArray(loaders) ? await parseInBatches(response, loaders, options) : await parseInBatches(response, loaders, options);
     }
     return Array.isArray(loaders) ? await parseInBatches(file, loaders, options) : await parseInBatches(file, loaders, options);
@@ -4318,8 +4521,14 @@ var __exports__ = (() => {
       resolvedLoaders = loaders;
       resolvedOptions = options;
     }
+    resolvedOptions ||= getGlobalLoaderOptions();
     if (!Array.isArray(resolvedLoaders) && isSourceLoader(resolvedLoaders)) {
       const sourceLoader = await resolveSourceLoader(resolvedLoaders, url, resolvedOptions);
+      resolvedOptions = await resolveLoaderAuthenticationOptions(
+        resolvedLoaders.getAuthentications ? resolvedLoaders : sourceLoader,
+        typeof url === "string" ? url : "",
+        resolvedOptions || {}
+      );
       const runtimeCoreApi = {
         fetchFile,
         parse,
@@ -4337,6 +4546,11 @@ var __exports__ = (() => {
     }
     if (Array.isArray(resolvedLoaders) && resolvedLoaders.length === 1 && isSourceLoader(resolvedLoaders[0])) {
       const sourceLoader = await resolveSourceLoader(resolvedLoaders[0], url, resolvedOptions);
+      resolvedOptions = await resolveLoaderAuthenticationOptions(
+        resolvedLoaders[0].getAuthentications ? resolvedLoaders[0] : sourceLoader,
+        typeof url === "string" ? url : "",
+        resolvedOptions || {}
+      );
       const runtimeCoreApi = {
         fetchFile,
         parse,
@@ -4359,6 +4573,11 @@ var __exports__ = (() => {
       });
       if (selectedLoader && isSourceLoader(selectedLoader)) {
         const sourceLoader = await resolveSourceLoader(selectedLoader, url, resolvedOptions);
+        resolvedOptions = await resolveLoaderAuthenticationOptions(
+          selectedLoader.getAuthentications ? selectedLoader : sourceLoader,
+          typeof url === "string" ? url : "",
+          resolvedOptions || {}
+        );
         return sourceLoader.createDataSource(
           url,
           resolvedOptions || {},
@@ -4379,14 +4598,23 @@ var __exports__ = (() => {
           resolvedOptions,
           url
         );
+        resolvedOptions = await resolveLoaderAuthenticationOptions(
+          selectedLoader.getAuthentications ? selectedLoader : loaderImplementation,
+          url,
+          resolvedOptions || {}
+        );
         const parseUrl = loaderImplementation.parseUrl;
-        if (parseUrl) return await parseUrl(url, resolvedOptions, context);
+        if (parseUrl) {
+          const requestUrl = applySearchParamsToUrl(url, resolvedOptions);
+          return await parseUrl(requestUrl, resolvedOptions, context);
+        }
       }
     }
+    if (resolvedOptions) resolvedOptions = resolveAuthenticationOptions(resolvedOptions);
     const fetch2 = getFetchFunction(resolvedOptions);
     let data = url;
     if (typeof url === "string") {
-      data = await fetch2(url);
+      data = await fetch2(applySearchParamsToUrl(url, resolvedOptions));
     }
     if (isBlob(url)) {
       data = await fetch2(url);
@@ -4488,7 +4716,13 @@ var __exports__ = (() => {
         `${loader.id} is a SourceLoader. Use load() to create a runtime source object instead of parse().`
       );
     }
-    const strictOptions = normalizeOptions(options, loader, candidateLoaders, url);
+    const normalizedOptions = normalizeOptions(options, loader, candidateLoaders, url);
+    const authenticationLoader = !loader.getAuthentications && normalizedOptions.core?.credentials?.length ? await getLoaderImplementation(loader, normalizedOptions, url || context?.url) : loader;
+    const strictOptions = await resolveLoaderAuthenticationOptions(
+      authenticationLoader,
+      url || "",
+      normalizedOptions
+    );
     context = getLoaderContext(
       // @ts-expect-error
       { url, _parse: parse, loaders: candidateLoaders },
@@ -4664,7 +4898,7 @@ var __exports__ = (() => {
   }
 
   // src/lib/api/create-data-source.ts
-  function createDataSource(data, sources, options) {
+  function createDataSource(data, sources, options = {}) {
     const resolvedOptions = options || {};
     const type = resolvedOptions?.core?.type || resolvedOptions.type || "auto";
     const source = sources.length === 1 ? sources[0] : type === "auto" ? selectLoaderSync(data, sources, {
@@ -4676,7 +4910,29 @@ var __exports__ = (() => {
     if (!source) {
       throw new Error("Not a valid source type");
     }
-    return source.createDataSource(data, resolvedOptions, coreApi);
+    const contributions = resolvedOptions.core?.credentials?.length ? source.getAuthentications?.(typeof data === "string" ? data : "", resolvedOptions) : void 0;
+    if (contributions && "then" in contributions) {
+      void contributions.catch(() => {
+      });
+      throw new Error("Use load() with an asynchronous getAuthentications() hook.");
+    }
+    const authenticatedOptions = resolveAuthenticationOptions(
+      contributions?.length ? {
+        ...resolvedOptions,
+        core: {
+          ...resolvedOptions.core,
+          authentications: [
+            ...resolvedOptions.core?.authentications || [],
+            ...contributions || []
+          ]
+        }
+      } : resolvedOptions
+    );
+    return source.createDataSource(
+      data,
+      authenticatedOptions,
+      coreApi
+    );
   }
   function getSourceOfType(type, sources) {
     for (const service of sources) {