angular-odata 0.163.0 → 0.164.0

package/fesm2022/angular-odata.mjs

@@ -1,6 +1,6 @@
 import { HttpHeaders, HttpParams, HttpResponse, HttpErrorResponse, HttpEventType, provideHttpClient, HttpClient } from '@angular/common/http';
-import { Subject, map as map$1, EMPTY, throwError, Observable, forkJoin, of, NEVER, firstValueFrom } from 'rxjs';
-import { map, expand, reduce, finalize, defaultIfEmpty, switchMap, catchError, startWith, tap } from 'rxjs/operators';
+import { Subject, defer, of, from, ReplaySubject, Subscription, race, EMPTY, throwError, Observable, forkJoin, NEVER, firstValueFrom, map as map$1 } from 'rxjs';
+import { map, tap, catchError, switchMap, finalize, expand, reduce, defaultIfEmpty, startWith } from 'rxjs/operators';
 import * as i0 from '@angular/core';
 import { EventEmitter, Injectable, InjectionToken, provideAppInitializer, inject, makeEnvironmentProviders, NgModule } from '@angular/core';
 import { CommonModule } from '@angular/common';
@@ -195,6 +195,7 @@ const ODATA_ALIAS_PREFIX = '@';
 const NEWLINE = '\r\n';
 const NEWLINE_REGEXP = /\r?\n/;
 const CACHE_KEY_SEPARATOR = ':';
+const CACHE_REPRESENTATION_HEADERS = ['accept', 'accept-language', 'prefer'];
 // Models
 const CID_FIELD_NAME = '_cid';
 const EVENT_SPLITTER = /\s+/;
@@ -5928,6 +5929,8 @@ class ODataRequest {
     withCredentials;
     bodyQueryOptions;
     fetchPolicy;
+    ignoreCacheControl;
+    cacheInvalidation;
     maxAge;
     resource;
     _responseType;
@@ -5954,6 +5957,8 @@ class ODataRequest {
             this._body = this.resource.serialize(this._body, parserOptions);
         this.withCredentials = init.withCredentials ?? apiOptions.withCredentials;
         this.fetchPolicy = init.fetchPolicy ?? apiOptions.fetchPolicy;
+        this.ignoreCacheControl = init.ignoreCacheControl ?? apiOptions.ignoreCacheControl;
+        this.cacheInvalidation = init.cacheInvalidation ?? apiOptions.cacheInvalidation;
         this.maxAge = init.maxAge;
         this.bodyQueryOptions = [
             ...(apiOptions.bodyQueryOptions ?? []),
@@ -6052,6 +6057,8 @@ class ODataRequest {
             reportProgress: options.reportProgress,
             responseType: options.responseType,
             fetchPolicy: options.fetchPolicy,
+            ignoreCacheControl: options.ignoreCacheControl,
+            cacheInvalidation: options.cacheInvalidation,
             maxAge: options.maxAge,
             parserOptions: options.parserOptions,
             withCredentials: options.withCredentials,
@@ -6096,8 +6103,29 @@ class ODataRequest {
     get urlWithParams() {
         return `${this.api.serviceRootUrl}${this.pathWithParams}`;
     }
+    /** A versioned response identity that includes the API and transport representation. */
     get cacheKey() {
-        return this._params.keys().length > 0 ? `${this._path}?${this._params}` : this._path;
+        return [
+            'v2',
+            this.api.serviceRootUrl,
+            JSON.stringify(this.api.name ?? null),
+            this._path,
+            this._params.toString(),
+            this.responseType ?? 'json',
+            String(this.withCredentials ?? false),
+            String(this.ignoreCacheControl),
+            ...CACHE_REPRESENTATION_HEADERS.map((name) => JSON.stringify(this.headers.getAll(name))),
+        ]
+            .map((part) => part.replace(/%/g, '%25').replace(/\|/g, '%7C'))
+            .join('|');
+    }
+    /** The versioned response-cache partition belonging to this API. */
+    get cacheScope() {
+        return [
+            'request',
+            'v2',
+            encodeURIComponent(JSON.stringify([this.api.serviceRootUrl, this.api.name ?? null])),
+        ];
     }
     isQueryBody() {
         return (this._method === 'GET' &&
@@ -6557,16 +6585,6 @@ class ODataActionResource extends ODataResource {
     }
 }
 
-const Arrays = {
-    // Zip arrays
-    // Example
-    //   Arrays.zip([1, 2, 3, 4, 5, 6], ['a', 'b', 'c', 'd', 'e', 'f'])
-    //   => [[1, 'a'], [2, 'b'], [3, 'c'], [4, 'd'], [5, 'e'], [6, 'f']]
-    zip: (...arrays) => {
-        return arrays[0].map((_, i) => arrays.map((array) => array[i]));
-    },
-};
-
 class ODataBatchRequest extends Subject {
     request;
     id;
@@ -6664,103 +6682,144 @@ class ODataBatchResource extends ODataResource {
         return batch;
     }
     //#endregion
-    storeRequester() {
-        const current = this.api.requester;
-        // Switch to the batch requester
-        this.api.requester = (req) => {
-            if (req.api !== this.api)
-                throw new Error('Batch Request are for the same api.');
-            if (req.observe === 'events')
-                throw new Error("Batch Request does not allows observe == 'events'.");
-            this._requests.push(new ODataBatchRequest(req));
-            return this._requests[this._requests.length - 1];
-        };
-        return current;
-    }
-    restoreRequester(handler) {
-        this.api.requester = handler;
-    }
     /**
      * Add to batch request
      * @param ctx The context for the request
      * @returns The result of execute the context
      */
     add(ctx) {
-        // Store original requester
-        var handler = this.storeRequester();
-        // Execute the context
-        const result = ctx(this);
-        // Restore original requester
-        this.restoreRequester(handler);
-        return result;
+        return this.api.captureRequests((req) => {
+            if (req.api !== this.api)
+                throw new Error('Batch Request are for the same api.');
+            if (req.observe === 'events')
+                throw new Error("Batch Request does not allows observe == 'events'.");
+            const request = new ODataBatchRequest(req);
+            this._requests.push(request);
+            return request;
+        }, () => ctx(this));
     }
+    /** Send collected requests, evaluating their cache policies when subscribed. */
     send(options) {
-        if (this.api.options.jsonBatchFormat) {
-            return this.sendJson(options);
-        }
-        else {
-            return this.sendLegacy(options);
+        return defer(() => {
+            const readsCache = this._requests.some(({ request }) => request.isFetch() &&
+                request.fetchPolicy !== 'network-only' &&
+                request.fetchPolicy !== 'no-cache');
+            let readiness = defer(() => {
+                const ready = readsCache ? this.api.cache?.ready?.() : undefined;
+                return ready === undefined ? of(undefined) : from(ready);
+            }).pipe(tap({
+                error: (error) => this._requests.forEach((request) => request.error(error)),
+            }));
+            if (this.api.errorHandler !== undefined) {
+                readiness = readiness.pipe(catchError(this.api.errorHandler));
+            }
+            return readiness.pipe(switchMap(() => this.sendRequests(options)));
+        });
+    }
+    sendRequests(options) {
+        const outgoing = [];
+        const responses = new Map();
+        const responseErrors = new Set();
+        const cacheErrors = new ReplaySubject(1);
+        let dispatchingResponses = false;
+        let pendingCacheError;
+        const subscriptions = new Subscription();
+        for (const request of this._requests) {
+            subscriptions.add(this.api
+                .executeRequest(request.request, () => {
+                const response = new Subject();
+                responses.set(request, response);
+                outgoing.push(request);
+                return response;
+            }, true)
+                .subscribe({
+                next: (response) => request.next(response),
+                error: (error) => {
+                    request.error(error);
+                    if (responseErrors.has(error) || this.api.isCacheMiss(error))
+                        return;
+                    if (dispatchingResponses)
+                        pendingCacheError ??= { error };
+                    else
+                        cacheErrors.error(error);
+                },
+                complete: () => request.complete(),
+            }));
         }
+        const result = defer(() => this.api.options.jsonBatchFormat
+            ? this.sendJson(outgoing, options).pipe(map((response) => ({
+                response,
+                parsed: ODataBatchResource.parseJsonResponse(outgoing, response),
+            })))
+            : this.sendLegacy(outgoing, options).pipe(map((response) => ({
+                response,
+                parsed: ODataBatchResource.parseLegacyResponse(outgoing, response),
+            }))));
+        const resultWithResponses = result.pipe(map(({ response, parsed }) => {
+            this._responses = [...(this._responses ?? []), ...parsed];
+            dispatchingResponses = true;
+            outgoing.forEach((request, index) => {
+                const result = parsed[index];
+                const stream = responses.get(request);
+                if (result === undefined) {
+                    const error = new Error('Missing batch response');
+                    responseErrors.add(error);
+                    stream.error(error);
+                }
+                else if (result.ok) {
+                    stream.next(result);
+                    stream.complete();
+                }
+                else {
+                    responseErrors.add(result);
+                    stream.error(result);
+                }
+            });
+            dispatchingResponses = false;
+            if (pendingCacheError !== undefined)
+                cacheErrors.error(pendingCacheError.error);
+            return response;
+        }));
+        const failures = this.api.errorHandler === undefined
+            ? cacheErrors
+            : cacheErrors.pipe(catchError(this.api.errorHandler));
+        return race(failures, resultWithResponses).pipe(tap({
+            error: (error) => {
+                responseErrors.add(error);
+                responses.forEach((response) => response.error(error));
+                this._requests.forEach((request) => request.error(error));
+            },
+            complete: () => this._requests.forEach((request) => request.complete()),
+        }), finalize(() => subscriptions.unsubscribe()));
     }
-    sendJson(options) {
+    sendJson(requests, options) {
         const headers = Http.mergeHttpHeaders((options && options.headers) || {}, {
             [ODATA_VERSION]: VERSION_4_0,
         });
-        return this.api
-            .request('POST', this, {
-            body: ODataBatchResource.buildJsonBody(this._requests, this.api.options),
+        return this.api.request('POST', this, {
+            body: ODataBatchResource.buildJsonBody(requests, this.api.options),
             responseType: 'json',
             observe: 'response',
             headers: headers,
             params: options ? options.params : undefined,
             withCredentials: options ? options.withCredentials : undefined,
-        })
-            .pipe(map$1((response) => {
-            if (this._responses == null) {
-                this._responses = [];
-            }
-            this._responses = [
-                ...this._responses,
-                ...ODataBatchResource.parseJsonResponse(this._requests, response),
-            ];
-            //HACK: tuple[1] === undefined
-            Arrays.zip(this._requests, this._responses).forEach((tuple) => {
-                if (!tuple[0].isStopped && tuple[1])
-                    tuple[0].onLoad(tuple[1]);
-            });
-            return response;
-        }));
+        });
     }
-    sendLegacy(options) {
+    sendLegacy(requests, options) {
         const bound = Strings.uniqueId({ prefix: BATCH_PREFIX });
         const headers = Http.mergeHttpHeaders((options && options.headers) || {}, {
             [ODATA_VERSION]: VERSION_4_0,
             [CONTENT_TYPE]: MULTIPART_MIXED_BOUNDARY + bound,
             [ACCEPT]: MULTIPART_MIXED,
         });
-        return this.api
-            .request('POST', this, {
-            body: ODataBatchResource.buildLegacyBody(bound, this._requests, this.api.options),
+        return this.api.request('POST', this, {
+            body: ODataBatchResource.buildLegacyBody(bound, requests, this.api.options),
             responseType: 'text',
             observe: 'response',
             headers: headers,
             params: options ? options.params : undefined,
             withCredentials: options ? options.withCredentials : undefined,
-        })
-            .pipe(map$1((response) => {
-            if (this._responses == null) {
-                this._responses = [];
-            }
-            this._responses = [
-                ...this._responses,
-                ...ODataBatchResource.parseLegacyResponse(this._requests, response),
-            ];
-            Arrays.zip(this._requests, this._responses).forEach((tuple) => {
-                if (!tuple[0].isStopped && tuple[1])
-                    tuple[0].onLoad(tuple[1]);
-            });
-            return response;
-        }));
+        });
     }
     /**
      * Execute the batch request
@@ -6770,7 +6829,7 @@ class ODataBatchResource extends ODataResource {
      */
     exec(ctx, options) {
         let result = this.add(ctx);
-        return this.send(options).pipe(map$1((response) => [result, response]));
+        return this.send(options).pipe(map((response) => [result, response]));
     }
     body() {
         return ODataBatchResource.buildLegacyBody(Strings.uniqueId({ prefix: BATCH_PREFIX }), this._requests, this.api.options);
@@ -6940,21 +6999,29 @@ class ODataBatchResource extends ODataResource {
         });
     }
     static parseJsonResponse(requests, response) {
-        const responses = (response.body ? response.body : {})['responses'] ?? [];
-        return responses.map((response, index) => {
-            let request = requests[index].request;
-            let code = response['status'];
-            let headers = new HttpHeaders(response['headers']);
-            let body = response['body'];
+        const responses = response.body?.['responses'] ?? [];
+        return requests.map(({ request, id }, index) => {
+            const response = responses.find((response) => response.id === id) ??
+                (responses[index]?.id ? undefined : responses[index]);
+            if (response === undefined) {
+                return new HttpErrorResponse({
+                    error: new Error('Missing batch response'),
+                    status: 0,
+                    url: request.urlWithParams,
+                });
+            }
+            let code = response.status;
+            const headers = new HttpHeaders(response.headers);
+            let body = response.body;
             if (code === 0) {
                 code = !!body ? 200 : 0;
             }
             let ok = code >= 200 && code < 300;
             if (request.responseType === 'json' && typeof body === 'string') {
                 const originalBody = body;
-                body = body.replace(XSSI_PREFIX, '');
+                const text = body.replace(XSSI_PREFIX, '');
                 try {
-                    body = body !== '' ? JSON.parse(body) : null;
+                    body = text !== '' ? JSON.parse(text) : null;
                 }
                 catch (error) {
                     body = originalBody;
@@ -10183,16 +10250,30 @@ class ODataResponseOptions {
         });
     }
     setCache(cacheControl) {
-        cacheControl.split(',').forEach((directive) => {
-            if (directive.startsWith(MAX_AGE)) {
-                let maxAge = Number(directive.split('=')[1]);
-                if (!Number.isNaN(maxAge))
-                    this.maxAge = maxAge;
-            }
-            if (['public', 'private', 'no-cache', 'no-store'].indexOf(directive) !== -1) {
-                this.cacheability = directive;
+        const precedence = ['public', 'private', 'no-cache', 'no-store'];
+        this.cacheability = undefined;
+        this.maxAge = undefined;
+        for (const directive of cacheControl.split(',')) {
+            const separator = directive.indexOf('=');
+            const name = (separator < 0 ? directive : directive.slice(0, separator)).trim().toLowerCase();
+            const value = separator < 0
+                ? ''
+                : directive
+                    .slice(separator + 1)
+                    .trim()
+                    .replace(/^"(.*)"$/, '$1');
+            if (name === MAX_AGE) {
+                const maxAge = /^\d+$/.test(value) ? Number(value) : NaN;
+                const seconds = Number.isFinite(maxAge * 1000) ? maxAge : 0;
+                this.maxAge = Math.min(this.maxAge ?? Infinity, seconds);
+            }
+            const cacheability = precedence.find((candidate) => candidate === name);
+            if (cacheability !== undefined &&
+                (this.cacheability === undefined ||
+                    precedence.indexOf(cacheability) > precedence.indexOf(this.cacheability))) {
+                this.cacheability = cacheability;
             }
-        });
+        }
     }
 }
 
@@ -10241,6 +10322,17 @@ class ODataResponse extends HttpResponse {
             url: this.url,
         };
     }
+    /** Whether the response can be reused without server validation. */
+    isCacheable(ignoreCacheControl = false) {
+        const vary = (this.headers.getAll('Vary') ?? [])
+            .flatMap((value) => value.split(','))
+            .map((name) => name.trim().toLowerCase())
+            .filter((name) => name.length > 0);
+        return (this.ok &&
+            (ignoreCacheControl ||
+                (this.options.cacheability !== 'no-store' && this.options.cacheability !== 'no-cache')) &&
+            vary.every((name) => CACHE_REPRESENTATION_HEADERS.includes(name)));
+    }
     _options;
     get options() {
         if (this._options === undefined) {
@@ -12916,6 +13008,10 @@ class ODataApiOptions {
      * Cache fetch policy
      */
     fetchPolicy;
+    /** Ignore response Cache-Control directives. Defaults to false. */
+    ignoreCacheControl;
+    /** Scope invalidated by successful writes. Defaults to entity-set. */
+    cacheInvalidation;
     /**
      * Extra params to be sent in the request
      */
@@ -12947,6 +13043,8 @@ class ODataApiOptions {
         this.withCredentials = config.withCredentials;
         this.stripMetadata = config.stripMetadata || DEFAULT_STRIP_METADATA;
         this.fetchPolicy = config.fetchPolicy || DEFAULT_FETCH_POLICY;
+        this.ignoreCacheControl = config.ignoreCacheControl ?? false;
+        this.cacheInvalidation = config.cacheInvalidation ?? 'entity-set';
         this.bodyQueryOptions = config.bodyQueryOptions || [];
         this.accept = config.accept;
         Object.assign(this.etag, config.etag || {});
@@ -13016,11 +13114,15 @@ class ODataReference extends ODataAnnotatable {
 }
 
 const RESERVED_FIELD_NAMES = Object.getOwnPropertyNames(ODataModel.prototype);
+// Share invalidation generations across API instances using the same cache.
+const CACHE_GENERATIONS = new WeakMap();
+const CACHE_MISSES = new WeakSet();
 /**
  * Api abstraction for consuming OData services.
  */
 class ODataApi {
     requester;
+    _requestCapture;
     serviceRootUrl;
     metadataUrl;
     name;
@@ -13212,6 +13314,8 @@ class ODataApi {
             bodyQueryOptions: options.bodyQueryOptions,
             reportProgress: options.reportProgress,
             fetchPolicy: options.fetchPolicy,
+            ignoreCacheControl: options.ignoreCacheControl,
+            cacheInvalidation: options.cacheInvalidation,
             maxAge: options.maxAge,
             parserOptions: options.parserOptions,
             withCredentials: options.withCredentials,
@@ -13251,53 +13355,100 @@ class ODataApi {
      * @returns
      */
     handleRequest(req) {
-        return this.cache !== undefined && req.isFetch()
-            ? this.handleCacheFetch(req)
-            : this.cache !== undefined && req.isMutate()
-                ? this.handleCacheMutate(req)
-                : this.handleRequester(req);
-    }
-    handleRequester(req) {
-        return (this.requester !== undefined ? this.requester(req) : NEVER).pipe(map((res) => res.type === HttpEventType.Response ? ODataResponse.fromHttpResponse(req, res) : res));
-    }
-    handleCacheFetch(req) {
+        return this._requestCapture !== undefined
+            ? this.handleRequester(req, this._requestCapture)
+            : this.executeRequest(req);
+    }
+    /** @internal Collect batch requests synchronously without executing their cache effects. */
+    captureRequests(capture, callback) {
+        const previous = this._requestCapture;
+        this._requestCapture = capture;
+        try {
+            return callback();
+        }
+        finally {
+            this._requestCapture = previous;
+        }
+    }
+    /** @internal Execute a collected or ordinary request with subscription-time cache semantics. */
+    executeRequest(req, requester = this.requester, cacheReady = false) {
+        return defer(() => {
+            const cache = this.cache;
+            const network = () => this.handleRequester(req, requester);
+            if (cache === undefined)
+                return network();
+            if (req.isFetch()) {
+                if (req.fetchPolicy === 'no-cache')
+                    return network();
+                const fetch = () => this.handleCacheFetch(req, cache, network);
+                return !cacheReady && req.fetchPolicy !== 'network-only' && cache.ready !== undefined
+                    ? from(cache.ready()).pipe(switchMap(fetch))
+                    : fetch();
+            }
+            return req.isMutate() && !req.isBatch()
+                ? network().pipe(tap((res) => {
+                    if (res.type === HttpEventType.Response && res.ok)
+                        this.invalidateCache(req, cache);
+                }))
+                : network();
+        });
+    }
+    /** @internal Whether the error is a `cache-only` miss rather than a cache failure. */
+    isCacheMiss(error) {
+        return error instanceof Error && CACHE_MISSES.has(error);
+    }
+    handleRequester(req, requester) {
+        return (requester !== undefined ? requester(req) : NEVER).pipe(map((res) => res.type === HttpEventType.Response ? ODataResponse.fromHttpResponse(req, res) : res));
+    }
+    cacheGeneration(req, cache) {
+        const generations = CACHE_GENERATIONS.get(cache);
+        const apiKey = JSON.stringify(req.cacheScope);
+        const scopeKey = JSON.stringify(cache.scope(req));
+        return ((generations?.get(apiKey) ?? 0) +
+            (scopeKey !== apiKey ? generations?.get(scopeKey) ?? 0 : 0));
+    }
+    invalidateCache(req, cache) {
+        let generations = CACHE_GENERATIONS.get(cache);
+        if (generations === undefined) {
+            generations = new Map();
+            CACHE_GENERATIONS.set(cache, generations);
+        }
+        const scope = cache.scope(req);
+        // Custom scopes outside the API partition use scoped invalidation.
+        const target = req.cacheInvalidation === 'api' &&
+            req.cacheScope.every((part, index) => scope[index] === part) ? req.cacheScope : scope;
+        const key = JSON.stringify(target);
+        generations.set(key, (generations.get(key) ?? 0) + 1);
+        cache.forget({ scope: target });
+    }
+    handleCacheFetch(req, cache, network) {
         const policy = req.fetchPolicy;
-        const cached = this.cache.getResponse(req);
-        if (policy === 'no-cache') {
-            return this.handleRequester(req);
-        }
+        const cached = policy === 'network-only' ? undefined : cache.getResponse(req);
         if (policy === 'cache-only') {
-            if (cached !== undefined) {
+            if (cached !== undefined)
                 return of(cached);
+            const miss = new Error('No Cached');
+            CACHE_MISSES.add(miss);
+            return throwError(() => miss);
+        }
+        if (cached !== undefined && policy === 'cache-first')
+            return of(cached);
+        const generation = this.cacheGeneration(req, cache);
+        const response = defer(network).pipe(tap((res) => {
+            if (res.type !== HttpEventType.Response ||
+                !res.ok ||
+                generation !== this.cacheGeneration(req, cache)) {
+                return;
             }
-            else {
-                return throwError(() => new Error('No Cached'));
-            }
-        }
-        let res$ = cached !== undefined && policy !== 'network-only'
-            ? policy === 'cache-and-network'
-                ? this.handleRequester(req).pipe(startWith(cached))
-                : of(cached)
-            : this.handleRequester(req);
-        if (cached === undefined &&
-            (policy === 'cache-first' || policy === 'cache-and-network' || policy === 'network-only')) {
-            res$ = res$.pipe(tap((res) => {
-                if (res.options.cacheability !== 'no-store') {
-                    this.cache.putResponse(req, res);
-                }
-            }));
-        }
-        return res$;
-    }
-    handleCacheMutate(req) {
-        const requests = req.isBatch()
-            ? req.resource.requests().filter((r) => r.isMutate())
-            : [req];
-        for (var r of requests) {
-            const scope = this.cache.scope(r);
-            this.cache.forget({ scope });
-        }
-        return this.handleRequester(req);
+            const response = res instanceof ODataResponse ? res : ODataResponse.fromHttpResponse(req, res);
+            if (response.isCacheable(req.ignoreCacheControl))
+                cache.putResponse(req, response);
+            else
+                cache.forget({ name: req.cacheKey, scope: cache.scope(req) });
+        }));
+        return cached !== undefined && policy === 'cache-and-network'
+            ? response.pipe(startWith(cached))
+            : response;
     }
     //# region Find by Type
     // Memoize
@@ -13713,6 +13864,8 @@ function addBody(options, body) {
         body,
         etag: options.etag,
         fetchPolicy: options.fetchPolicy,
+        ignoreCacheControl: options.ignoreCacheControl,
+        cacheInvalidation: options.cacheInvalidation,
         headers: options.headers,
         observe: options.observe,
         params: options.params,
@@ -14280,8 +14433,12 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.5", ngImpor
 
 class ODataBaseCache {
     maxAge;
-    constructor({ maxAge = DEFAULT_MAXAGE }) {
+    _onError;
+    _error;
+    constructor({ maxAge = DEFAULT_MAXAGE, onError, }) {
+        this.validateMaxAge(maxAge);
         this.maxAge = maxAge;
+        this._onError = onError;
     }
     /**
      * Check if the entry is expired
@@ -14289,7 +14446,7 @@ class ODataBaseCache {
      * @returns Boolean indicating if the entry is expired
      */
     isExpired(entry) {
-        return entry.date < Date.now() - entry.maxAge;
+        return entry.date <= Date.now() - entry.maxAge;
     }
     /**
      * Using the resource on the request build an array of string to identify the scope of the request
@@ -14298,11 +14455,11 @@ class ODataBaseCache {
      */
     scope(req) {
         const segments = req.resource.cloneSegments();
-        return segments.segments({ key: true }).reduce((acc, s) => {
-            if (s.name === PathSegment.entitySet)
+        return segments.segments().reduce((acc, s) => {
+            if (s.name === PathSegment.entitySet || s.name === PathSegment.singleton)
                 acc = [...acc, s.path()];
             return acc;
-        }, ['request']);
+        }, req.cacheScope);
     }
     /**
      * Using the odata context on the response build an array of string to identify the tags of the response
@@ -14327,11 +14484,13 @@ class ODataBaseCache {
      * @returns The entry to store in the cache
      */
     buildEntry(payload, { maxAge, tags }) {
+        const seconds = maxAge ?? this.maxAge;
+        this.validateMaxAge(seconds);
         return {
             payload,
             date: Date.now(),
-            maxAge: (maxAge ?? this.maxAge) * 1000,
-            tags: tags ?? [],
+            maxAge: seconds * 1000,
+            tags: [...(tags ?? [])],
         };
     }
     /**
@@ -14342,14 +14501,147 @@ class ODataBaseCache {
     buildKey(names) {
         return names.join(CACHE_KEY_SEPARATOR);
     }
+    validateMaxAge(maxAge) {
+        if (!Number.isFinite(maxAge * 1000) || maxAge < 0) {
+            throw new RangeError('Cache maxAge must be a finite, non-negative number of seconds');
+        }
+    }
+    reportError(message, cause) {
+        const error = new Error(message, { cause });
+        if (this._onError !== undefined)
+            this._onError(error);
+        else {
+            this._error = error;
+            throw error;
+        }
+    }
+    /** Report a discarded entry; corrupt entries are treated as cache misses. */
+    reportCorruption(message, cause) {
+        this._onError?.(new Error(message, { cause }));
+    }
+    checkError() {
+        if (this._error !== undefined)
+            throw this._error;
+    }
+    isEntry(value) {
+        return (typeof value === 'object' &&
+            value !== null &&
+            'payload' in value &&
+            'date' in value &&
+            typeof value.date === 'number' &&
+            Number.isFinite(value.date) &&
+            'maxAge' in value &&
+            typeof value.maxAge === 'number' &&
+            Number.isFinite(value.maxAge) &&
+            value.maxAge >= 0 &&
+            'tags' in value &&
+            Array.isArray(value.tags) &&
+            value.tags.every((tag) => typeof tag === 'string'));
+    }
+    matches(key, entry, { name, scope = [], tags = [] }) {
+        const scopedKey = this.buildKey(name !== undefined ? [...scope, name] : scope);
+        return (this.isExpired(entry) ||
+            (name !== undefined
+                ? key === scopedKey
+                : scope.length > 0 &&
+                    (key === scopedKey || key.startsWith(`${scopedKey}${CACHE_KEY_SEPARATOR}`))) ||
+            tags.some((tag) => entry.tags.includes(tag)));
+    }
+    isResponseJson(value) {
+        return (typeof value === 'object' &&
+            value !== null &&
+            'body' in value &&
+            'status' in value &&
+            typeof value.status === 'number' &&
+            Number.isInteger(value.status) &&
+            'statusText' in value &&
+            typeof value.statusText === 'string' &&
+            'url' in value &&
+            (value.url === null || typeof value.url === 'string') &&
+            'headers' in value &&
+            typeof value.headers === 'object' &&
+            value.headers !== null &&
+            !Array.isArray(value.headers) &&
+            Object.values(value.headers).every((header) => typeof header === 'string' ||
+                (Array.isArray(header) && header.every((part) => typeof part === 'string'))));
+    }
+    snapshot(response) {
+        const body = response.body;
+        return {
+            ...response,
+            body: typeof Blob !== 'undefined' && body instanceof Blob
+                ? body.slice(0, body.size, body.type)
+                : structuredClone(body),
+            headers: structuredClone(response.headers),
+        };
+    }
+    /** Store a detached response snapshot, respecting server reuse restrictions. */
+    putResponse(req, res) {
+        const scope = this.scope(req);
+        if (!res.isCacheable(req.ignoreCacheControl)) {
+            this.forget({ name: req.cacheKey, scope });
+            return;
+        }
+        this.put(req.cacheKey, this.snapshot(res.toJson()), {
+            maxAge: req.maxAge ?? (req.ignoreCacheControl ? undefined : res.options.maxAge),
+            scope,
+            tags: this.tags(res),
+        });
+    }
+    /** Restore a detached response using the current request's resource and parser. */
+    getResponse(req) {
+        const scope = this.scope(req);
+        const data = this.get(req.cacheKey, { scope });
+        if (data === undefined)
+            return undefined;
+        if (!this.isResponseJson(data)) {
+            this.forget({ name: req.cacheKey, scope });
+            this.reportCorruption('Discarding an invalid cached OData response');
+            return undefined;
+        }
+        const response = ODataResponse.fromJson(req, this.snapshot(data));
+        if (!response.isCacheable(req.ignoreCacheControl)) {
+            this.forget({ name: req.cacheKey, scope });
+            return undefined;
+        }
+        return response;
+    }
 }
 
 class ODataInMemoryCache extends ODataBaseCache {
     entries;
-    constructor({ maxAge } = {}) {
-        super({ maxAge });
+    _nextExpiry = Infinity;
+    constructor(options = {}) {
+        super(options);
         this.entries = new Map();
     }
+    setEntry(key, entry) {
+        this.entries.set(key, entry);
+        this._nextExpiry = Math.min(this._nextExpiry, entry.date + entry.maxAge);
+    }
+    deleteEntry(key) {
+        this.entries.delete(key);
+    }
+    expireEntry(key) {
+        this.deleteEntry(key);
+    }
+    clearEntries() {
+        this.entries.clear();
+        this._nextExpiry = Infinity;
+    }
+    prune() {
+        if (Date.now() < this._nextExpiry)
+            return;
+        this._nextExpiry = Infinity;
+        this.entries.forEach((entry, key) => {
+            if (this.isExpired(entry))
+                this.expireEntry(key);
+            const current = this.entries.get(key);
+            if (current !== undefined) {
+                this._nextExpiry = Math.min(this._nextExpiry, current.date + current.maxAge);
+            }
+        });
+    }
     /**
      * Put some payload in the cache
      * @param name The name for the entry
@@ -14359,9 +14651,11 @@ class ODataInMemoryCache extends ODataBaseCache {
      * @param tags The tags for the entry
      */
     put(name, payload, { maxAge, scope, tags } = {}) {
+        this.checkError();
         const entry = this.buildEntry(payload, { maxAge, tags });
         const key = this.buildKey([...(scope ?? []), name]);
-        this.entries.set(key, entry);
+        this.prune();
+        this.setEntry(key, entry);
     }
     /**
      * Return the payload from the cache if it exists and is not expired
@@ -14370,266 +14664,416 @@ class ODataInMemoryCache extends ODataBaseCache {
      * @returns The payload of the entry
      */
     get(name, { scope } = {}) {
+        this.checkError();
+        this.prune();
         const key = this.buildKey([...(scope || []), name]);
         const entry = this.entries.get(key);
         return entry !== undefined && !this.isExpired(entry) ? entry.payload : undefined;
     }
-    /**
-     * Store the response in the cache
-     * @param req The request with the resource to store the response
-     * @param res The response to store in the cache
-     */
-    putResponse(req, res) {
-        let scope = this.scope(req);
-        let tags = this.tags(res);
-        this.put(req.cacheKey, res, {
-            maxAge: req.maxAge ?? res.options.maxAge,
-            scope,
-            tags,
-        });
-    }
-    /**
-     * Restore the response from the cache
-     * @param req The request with the resource to get the response
-     * @returns The response from the cache
-     */
-    getResponse(req) {
-        let scope = this.scope(req);
-        return this.get(req.cacheKey, { scope });
-    }
     /**
      * Remove all cache entries that are matching with the given options
      * @param options The options to forget
      */
-    forget({ name, scope = [], tags = [], } = {}) {
-        if (name)
-            scope.push(name);
-        const key = scope.length > 0 ? this.buildKey(scope) : undefined;
+    forget(options = {}) {
+        this.checkError();
         this.entries.forEach((entry, k) => {
-            if (this.isExpired(entry) || // Expired
-                (key !== undefined && k.startsWith(key)) || // Key
-                (tags.length > 0 && tags.some((t) => entry.tags.indexOf(t) !== -1)) // Tags
-            ) {
-                this.entries.delete(k);
-            }
+            if (this.matches(k, entry, options))
+                this.deleteEntry(k);
         });
     }
     /**
      * Remove all cache entries
      */
     flush() {
-        this.entries = new Map();
+        this.checkError();
+        this.clearEntries();
     }
+    /** Return the number of unexpired entries. */
     size() {
+        this.checkError();
+        this.prune();
         return this.entries.size;
     }
 }
 
-class ODataInStorageCache extends ODataBaseCache {
+class ODataInStorageCache extends ODataInMemoryCache {
     prefix;
-    storage;
-    constructor({ prefix, storage = sessionStorage, maxAge, }) {
-        super({ maxAge });
+    _storage;
+    _persistent = true;
+    _memoryOnly = new Set();
+    constructor({ prefix, storage, ...options }) {
+        super(options);
         this.prefix = prefix;
-        this.storage = storage;
+        try {
+            this._storage = storage ?? globalThis.sessionStorage;
+            if (this._storage === undefined)
+                throw new Error('Web Storage is unavailable');
+        }
+        catch (error) {
+            this.disablePersistence(error);
+        }
+        this.loadFromStorage();
+    }
+    /** The backing storage. Throws if the platform has no Web Storage implementation. */
+    get storage() {
+        if (this._storage === undefined)
+            throw new Error('Web Storage is unavailable');
+        return this._storage;
+    }
+    set storage(storage) {
+        this._storage = storage;
+        this._persistent = true;
+        this.loadFromStorage();
     }
     buildKey(names) {
         return super.buildKey([this.prefix, ...names]);
     }
-    put(name, payload, { maxAge, scope, tags } = {}) {
-        const entry = this.buildEntry(payload, { maxAge, tags });
-        const key = this.buildKey([...(scope ?? []), name]);
-        this.storage.setItem(key, JSON.stringify(entry));
+    disablePersistence(cause) {
+        if (!this._persistent)
+            return;
+        this._persistent = false;
+        this.reportError('Web Storage cache persistence failed; using memory only', cause);
     }
-    get(name, { scope } = {}) {
-        const key = this.buildKey([...(scope || []), name]);
-        const entry = JSON.parse(this.storage.getItem(key) ?? '{}');
-        return entry !== undefined && !this.isExpired(entry) ? entry.payload : undefined;
+    storageKeys() {
+        if (this._storage === undefined)
+            return [];
+        try {
+            const keys = [];
+            const prefix = `${this.prefix}${CACHE_KEY_SEPARATOR}`;
+            for (let index = 0; index < this.storage.length; index++) {
+                const key = this.storage.key(index);
+                if (key !== null && key.startsWith(prefix))
+                    keys.push(key);
+            }
+            return keys;
+        }
+        catch (error) {
+            this.disablePersistence(error);
+            return [];
+        }
+    }
+    readEntry(key) {
+        let raw;
+        try {
+            raw = this.storage.getItem(key);
+        }
+        catch (error) {
+            this.disablePersistence(error);
+            return this.entries.get(key);
+        }
+        if (raw === null)
+            return undefined;
+        let value;
+        try {
+            value = JSON.parse(raw);
+        }
+        catch (error) {
+            this.deleteEntry(key);
+            this.reportCorruption('Discarding invalid JSON from the Web Storage cache', error);
+            return undefined;
+        }
+        if (!this.isEntry(value)) {
+            this.deleteEntry(key);
+            this.reportCorruption('Discarding an invalid Web Storage cache entry');
+            return undefined;
+        }
+        if (this.isExpired(value)) {
+            this.deleteEntry(key);
+            return undefined;
+        }
+        return value;
+    }
+    loadFromStorage() {
+        if (!this._persistent)
+            return;
+        const keys = this.storageKeys();
+        if (!this._persistent)
+            return;
+        const stored = new Set(keys);
+        this.entries.forEach((_, key) => {
+            if (!stored.has(key) && !this._memoryOnly.has(key))
+                super.deleteEntry(key);
+        });
+        for (const key of keys) {
+            if (!this._persistent)
+                break;
+            if (this._memoryOnly.has(key))
+                continue;
+            const entry = this.readEntry(key);
+            if (entry !== undefined)
+                super.setEntry(key, entry);
+        }
+        this.prune();
+    }
+    // Removal is attempted after a memory fallback so flush/forget still clear persisted data.
+    removeStoredEntry(key) {
+        if (this._storage === undefined)
+            return;
+        try {
+            this.storage.removeItem(key);
+        }
+        catch (error) {
+            this.disablePersistence(error);
+        }
     }
-    forget({ name, scope = [], tags = [], }) {
-        if (name)
-            scope.push(name);
-        const key = scope.length > 0 ? this.buildKey(scope) : undefined;
-        Object.keys(this.storage)
-            .filter((k) => k.startsWith(this.prefix))
-            .forEach((k) => {
-            const entry = JSON.parse(this.storage.getItem(k) ?? '{}');
-            if (this.isExpired(entry) || // Expired
-                (key !== undefined && k.startsWith(key)) || // Key
-                (tags.length > 0 && tags.some((t) => entry.tags.indexOf(t) !== -1)) // Tags
-            ) {
-                this.storage.removeItem(k);
+    setEntry(key, entry) {
+        super.setEntry(key, entry);
+        const payload = this.isResponseJson(entry.payload) ? entry.payload.body : entry.payload;
+        if (['ArrayBuffer', 'Blob', 'File'].includes(Types.rawType(payload))) {
+            this._memoryOnly.add(key);
+            this.removeStoredEntry(key);
+            return;
+        }
+        this._memoryOnly.delete(key);
+        if (!this._persistent) {
+            this.removeStoredEntry(key);
+            return;
+        }
+        try {
+            const serialized = JSON.stringify(entry);
+            if (!this.isEntry(JSON.parse(serialized))) {
+                throw new TypeError('Cache payload is not JSON serializable');
             }
-        });
+            this.storage.setItem(key, serialized);
+        }
+        catch (error) {
+            this.disablePersistence(error);
+        }
     }
-    /**
-     * Flush the cache and clean the storage
-     */
-    flush() {
-        Object.keys(this.storage)
-            .filter((k) => k.startsWith(this.prefix))
-            .forEach((k) => {
-            this.storage.removeItem(k);
-        });
+    deleteEntry(key) {
+        super.deleteEntry(key);
+        this._memoryOnly.delete(key);
+        this.removeStoredEntry(key);
     }
-    /**
-     * Store the response in the cache
-     * @param req The request with the resource to store the response
-     * @param res The response to store in the cache
-     */
-    putResponse(req, res) {
-        const scope = this.scope(req);
-        const tags = this.tags(res);
-        this.put(req.cacheKey, res.toJson(), {
-            maxAge: req.maxAge ?? res.options.maxAge,
-            scope,
-            tags,
-        });
+    expireEntry(key) {
+        if (this._persistent && !this._memoryOnly.has(key)) {
+            const latest = this.readEntry(key);
+            if (latest !== undefined && !this.isExpired(latest)) {
+                super.setEntry(key, latest);
+                return;
+            }
+        }
+        super.expireEntry(key);
     }
-    /**
-     * Restore the response from the cache
-     * @param req The request with the resource to get the response
-     * @returns The response from the cache
-     */
-    getResponse(req) {
-        const scope = this.scope(req);
-        const data = this.get(req.cacheKey, { scope });
-        return data !== undefined ? ODataResponse.fromJson(req, data) : undefined;
+    clearEntries() {
+        const keys = this.storageKeys();
+        super.clearEntries();
+        this._memoryOnly.clear();
+        keys.forEach((key) => this.removeStoredEntry(key));
     }
+    /** Read a persisted entry, or its in-memory fallback, without renewing its age. */
+    get(name, { scope } = {}) {
+        const key = this.buildKey([...(scope ?? []), name]);
+        if (this._persistent && !this._memoryOnly.has(key)) {
+            const entry = this.readEntry(key);
+            if (entry === undefined)
+                super.deleteEntry(key);
+            else
+                super.setEntry(key, entry);
+        }
+        return super.get(name, { scope });
+    }
+    /** Remove matching entries from both persistent storage and the memory fallback. */
+    forget(options = {}) {
+        this.loadFromStorage();
+        super.forget(options);
+    }
+    /** Count unexpired entries, including memory-only binary responses. */
     size() {
-        return Object.keys(this.storage).filter((k) => k.startsWith(this.prefix)).length;
+        this.loadFromStorage();
+        return super.size();
     }
 }
 
-class ODataIndexedDBCache extends ODataBaseCache {
+class ODataIndexedDBCache extends ODataInMemoryCache {
     name;
     version;
     store;
-    entries;
-    _db;
-    constructor({ name = 'ODataCache', store = 'cache', version = 1, maxAge, } = {}) {
-        super({ maxAge });
+    _database;
+    _persistent = true;
+    _hydrated = false;
+    _pending = [];
+    _writes = Promise.resolve();
+    _ready;
+    constructor({ name = 'ODataCache', store = 'cache', version = 1, ...options } = {}) {
+        super(options);
         this.name = name;
         this.store = store;
         this.version = version;
-        this.entries = new Map();
-        this._db = this.initDb();
+        this._ready = this.initialize().catch((error) => {
+            const flushed = this._pending.some((operation) => operation.kind === 'flush');
+            this.disablePersistence(error);
+            this._hydrated = true;
+            this._pending = [];
+            if (flushed)
+                this.persist((store) => store.clear(), true);
+        });
+    }
+    /** Wait for hydration and queued writes, or an explicitly reported memory-only fallback. */
+    ready() {
+        return this._ready.then(() => this._writes).then(() => this.checkError());
+    }
+    reportError(message, cause) {
+        // IndexedDB event callbacks cannot throw into the caller's observable.
+        try {
+            super.reportError(message, cause);
+        }
+        catch (error) {
+            if (!(error instanceof Error))
+                throw error;
+            this._error = error;
+        }
     }
-    initDb() {
+    // The database stays open after a fallback so flush/forget can still remove persisted data.
+    disablePersistence(cause) {
+        if (!this._persistent)
+            return;
+        this._persistent = false;
+        this.reportError('IndexedDB cache persistence failed; using memory only', cause);
+    }
+    openDb() {
         return new Promise((resolve, reject) => {
             const request = indexedDB.open(this.name, this.version);
-            request.onupgradeneeded = (event) => {
-                const db = event.target.result;
-                if (!db.objectStoreNames.contains(this.store)) {
-                    db.createObjectStore(this.store);
+            let failed = false;
+            const fail = (error) => {
+                failed = true;
+                reject(error);
+            };
+            request.onupgradeneeded = () => {
+                if (failed) {
+                    request.transaction?.abort();
+                    return;
                 }
+                const db = request.result;
+                if (!db.objectStoreNames.contains(this.store))
+                    db.createObjectStore(this.store);
             };
-            request.onsuccess = async (event) => {
-                const db = event.target.result;
-                await this.loadFromDb(db);
+            request.onsuccess = () => {
+                const db = request.result;
+                if (failed) {
+                    db.close();
+                    return;
+                }
+                db.onversionchange = () => {
+                    db.close();
+                    this._database = undefined;
+                    this.disablePersistence(new Error('IndexedDB cache version changed'));
+                };
                 resolve(db);
             };
-            request.onerror = (event) => {
-                reject(event.target.error);
-            };
+            request.onerror = () => fail(request.error);
+            request.onblocked = () => fail(new Error('IndexedDB cache opening was blocked'));
         });
     }
     loadFromDb(db) {
         return new Promise((resolve, reject) => {
-            const transaction = db.transaction(this.store, 'readonly');
-            const store = transaction.objectStore(this.store);
-            const request = store.openCursor();
-            request.onsuccess = (event) => {
-                const cursor = event.target.result;
-                if (cursor) {
-                    this.entries.set(cursor.key, cursor.value);
-                    cursor.continue();
+            const entries = new Map();
+            const transaction = db.transaction(this.store, 'readwrite');
+            const request = transaction.objectStore(this.store).openCursor();
+            request.onsuccess = () => {
+                const cursor = request.result;
+                if (cursor === null)
+                    return;
+                const value = cursor.value;
+                if (typeof cursor.key !== 'string' || !this.isEntry(value)) {
+                    cursor.delete();
+                    this.reportCorruption('Discarding an invalid IndexedDB cache entry');
+                }
+                else if (this.isExpired(value)) {
+                    cursor.delete();
                 }
                 else {
-                    resolve();
+                    entries.set(cursor.key, value);
                 }
+                cursor.continue();
             };
-            request.onerror = (event) => {
-                reject(event.target.error);
-            };
-        });
-    }
-    async withDb(fn) {
-        const db = await this._db;
-        return fn(db);
+            transaction.oncomplete = () => resolve(entries);
+            transaction.onerror = () => reject(transaction.error ?? new Error('IndexedDB load failed'));
+            transaction.onabort = () => reject(transaction.error ?? new Error('IndexedDB load aborted'));
+        });
+    }
+    async initialize() {
+        const db = await this.openDb();
+        this._database = db;
+        const entries = await this.loadFromDb(db);
+        if (!this._persistent) {
+            this._hydrated = true;
+            this._pending = [];
+            return;
+        }
+        const pending = this._pending;
+        this._pending = [];
+        super.clearEntries();
+        entries.forEach((entry, key) => super.setEntry(key, entry));
+        this._hydrated = true;
+        for (const operation of pending) {
+            switch (operation.kind) {
+                case 'put':
+                    this.setEntry(operation.key, operation.entry);
+                    break;
+                case 'forget':
+                    this.forget(operation.options);
+                    break;
+                case 'flush':
+                    this.flush();
+                    break;
+            }
+        }
+        this.prune();
+        await this._writes;
     }
-    put(name, payload, { maxAge, scope, tags } = {}) {
-        const entry = this.buildEntry(payload, { maxAge, tags });
-        const key = this.buildKey([...(scope ?? []), name]);
-        this.entries.set(key, entry);
-        this.withDb((db) => {
+    persist(operation, removal = false) {
+        this._writes = this._writes
+            .then(() => {
+            const db = this._database;
+            if (db === undefined || (!this._persistent && !removal))
+                return;
             return new Promise((resolve, reject) => {
                 const transaction = db.transaction(this.store, 'readwrite');
-                const store = transaction.objectStore(this.store);
-                store.put(entry, key);
                 transaction.oncomplete = () => resolve();
-                transaction.onerror = (event) => reject(event.target.error);
+                transaction.onerror = () => reject(transaction.error ?? new Error('IndexedDB write failed'));
+                transaction.onabort = () => reject(transaction.error ?? new Error('IndexedDB write aborted'));
+                try {
+                    operation(transaction.objectStore(this.store));
+                }
+                catch (error) {
+                    transaction.abort();
+                    reject(error);
+                }
             });
-        });
-    }
-    get(name, { scope } = {}) {
-        const key = this.buildKey([...(scope || []), name]);
-        const entry = this.entries.get(key);
-        return entry !== undefined && !this.isExpired(entry) ? entry.payload : undefined;
+        })
+            .catch((error) => this.disablePersistence(error));
+    }
+    setEntry(key, entry) {
+        super.setEntry(key, entry);
+        if (!this._hydrated)
+            this._pending.push({ kind: 'put', key, entry });
+        else if (this._persistent)
+            this.persist((store) => store.put(entry, key));
+        else
+            this.persist((store) => store.delete(key), true);
     }
-    putResponse(req, res) {
-        const scope = this.scope(req);
-        const tags = this.tags(res);
-        this.put(req.cacheKey, res.toJson(), {
-            maxAge: req.maxAge ?? res.options.maxAge,
-            scope,
-            tags,
-        });
+    deleteEntry(key) {
+        super.deleteEntry(key);
+        if (this._hydrated)
+            this.persist((store) => store.delete(key), true);
     }
-    getResponse(req) {
-        const scope = this.scope(req);
-        const data = this.get(req.cacheKey, { scope });
-        return data !== undefined ? ODataResponse.fromJson(req, data) : undefined;
-    }
-    forget({ name, scope = [], tags = [], } = {}) {
-        if (name)
-            scope.push(name);
-        const key = scope.length > 0 ? this.buildKey(scope) : undefined;
-        const keysToDelete = [];
-        this.entries.forEach((entry, k) => {
-            if (this.isExpired(entry) ||
-                (key !== undefined && k.startsWith(key)) ||
-                (tags.length > 0 && tags.some((t) => entry.tags.indexOf(t) !== -1))) {
-                keysToDelete.push(k);
-            }
-        });
-        keysToDelete.forEach((k) => this.entries.delete(k));
-        if (keysToDelete.length > 0) {
-            this.withDb((db) => {
-                return new Promise((resolve, reject) => {
-                    const transaction = db.transaction(this.store, 'readwrite');
-                    const store = transaction.objectStore(this.store);
-                    keysToDelete.forEach((k) => store.delete(k));
-                    transaction.oncomplete = () => resolve();
-                    transaction.onerror = (event) => reject(event.target.error);
-                });
+    clearEntries() {
+        super.clearEntries();
+        if (!this._hydrated)
+            this._pending.push({ kind: 'flush' });
+        else
+            this.persist((store) => store.clear(), true);
+    }
+    /** Invalidate loaded entries and record filters that must also apply during hydration. */
+    forget(options = {}) {
+        if (!this._hydrated) {
+            this._pending.push({
+                kind: 'forget',
+                options: { ...options, scope: [...(options.scope ?? [])], tags: [...(options.tags ?? [])] },
             });
         }
-    }
-    flush() {
-        this.entries = new Map();
-        this.withDb((db) => {
-            return new Promise((resolve, reject) => {
-                const transaction = db.transaction(this.store, 'readwrite');
-                const store = transaction.objectStore(this.store);
-                store.clear();
-                transaction.oncomplete = () => resolve();
-                transaction.onerror = (event) => reject(event.target.error);
-            });
-        });
-    }
-    size() {
-        return this.entries.size;
+        super.forget(options);
     }
 }