@sdcorejs/angular 19.1.2 → 19.1.4

package/fesm2022/sdcorejs-angular-services-cache.mjs

@@ -1,155 +1,565 @@
 import * as i0 from '@angular/core';
-import { Injectable, InjectionToken } from '@angular/core';
-import { DateUtilities } from '@sdcorejs/angular/utilities/extensions';
+import { InjectionToken, inject, DestroyRef, Injectable } from '@angular/core';
+import { SD_PERSISTENCE_STORAGE_ADAPTER, SdGraphSerializer, SdGraphIdentityCanonicalizer, canonicalizeSdPersistenceValue, buildSdPersistenceKey, digestSdPersistenceKey, readSdPersistenceStorageItem, parseSdPersistenceEnvelope, stringifySdPersistenceValueEnvelope, stringifySdPersistenceTombstoneEnvelope } from '@sdcorejs/angular/services/persistence';
 import { Utilities } from '@sdcorejs/utils/fns';
 import { BehaviorSubject } from 'rxjs';
-import { map } from 'rxjs/operators';
+
+const SD_CACHE_CONFIG = new InjectionToken('sd-cache.configuration');
+/** @deprecated Prefer globally safe unknown callbacks on `ISdCacheConfiguration`. */
+function adaptLegacySdCacheCallbacks(callbacks) {
+    return {
+        set: callbacks.set
+            ? (key, value, option) => {
+                if (!callbacks.matches(key, option))
+                    return;
+                if (!callbacks.isValue(value.data))
+                    throw new TypeError(`Legacy cache value did not match key ${key}`);
+                return callbacks.set?.(key, { data: value.data, createdOn: new Date(value.createdOn) }, option);
+            }
+            : undefined,
+        get: callbacks.get
+            ? async (key, option) => {
+                if (!callbacks.matches(key, option))
+                    return undefined;
+                const value = await callbacks.get?.(key, option);
+                if (!value)
+                    return undefined;
+                if (!callbacks.isValue(value.data))
+                    throw new TypeError(`Legacy cache value did not match key ${key}`);
+                return { data: value.data, createdOn: new Date(value.createdOn) };
+            }
+            : undefined,
+        remove: callbacks.remove
+            ? (key, option) => {
+                if (!callbacks.matches(key, option))
+                    return;
+                return callbacks.remove?.(key, option);
+            }
+            : undefined,
+    };
+}
 
 class SdCacheService {
-    #memoryCache = new Map();
-    #subjects = new Map();
-    constructor() { }
-    create(key, option) {
+    #configuration = inject(SD_CACHE_CONFIG, { optional: true });
+    #adapter = inject(SD_PERSISTENCE_STORAGE_ADAPTER);
+    #destroyRef = inject(DestroyRef);
+    #defaultSerializer = new SdGraphSerializer();
+    #defaultIdentityCanonicalizer = new SdGraphIdentityCanonicalizer();
+    #states = new Map();
+    #remoteQueues = new Map();
+    #memoryEntries = new Map();
+    #failedOwners = new Map();
+    #maxFailedOwners = 256;
+    #destroyed = false;
+    constructor() {
+        this.#destroyRef.onDestroy(() => {
+            this.#destroyed = true;
+            for (const state of this.#states.values()) {
+                state.disposed = true;
+                state.generation += 1;
+                state.entry = undefined;
+                state.inFlight = undefined;
+                for (const handle of state.handles)
+                    handle.complete();
+                state.handles.clear();
+            }
+            this.#states.clear();
+            this.#remoteQueues.clear();
+            this.#memoryEntries.clear();
+            this.#failedOwners.clear();
+        });
+    }
+    create(key, option = {}) {
+        if (this.#destroyed)
+            throw new Error('Cache service has been destroyed');
         if (!key)
             throw new Error('Key is required');
-        const hashKey = Utilities.hash({ key });
-        // 1. Init Subject: Load data có sẵn nếu có
-        if (!this.#subjects.has(hashKey)) {
-            const existingData = this.#internalGet(hashKey, option);
-            this.#subjects.set(hashKey, new BehaviorSubject(existingData ?? option?.default));
-        }
-        const subject = this.#subjects.get(hashKey);
-        // 2. Define helpers
+        const normalized = this.#normalize(key, option);
+        const state = this.#getOrCreateState(normalized);
+        if (Object.prototype.hasOwnProperty.call(option, 'default')) {
+            return this.#createDefaultHandle(state, normalized, this.#cloneAs(normalized.serializer, option.default));
+        }
+        return this.#createOptionalHandle(state, normalized);
+    }
+    #getOrCreateState(normalized) {
+        const existing = this.#states.get(normalized.ownerDigest);
+        if (existing)
+            return existing;
+        const state = {
+            hydrated: false,
+            handles: new Set(),
+            generation: 0,
+            disposed: false,
+        };
+        this.#states.set(normalized.ownerDigest, state);
+        this.#hydrateState(state, normalized);
+        return state;
+    }
+    #createOptionalHandle(state, normalized) {
+        const initial = this.#readOptional(state, normalized);
+        const subject = new BehaviorSubject(initial);
+        const facade = {
+            emit: (present, value) => subject.next(present ? this.#cloneAs(normalized.serializer, value) : undefined),
+            complete: () => subject.complete(),
+        };
+        const operations = this.#attachHandle(state, normalized, facade, () => this.#readOptional(state, normalized));
+        return { ...operations, observer: subject.asObservable() };
+    }
+    #createDefaultHandle(state, normalized, defaultSnapshot) {
+        const read = () => this.#readWithDefault(state, normalized, defaultSnapshot);
+        const subject = new BehaviorSubject(read());
+        const facade = {
+            emit: (present, value) => subject.next(present ? this.#cloneAs(normalized.serializer, value) : this.#cloneAs(normalized.serializer, defaultSnapshot)),
+            complete: () => subject.complete(),
+        };
+        const operations = this.#attachHandle(state, normalized, facade, read);
+        return { ...operations, get: read, observer: subject.asObservable() };
+    }
+    #attachHandle(state, normalized, facade, read) {
+        state.handles.add(facade);
+        let active = true;
+        const assertActive = () => {
+            if (!active || state.disposed || this.#destroyed)
+                throw new Error('Cache handle has been destroyed');
+        };
         const get = () => {
-            const val = this.#internalGet(hashKey, option);
-            // Fix strict type: Ép kiểu về T (chấp nhận rủi ro undefined nếu user không check)
-            return (val ?? option?.default);
+            assertActive();
+            return read();
+        };
+        const snapshot = () => {
+            assertActive();
+            const entry = this.#getValidEntry(state, normalized);
+            return entry === undefined ? { present: false } : { present: true, value: this.#cloneAs(normalized.serializer, entry.data) };
         };
         const set = (data) => {
-            this.#internalSet(hashKey, data, option);
-            subject.next(data);
+            assertActive();
+            this.#setEntry(state, normalized, data, true);
+            this.#broadcast(state);
         };
         const has = () => {
-            return this.#internalGet(hashKey, option) !== undefined;
+            assertActive();
+            return this.#getValidEntry(state, normalized) !== undefined;
         };
         const remove = () => {
-            this.#internalRemove(hashKey, option);
-            subject.next(undefined);
+            assertActive();
+            this.#removeEntry(state, normalized, true);
+            this.#broadcast(state);
+        };
+        const releaseFacade = () => {
+            if (!active)
+                return;
+            active = false;
+            state.handles.delete(facade);
+            facade.complete();
+            if (state.handles.size > 0)
+                return;
+            state.disposed = true;
+            state.generation += 1;
+            state.entry = undefined;
+            state.inFlight = undefined;
+            this.#states.delete(normalized.ownerDigest);
         };
+        const release = () => releaseFacade();
         const destroy = () => {
-            subject.complete();
-            this.#subjects.delete(hashKey);
-            this.#memoryCache.delete(hashKey);
+            if (!active)
+                return;
+            releaseFacade();
+            if (normalized.area !== 'memory')
+                return;
+            this.#memoryEntries.delete(normalized.ownerDigest);
+            if (state.disposed)
+                return;
+            state.entry = undefined;
+            state.hydrated = true;
+            this.#broadcast(state);
         };
-        // 3. IMPLEMENT LOAD (Get-Or-Set Pattern)
-        const load = async (callback) => {
-            // Check cache trước
-            if (has()) {
-                return get();
+        const load = (callback) => {
+            try {
+                assertActive();
             }
-            // Cache miss -> Gọi API
-            const result = await callback();
-            // Chỉ lưu nếu kết quả hợp lệ (khác undefined/null)
-            if (result !== undefined && result !== null) {
-                set(result);
+            catch (error) {
+                return Promise.reject(error);
             }
-            return result;
+            const entry = this.#getValidEntry(state, normalized);
+            if (entry)
+                return Promise.resolve(this.#cloneAs(normalized.serializer, entry.data));
+            const generation = state.generation;
+            if (state.inFlight?.generation === generation) {
+                return state.inFlight.promise.then(value => this.#cloneAs(normalized.serializer, value));
+            }
+            const promise = this.#loadMiss(state, normalized, callback, generation);
+            state.inFlight = { generation, promise };
+            void promise
+                .finally(() => {
+                if (state.inFlight?.promise === promise)
+                    state.inFlight = undefined;
+            })
+                .catch(() => undefined);
+            return promise;
         };
+        return { get, snapshot, set, has, remove, release, destroy, load };
+    }
+    async #loadMiss(state, normalized, callback, generation) {
+        const remote = await this.#readRemote(normalized);
+        if (remote) {
+            if (!state.disposed && state.generation === generation) {
+                state.entry = this.#cloneEntry(remote, normalized.serializer);
+                state.hydrated = true;
+                state.generation += 1;
+                this.#writePersistent(normalized, state.entry);
+                this.#broadcast(state);
+            }
+            return this.#cloneAs(normalized.serializer, remote.data);
+        }
+        const result = await callback();
+        if (result !== null && result !== undefined && !state.disposed && state.generation === generation) {
+            this.#setEntry(state, normalized, result, true);
+            this.#broadcast(state);
+        }
+        if (result === null || result === undefined)
+            return result;
+        return this.#cloneAs(normalized.serializer, result);
+    }
+    #normalize(key, option) {
+        const serializer = option.serializer ?? this.#configuration?.serializer ?? this.#defaultSerializer;
+        const identityCanonicalizer = option.identityCanonicalizer ?? this.#configuration?.identityCanonicalizer ?? this.#defaultIdentityCanonicalizer;
+        const canonicalKey = canonicalizeSdPersistenceValue(identityCanonicalizer, key, 'cache key');
+        const legacyStorageKey = this.#legacyStorageKey(key);
+        const namespace = option.namespace ?? this.#configuration?.namespace;
+        const version = option.version ?? this.#configuration?.version;
+        const area = option.type ?? 'memory';
+        const ttlMs = this.#normalizeTtl(option);
+        const serializerFormat = this.#serializerFormat(serializer);
+        const hasArgs = Object.prototype.hasOwnProperty.call(option, 'args');
+        const hasDefault = Object.prototype.hasOwnProperty.call(option, 'default');
+        const fields = [
+            { tag: 'area', value: canonicalizeSdPersistenceValue(identityCanonicalizer, area, 'cache area') },
+            { tag: 'namespace', value: this.#optionalIdentity(identityCanonicalizer, namespace !== undefined, namespace, 'cache namespace') },
+            { tag: 'version', value: this.#optionalIdentity(identityCanonicalizer, version !== undefined, version, 'cache version') },
+            { tag: 'ttlMs', value: this.#optionalIdentity(identityCanonicalizer, ttlMs !== undefined, ttlMs, 'cache TTL') },
+            { tag: 'args', value: this.#optionalIdentity(identityCanonicalizer, hasArgs, option.args, 'cache args') },
+            { tag: 'default', value: this.#optionalIdentity(identityCanonicalizer, hasDefault, option.default, 'cache default') },
+            { tag: 'serializer', value: serializerFormat },
+            { tag: 'identityCanonicalizer', value: this.#identityCanonicalizerFormat(identityCanonicalizer) },
+        ];
+        const identity = buildSdPersistenceKey(canonicalKey, fields);
+        const identityDigest = digestSdPersistenceKey(identity);
+        const storageKey = this.#convertKey(`sdcorejs.cache@1:${identityDigest}`);
+        const ownerDigest = digestSdPersistenceKey(buildSdPersistenceKey(storageKey, [{ tag: 'area', value: area }]));
         return {
-            get,
-            set,
-            has,
-            remove,
-            destroy,
-            load,
-            observer: subject.asObservable().pipe(map(() => get())),
+            publicOption: option,
+            area,
+            storageKey,
+            legacyStorageKey,
+            ownerDigest,
+            identityDigest,
+            ttlMs,
+            serializer,
         };
     }
-    // --- PRIVATE HELPERS ---
-    #getStorage(option) {
-        if (option?.type === 'local')
-            return localStorage;
-        if (option?.type === 'session')
-            return sessionStorage;
-        return null;
-    }
-    #internalGet(key, option) {
-        let entry = this.#memoryCache.get(key);
-        if (!entry) {
-            const storage = this.#getStorage(option);
-            if (storage) {
-                const raw = storage.getItem(key);
-                if (raw) {
-                    try {
-                        const parsed = JSON.parse(raw);
-                        entry = {
-                            data: parsed.data,
-                            createdOn: new Date(parsed.createdOn),
-                        };
-                        this.#memoryCache.set(key, entry);
-                    }
-                    catch (e) {
-                        this.#internalRemove(key, option);
-                    }
-                }
-            }
+    #convertKey(baseKey) {
+        try {
+            return this.#configuration?.convertKey?.(baseKey) ?? baseKey;
+        }
+        catch {
+            return baseKey;
+        }
+    }
+    #legacyStorageKey(key) {
+        try {
+            return this.#convertKey(Utilities.hash({ key }));
         }
-        if (!entry)
+        catch {
+            return undefined;
+        }
+    }
+    #normalizeTtl(option) {
+        const candidate = option.ttlMs ?? (option.hours === undefined ? undefined : option.hours * 3_600_000);
+        if (candidate === undefined || !Number.isFinite(candidate) || candidate <= 0)
+            return undefined;
+        return Math.min(candidate, Number.MAX_SAFE_INTEGER);
+    }
+    #optionalIdentity(canonicalizer, present, value, label) {
+        return present ? `1${canonicalizeSdPersistenceValue(canonicalizer, value, label)}` : '0';
+    }
+    #identityCanonicalizerFormat(canonicalizer) {
+        if (typeof canonicalizer.format !== 'string' || canonicalizer.format.length === 0) {
+            throw new Error('Persistence identity canonicalizer format must be a non-empty string');
+        }
+        return canonicalizer.format;
+    }
+    #serializerFormat(serializer) {
+        if (typeof serializer.format !== 'string' || serializer.format.length === 0) {
+            throw new Error('Persistence serializer format must be a non-empty string');
+        }
+        return serializer.format;
+    }
+    #readOptional(state, normalized) {
+        const entry = this.#getValidEntry(state, normalized);
+        return entry ? this.#cloneAs(normalized.serializer, entry.data) : undefined;
+    }
+    #readWithDefault(state, normalized, defaultSnapshot) {
+        const entry = this.#getValidEntry(state, normalized);
+        return entry ? this.#cloneAs(normalized.serializer, entry.data) : this.#cloneAs(normalized.serializer, defaultSnapshot);
+    }
+    #getValidEntry(state, normalized) {
+        if (!state.hydrated) {
+            this.#hydrateState(state, normalized);
+        }
+        if (!state.entry)
+            return undefined;
+        if (this.#isExpired(state.entry, normalized.ttlMs)) {
+            this.#removeEntry(state, normalized, true);
+            this.#broadcast(state);
             return undefined;
-        if (option?.hours && entry.createdOn) {
-            const expiredOn = DateUtilities.addHours(entry.createdOn, option.hours);
-            if (expiredOn && expiredOn < new Date()) {
-                this.#internalRemove(key, option);
-                return undefined;
-            }
         }
-        return this.#deepClone(entry.data);
+        return state.entry;
+    }
+    #isExpired(entry, ttlMs) {
+        return ttlMs !== undefined && entry.createdOn.getTime() + ttlMs <= Date.now();
     }
-    #internalSet(key, data, option) {
-        // FIX LỖI TẠI ĐÂY: Bỏ "?? null" để giữ nguyên kiểu T
-        const clonedData = this.#deepClone(data);
+    #hydrateState(state, normalized) {
+        const read = this.#readEntry(normalized);
+        state.entry = read.status === 'found' ? read.entry : undefined;
+        state.hydrated = read.status !== 'unavailable';
+    }
+    #setEntry(state, normalized, data, notifyRemote) {
         const entry = {
-            data: clonedData,
+            data: normalized.serializer.clone(data),
             createdOn: new Date(),
         };
-        this.#memoryCache.set(key, entry);
-        const storage = this.#getStorage(option);
-        if (storage) {
+        state.entry = entry;
+        state.hydrated = true;
+        state.generation += 1;
+        this.#writePersistent(normalized, entry);
+        if (notifyRemote)
+            this.#safeRemoteSet(normalized, entry);
+    }
+    #removeEntry(state, normalized, notifyRemote) {
+        state.entry = undefined;
+        state.hydrated = true;
+        state.generation += 1;
+        if (normalized.area !== 'memory')
+            this.#writeTombstone(normalized);
+        if (notifyRemote)
+            void this.#safeRemoteRemove(normalized);
+    }
+    #broadcast(state) {
+        const present = state.entry !== undefined;
+        const value = state.entry?.data;
+        for (const handle of state.handles)
+            handle.emit(present, value);
+    }
+    #readEntry(normalized) {
+        if (normalized.area === 'memory') {
+            const entry = this.#memoryEntries.get(normalized.ownerDigest);
+            return entry ? { status: 'found', entry: this.#cloneEntry(entry, normalized.serializer) } : { status: 'absent' };
+        }
+        if (this.#failedOwners.has(normalized.ownerDigest))
+            return { status: 'unavailable' };
+        const primary = readSdPersistenceStorageItem(this.#adapter, normalized.area, normalized.storageKey);
+        if (primary.status === 'found') {
+            let envelope;
+            try {
+                envelope = parseSdPersistenceEnvelope(primary.value, normalized.identityDigest, normalized.serializer.format);
+            }
+            catch {
+                this.#writeTombstone(normalized);
+                return { status: 'absent' };
+            }
+            if (envelope?.kind === 'tombstone')
+                return { status: 'absent' };
+            const entry = envelope?.kind === 'value' ? this.#parseCurrentEntry(envelope.payload, normalized.serializer) : undefined;
+            if (entry)
+                return { status: 'found', entry };
+            this.#writeTombstone(normalized);
+            return { status: 'absent' };
+        }
+        if (primary.status === 'unavailable')
+            return { status: 'unavailable' };
+        if (normalized.legacyStorageKey === undefined)
+            return { status: 'absent' };
+        const legacyRead = readSdPersistenceStorageItem(this.#adapter, normalized.area, normalized.legacyStorageKey);
+        if (legacyRead.status === 'unavailable')
+            return { status: 'unavailable' };
+        if (legacyRead.status === 'absent')
+            return { status: 'absent' };
+        const legacy = this.#parseLegacy(legacyRead.value);
+        if (!legacy) {
+            this.#writeTombstone(normalized);
+            return { status: 'absent' };
+        }
+        this.#writePersistent(normalized, legacy);
+        return { status: 'found', entry: legacy };
+    }
+    #parseCurrentEntry(payload, serializer) {
+        try {
+            return this.#validateEntry(serializer.parse(payload));
+        }
+        catch {
+            return undefined;
+        }
+    }
+    #parseLegacy(raw) {
+        try {
+            const parsed = JSON.parse(raw);
+            if (!this.#hasExactEntryKeys(parsed))
+                return undefined;
+            const createdOn = this.#toValidDate(parsed['createdOn']);
+            return createdOn ? { data: parsed['data'], createdOn } : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    #validateEntry(value) {
+        if (!this.#hasExactEntryKeys(value))
+            return undefined;
+        const createdOn = this.#toValidDate(value['createdOn']);
+        return createdOn ? { data: value['data'], createdOn } : undefined;
+    }
+    #toValidDate(value) {
+        const date = value instanceof Date ? value : typeof value === 'string' || typeof value === 'number' ? new Date(value) : undefined;
+        return date && Number.isFinite(date.getTime()) ? date : undefined;
+    }
+    #writePersistent(normalized, entry) {
+        if (normalized.area === 'memory') {
+            this.#memoryEntries.set(normalized.ownerDigest, this.#cloneEntry(entry, normalized.serializer));
+            return true;
+        }
+        try {
+            const payload = normalized.serializer.stringify(entry);
+            if (this.#adapter.setItem(normalized.area, normalized.storageKey, stringifySdPersistenceValueEnvelope(normalized.identityDigest, normalized.serializer.format, payload))) {
+                this.#clearFailedOwner(normalized.ownerDigest);
+                return true;
+            }
+        }
+        catch {
+            // Fall through to canonical quarantine.
+        }
+        this.#safeAdapterRemove(normalized.area, normalized.storageKey);
+        if (this.#tryPersistTombstone(normalized)) {
+            this.#clearFailedOwner(normalized.ownerDigest);
+            return false;
+        }
+        this.#recordFailedOwner(normalized.ownerDigest);
+        return false;
+    }
+    #readRemote(normalized) {
+        return this.#enqueueRemote(normalized, async () => {
+            const get = this.#configuration?.get;
+            if (!get)
+                return undefined;
+            const entry = this.#validateEntry(await get(normalized.storageKey, normalized.publicOption));
+            if (!entry || !this.#isExpired(entry, normalized.ttlMs))
+                return entry;
+            const remove = this.#configuration?.remove;
+            if (remove)
+                await remove(normalized.storageKey, normalized.publicOption);
+            return undefined;
+        });
+    }
+    #safeRemoteSet(normalized, entry) {
+        const set = this.#configuration?.set;
+        if (!set)
+            return;
+        void this.#enqueueRemote(normalized, () => set(normalized.storageKey, this.#cloneEntry(entry, normalized.serializer), normalized.publicOption));
+    }
+    #safeRemoteRemove(normalized) {
+        const remove = this.#configuration?.remove;
+        if (!remove)
+            return Promise.resolve();
+        return this.#enqueueRemote(normalized, () => remove(normalized.storageKey, normalized.publicOption));
+    }
+    #enqueueRemote(normalized, operation) {
+        const previous = this.#remoteQueues.get(normalized.ownerDigest) ?? Promise.resolve();
+        const result = previous.then(async () => {
             try {
-                storage.setItem(key, JSON.stringify(entry));
+                return await operation();
             }
-            catch (e) {
-                console.error('Storage quota exceeded', e);
+            catch {
+                // A failed remote operation cannot poison later work for this identity.
+                return undefined;
             }
+        });
+        const tail = result.then(() => undefined);
+        this.#remoteQueues.set(normalized.ownerDigest, tail);
+        void tail.then(() => {
+            if (this.#remoteQueues.get(normalized.ownerDigest) === tail)
+                this.#remoteQueues.delete(normalized.ownerDigest);
+        });
+        return result;
+    }
+    #safeAdapterRemove(area, key) {
+        try {
+            return this.#adapter.removeItem(area, key);
         }
+        catch {
+            return false;
+        }
+    }
+    #writeTombstone(normalized) {
+        if (normalized.area === 'memory') {
+            this.#memoryEntries.delete(normalized.ownerDigest);
+            return true;
+        }
+        if (this.#tryPersistTombstone(normalized)) {
+            this.#clearFailedOwner(normalized.ownerDigest);
+            return true;
+        }
+        this.#safeAdapterRemove(normalized.area, normalized.storageKey);
+        this.#recordFailedOwner(normalized.ownerDigest);
+        return false;
     }
-    #internalRemove(key, option) {
-        this.#memoryCache.delete(key);
-        const storage = this.#getStorage(option);
-        if (storage) {
-            storage.removeItem(key);
+    #tryPersistTombstone(normalized) {
+        if (normalized.area === 'memory')
+            return false;
+        try {
+            return this.#adapter.setItem(normalized.area, normalized.storageKey, stringifySdPersistenceTombstoneEnvelope(normalized.identityDigest, normalized.serializer.format));
+        }
+        catch {
+            return false;
         }
     }
-    #deepClone(val) {
-        if (val === undefined || val === null)
-            return val;
-        return JSON.parse(JSON.stringify(val));
+    #clearFailedOwner(ownerDigest) {
+        this.#failedOwners.delete(ownerDigest);
+    }
+    #recordFailedOwner(ownerDigest) {
+        this.#failedOwners.delete(ownerDigest);
+        this.#failedOwners.set(ownerDigest, true);
+        if (this.#failedOwners.size <= this.#maxFailedOwners)
+            return;
+        const oldest = this.#failedOwners.keys().next().value;
+        if (oldest !== undefined)
+            this.#failedOwners.delete(oldest);
+    }
+    #cloneEntry(entry, serializer) {
+        return { data: serializer.clone(entry.data), createdOn: new Date(entry.createdOn) };
+    }
+    #cloneAs(serializer, value) {
+        const entry = serializer.parse(serializer.stringify({ data: value, createdOn: new Date(0) }));
+        return entry.data;
+    }
+    #isRecord(value) {
+        return typeof value === 'object' && value !== null && !Array.isArray(value);
+    }
+    #hasExactEntryKeys(value) {
+        return (this.#isRecord(value) &&
+            Reflect.ownKeys(value).length === 2 &&
+            Object.prototype.hasOwnProperty.call(value, 'data') &&
+            Object.prototype.hasOwnProperty.call(value, 'createdOn'));
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.21", ngImport: i0, type: SdCacheService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.21", ngImport: i0, type: SdCacheService, providedIn: 'root' });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.21", ngImport: i0, type: SdCacheService, decorators: [{
             type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
+            args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [] });
 
-const SD_CACHE_CONFIG = new InjectionToken('sd-cache.configuration');
-
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { SD_CACHE_CONFIG, SdCacheService };
+export { SD_CACHE_CONFIG, SdCacheService, adaptLegacySdCacheCallbacks };
 //# sourceMappingURL=sdcorejs-angular-services-cache.mjs.map