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

package/dist/dist.min.js

@@ -15726,6 +15726,10 @@ return true;`);
         return "int32";
       case Uint32Array:
         return "uint32";
+      case BigInt64Array:
+        return "int64";
+      case BigUint64Array:
+        return "uint64";
       case Float32Array:
         return "float32";
       case Float64Array:
@@ -18389,6 +18393,10 @@ return true;`);
       const result = await this.query(options);
       yield makeTableScanBatch(result);
     }
+    /** Scans the addressed query result through the same batch contract as `read()`. */
+    scan(options = {}) {
+      return this.read(options);
+    }
     /** Resolves and caches the addressed table while allowing failed loads to be retried. */
     async getTable(signal) {
       throwIfAborted3(signal);
@@ -18453,7 +18461,8 @@ return true;`);
           Object.freeze([...options.request.boundingBox[1]])
         ])
       });
-      const coordinateReferenceSystems = typeof request.crs === "string" ? [request.crs] : void 0;
+      const boundsCrs = request.requestCrs || request.crs;
+      const coordinateReferenceSystems = typeof boundsCrs === "string" ? [boundsCrs] : void 0;
       super(options, {
         sourceType: "vector-feature-table",
         description: `Vector feature request for ${normalizeLayers(request.layers).join(", ")}`,

package/dist/hudi.cjs

@@ -1047,13 +1047,17 @@ var init_src = __esm({
 
 // ../loader-utils/src/lib/worker-loader-utils/parse-with-worker.ts
 function canParseWithWorker(loader, options) {
-  var _a;
+  var _a, _b, _c;
+  if ((_b = (_a = options == null ? void 0 : options.core) == null ? void 0 : _a.credentials) == null ? void 0 : _b.some(
+    (credential) => credential.type === "request" || "token" in credential && typeof credential.token === "function"
+  ))
+    return false;
   const workerOptions = getWorkerOptions(options);
   const nodeWorkers = workerOptions._nodeWorkers;
   if (!isBrowser2 && !nodeWorkers) {
     return false;
   }
-  if (loader.id === "las" && (((_a = options == null ? void 0 : options.las) == null ? void 0 : _a.shape) ?? "arrow-table") === "arrow-table") {
+  if (loader.id === "las" && (((_c = options == null ? void 0 : options.las) == null ? void 0 : _c.shape) ?? "arrow-table") === "arrow-table") {
     return false;
   }
   if (loader.id === "csv" && !shouldParseCSVWithWorker(options)) {
@@ -1100,7 +1104,12 @@ function callParseOnMainThread(parseOnMainThread, input, options, context) {
   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
@@ -1189,6 +1198,48 @@ 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-cache.ts
 function createAbortError3() {
   const error = new Error("Request aborted");
@@ -1423,21 +1474,54 @@ var init_request_cache = __esm({
 
 // ../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 createAbortError4();
+    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 createAbortError4();
+    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 createAbortError4();
     const refreshedTokens = /* @__PURE__ */ new Map();
     await Promise.all(
       refreshableCredentials.map(async ({ credential }) => {
@@ -1445,24 +1529,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 createAbortError4();
-    const replayAuthorization = await authorizeRequest(
+    if ((_d = requestOptions.signal) == null ? void 0 : _d.aborted) throw createAbortError4();
+    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 createAbortError4();
+    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 createAbortError4();
+  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);
@@ -1531,6 +1702,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();
   }
@@ -1776,6 +1948,7 @@ var init_range_request_scheduler = __esm({
       /** Optional event callback for range batching diagnostics. */
       onEvent;
       pendingRequests = [];
+      /** Pending batch window, independent of in-flight transport requests. */
       flushTimer = null;
       /** Creates a scheduler for one group of byte-range-addressable resources. */
       constructor(props = {}) {
@@ -1852,7 +2025,7 @@ var init_range_request_scheduler = __esm({
       }
       /** Immediately starts loading the currently queued requests. */
       flush() {
-        if (this.flushTimer) {
+        if (this.flushTimer !== null) {
           clearTimeout(this.flushTimer);
           this.flushTimer = null;
         }
@@ -1874,9 +2047,9 @@ var init_range_request_scheduler = __esm({
           this.fetchMergedRequest(mergedRequest);
         }
       }
-      /** Schedules the next pending-request flush. */
+      /** Starts a fixed batch window only when no flush is already scheduled. */
       scheduleFlush() {
-        if (this.flushTimer) {
+        if (this.flushTimer !== null) {
           return;
         }
         this.flushTimer = setTimeout(() => this.flush(), this.props.batchDelayMs);
@@ -2396,39 +2569,25 @@ var init_blob_file = __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) || []
-  });
-}
-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;
+  return getAuthenticatedFetch(options);
 }
-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;
@@ -2466,6 +2625,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"),
@@ -2480,7 +2640,6 @@ var init_data_source = __esm({
         core: {
           type: "auto",
           attributions: [],
-          loadOptions: {},
           loaders: [],
           onError: void 0
         }
@@ -2489,9 +2648,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;
@@ -2499,15 +2658,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;
@@ -2515,7 +2672,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) */
@@ -3014,6 +3175,10 @@ function getDataTypeFromTypedArray(array) {
       return "int32";
     case Uint32Array:
       return "uint32";
+    case BigInt64Array:
+      return "int64";
+    case BigUint64Array:
+      return "uint64";
     case Float32Array:
       return "float32";
     case Float64Array:
@@ -17436,6 +17601,7 @@ function fillParquetValueBuffer(output, value, start, end) {
     return;
   }
   if (Array.isArray(output)) {
+    if (output.length < end) output.length = end;
     output.fill(value, start, end);
     return;
   }
@@ -17881,6 +18047,18 @@ function readUnsignedVarIntNumber(cursor) {
   }
   throw new Error("invalid RLE run header");
 }
+function encodeUnsignedVarIntNumber(value) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new Error("RLE run header must be a non-negative safe integer");
+  }
+  const bytes = [];
+  while (value >= 128) {
+    bytes.push(value % 128 | 128);
+    value = Math.floor(value / 128);
+  }
+  bytes.push(value);
+  return Uint8Array.from(bytes);
+}
 function assertReadable(cursor, byteLength) {
   const size = cursor.size ?? cursor.buffer.length;
   if (byteLength < 0 || cursor.offset + byteLength > size) {
@@ -17902,10 +18080,7 @@ function encodeRunBitpacked(values, opts) {
       buf[Math.floor(b / 8)] |= 1 << b % 8;
     }
   }
-  return concatUint8Arrays([
-    Uint8Array.from(import_varint.default.encode(paddedValues.length / 8 << 1 | 1)),
-    buf
-  ]);
+  return concatUint8Arrays([encodeUnsignedVarIntNumber(paddedValues.length / 8 << 1 | 1), buf]);
 }
 function encodeRunRepeated(value, count, opts) {
   const bitWidth = opts.bitWidth;
@@ -17914,15 +18089,13 @@ function encodeRunRepeated(value, count, opts) {
     buf[i] = value & 255;
     value = Math.floor(value / 256);
   }
-  return concatUint8Arrays([Uint8Array.from(import_varint.default.encode(count << 1)), buf]);
+  return concatUint8Arrays([encodeUnsignedVarIntNumber(count << 1), buf]);
 }
-var import_varint;
 var init_rle = __esm({
   "../parquet/src/parquetjs/codecs/rle.ts"() {
     "use strict";
     init_declare();
     init_binary_utils();
-    import_varint = __toESM(require("varint"), 1);
   }
 });
 
@@ -22875,7 +23048,20 @@ async function filterParquetRowGroupsWithBloomFilters(initialization, rowGroupIn
   let filtersRead = 0;
   let bytesRead = 0;
   for (const rowGroupIndex of rowGroupIndices) {
-    const rowGroup = initialization.metadata.rowGroups[rowGroupIndex];
+    let rowGroup = initialization.metadata.rowGroups[rowGroupIndex];
+    const rawRowGroup = initialization.fileMetadata.row_groups[rowGroupIndex];
+    if (rawRowGroup.columns.some((columnChunk) => columnChunk.encrypted_column_metadata)) {
+      await initialization.reader.resolveColumnMetadata(
+        rawRowGroup,
+        rowGroupIndex,
+        getParquetPredicateColumns(predicate).map((column) => [column])
+      );
+      throwIfAborted2(signal);
+      rowGroup = {
+        ...rowGroup,
+        columns: rawRowGroup.columns.filter((columnChunk) => Boolean(columnChunk.meta_data)).map((columnChunk) => createColumnChunkMetadata(columnChunk, initialization.parquetSchema))
+      };
+    }
     const probes = getParquetBloomFilterProbes(predicate, rowGroup);
     let keepRowGroup = true;
     for (const probe of probes) {