@reforgium/statum 3.0.1 → 3.1.1

package/fesm2022/reforgium-statum.mjs

@@ -1,380 +1,10 @@
-import { formatDate, isNullable, isDatePeriod, parseToDate, buildQueryParams, isNumber, isObject, parseToDatePeriod, parseQueryParamsByMode, fillUrlWithParams, mergeQueryParams, deepEqual, normalizeSortInput, sortInputToTokens, debounceSignal } from '@reforgium/internal';
+import { Serializer, fillUrlWithParams, mergeQueryParams, LruCache, deepEqual, isNullable, normalizeSortInput, sortInputToTokens, debounceSignal, storageStrategy } from '@reforgium/internal';
+export { LocalStorage, LruCache, MemoryStorage, Serializer, SerializerFieldError, SessionStorage, storageStrategy } from '@reforgium/internal';
 import { HttpClient, HttpParams } from '@angular/common/http';
 import { InjectionToken, makeEnvironmentProviders, inject, signal, computed, EnvironmentInjector, DestroyRef, runInInjectionContext, effect, untracked } from '@angular/core';
 import { Subject, filter, timer, merge, map } from 'rxjs';
 import { debounce, tap, throttle, finalize } from 'rxjs/operators';
 
-const serializeString = (config, value) => config.mapString.format?.(value) ?? (config.mapString.trim ? value.trim() : value);
-const serializeNumber = (config, value) => config.mapNumber.format?.(value) ?? Number(value);
-const serializeBoolean = (config, value) => config.mapBoolean.format?.(value) ?? (value ? (config.mapBoolean.true ?? true) : (config.mapBoolean.false ?? false));
-const serializeDate = (config, value) => config.mapDate.format?.(value) ?? formatDate(value, config.mapDate.dateFormat);
-
-class SerializerFieldError extends Error {
-    field;
-    stage;
-    originalError;
-    constructor(field, stage, originalError) {
-        const originalMessage = originalError instanceof Error ? originalError.message : String(originalError);
-        super(`Serializer ${stage} error for field "${field}": ${originalMessage}`);
-        this.field = field;
-        this.stage = stage;
-        this.originalError = originalError;
-        this.name = 'SerializerFieldError';
-    }
-}
-/**
- * Universal serializer/deserializer for values used in forms, filters, and DTOs.
- *
- * Supports types: `string | number | boolean | Date | [Date, Date] (period) | array | object | nullable`.
- * Capabilities:
- * - normalize values according to config (trim strings, parse numbers from strings, boolean strings, etc.),
- * - transform date periods into paired keys (`from/to`) or a single joined string,
- * - build/parse a query string (or JSON) to and from an object.
- *
- * Example:
- * ```ts
- * type Filters = { q?: string; active?: boolean; created?: [Date, Date] | null };
- * const s = new Serializer<Filters>({
- *   mapPeriod: { transformMode: { mode: 'split', dateFromKeyPostfix: 'From', dateToKeyPostfix: 'To' } }
- * });
- *
- * // -> { q: 'john', createdFrom: '2025-01-01', createdTo: '2025-01-31' }
- * const plain = s.serialize({
- *   q: '  john ',
- *   active: undefined,
- *   created: [new Date('2025-01-01'), new Date('2025-01-31')]
- * });
- *
- * // -> 'q=john&createdFrom=2025-01-01&createdTo=2025-01-31'
- * const qs = s.toQuery({ q: 'john', created: [new Date('2025-01-01'), new Date('2025-01-31')] });
- *
- * // <- { q: 'john', created: [Date, Date] }
- * const parsed = s.deserialize('q=john&createdFrom=2025-01-01&createdTo=2025-01-31');
- * ```
- */
-class Serializer {
-    config;
-    /**
-     * Creates a serializer with a partially overridden configuration.
-     * Provide only the options you want to change (the rest are taken from defaults).
-     *
-     * @param config partial transformation configuration
-     */
-    constructor(config = {}) {
-        this.config = this.mergeConfig({
-            mapString: { trim: true },
-            mapNumber: { fromString: false },
-            mapBoolean: {},
-            mapArray: { concatType: 'comma' },
-            mapObject: { deep: true },
-            mapDate: { dateFormat: 'yyyy-MM-dd' },
-            mapPeriod: {
-                dateFormat: 'yyyy-MM-dd',
-                transformMode: { mode: 'split', dateFromKeyPostfix: 'From', dateToKeyPostfix: 'To' },
-            },
-            mapNullable: { remove: true, includeEmptyString: false },
-        }, config);
-    }
-    /**
-     * Converts a domain object into a flat serialized representation
-     * (ready to send to an API or build a query string).
-     *
-     * Rules are taken from `config`:
-     * — strings can be trimmed (if enabled),
-     * — numbers can be converted from strings/numbers,
-     * — boolean supports custom true/false representations,
-     * — dates are formatted by `dateFormat`,
-     * — date periods can be split/joined,
-     * — `nullable` can be removed from the result (`remove`) or formatted.
-     *
-     * @param obj source object
-     * @returns a flat dictionary with string/primitive values
-     */
-    serialize(obj) {
-        const result = {};
-        for (const [key, value] of Object.entries(obj ?? {})) {
-            const fields = this.config.mapFields?.[key];
-            if (fields && 'format' in fields) {
-                try {
-                    result[key] = fields.format(value, obj);
-                }
-                catch (error) {
-                    throw new SerializerFieldError(key, 'format', error);
-                }
-                continue;
-            }
-            if (fields?.type === 'nullable' || isNullable(value, this.config.mapNullable?.includeEmptyString)) {
-                if (this.config.mapNullable.remove) {
-                    continue;
-                }
-            }
-            if (fields?.type === 'period' || isDatePeriod(value)) {
-                const transform = this.config.mapPeriod.transformMode;
-                const [from, to] = value;
-                if (transform?.mode === 'split') {
-                    result[`${key}${transform.dateFromKeyPostfix}`] = formatDate(from, this.config.mapPeriod.dateFormat);
-                    result[`${key}${transform.dateToKeyPostfix}`] = formatDate(to, this.config.mapPeriod.dateFormat);
-                    continue;
-                }
-            }
-            result[key] = this.serializeElement(value, key);
-        }
-        return result;
-    }
-    /**
-     * Parse serialized data into a domain object.
-     *
-     * Source can be:
-     * — a query string (`key=value&arr=1,2`) or `JSON.stringify(obj)`,
-     * — an already prepared flat object.
-     *
-     * Transformations are reverse of `serialize`: strings → number/boolean/Date/period,
-     * arrays are collected according to strategy (`comma`/`pipe`/`multi`), objects — deeply or as JSON.
-     *
-     * @param val query string or object
-     * @returns a domain object of the specified type
-     */
-    deserialize = (val) => {
-        const data = typeof val === 'string' ? this.parseInputString(val) : val;
-        const result = {};
-        for (const [key, value] of Object.entries(data ?? {})) {
-            const field = this.config.mapFields?.[key];
-            if (field && 'parse' in field) {
-                try {
-                    result[key] = field.parse(value, data);
-                }
-                catch (error) {
-                    throw new SerializerFieldError(key, 'parse', error);
-                }
-                continue;
-            }
-            if (field?.type === 'nullable' ||
-                (field?.type !== 'array' && isNullable(value, this.config.mapNullable?.includeEmptyString))) {
-                if (this.config.mapNullable.remove) {
-                    continue;
-                }
-            }
-            const periodTransform = this.config.mapPeriod.transformMode;
-            if (periodTransform.mode === 'split') {
-                const isFrom = (key || '').endsWith(periodTransform.dateFromKeyPostfix);
-                const isTo = (key || '').endsWith(periodTransform.dateToKeyPostfix);
-                const keyJoint = (key || '')
-                    .replace(periodTransform.dateFromKeyPostfix, '')
-                    .replace(periodTransform.dateToKeyPostfix, '');
-                const field = this.config.mapFields?.[keyJoint];
-                const fieldType = field && 'type' in field ? field.type : undefined;
-                if (fieldType === 'period' && (isFrom || isTo)) {
-                    result[keyJoint] ??= [null, null];
-                    if (isFrom) {
-                        result[keyJoint][0] = parseToDate(value, this.config.mapPeriod.dateFormat);
-                    }
-                    else if (isTo) {
-                        result[keyJoint][1] = parseToDate(value, this.config.mapPeriod.dateFormat);
-                    }
-                    continue;
-                }
-            }
-            result[key] = this.deserializeElement(value, key);
-        }
-        return result;
-    };
-    /** Parse only query-string input. */
-    deserializeQuery = (query) => {
-        return this.deserialize(this.parseQuery(query));
-    };
-    /** Parse only JSON object input. */
-    deserializeJson = (json) => {
-        return this.deserialize(this.parseJsonObject(json));
-    };
-    /**
-     * Build a query string from a domain object using `serialize` rules
-     * and the array joining strategy (`concatType`).
-     *
-     * @param val domain object
-     * @returns query string (suitable for URL or history API)
-     */
-    toQuery = (val) => {
-        return buildQueryParams(this.serialize(val), this.config.mapArray.concatType, this.resolveArrayFieldModes());
-    };
-    /**
-     * Returns a new serializer instance with a merged configuration.
-     * Useful for ad-hoc overrides for a specific call.
-     *
-     * @param config partial config changes
-     * @returns new `Serializer` with the provided `config` applied
-     */
-    withConfig(config) {
-        return new Serializer(this.mergeConfig(this.config, config));
-    }
-    serializeElement(value, key) {
-        const fields = this.config.mapFields?.[key || ''];
-        if (fields && 'format' in fields) {
-            return;
-        }
-        if (fields?.type === 'nullable' || isNullable(value, this.config.mapNullable?.includeEmptyString)) {
-            const nullableVal = value ?? null;
-            return this.config.mapNullable.format?.(nullableVal) || this.config.mapNullable.replaceWith || nullableVal;
-        }
-        if (fields?.type === 'string') {
-            return serializeString(this.config, value);
-        }
-        if (fields?.type === 'number' || isNumber(value, this.config.mapNumber.fromString)) {
-            return serializeNumber(this.config, value);
-        }
-        if (typeof value === 'string') {
-            return serializeString(this.config, value);
-        }
-        if (fields?.type === 'boolean' || typeof value === 'boolean') {
-            return serializeBoolean(this.config, value);
-        }
-        if (fields?.type === 'date' || value instanceof Date) {
-            return serializeDate(this.config, value);
-        }
-        if (fields?.type === 'period' || isDatePeriod(value)) {
-            const mapPeriod = this.config.mapPeriod;
-            if (mapPeriod.format) {
-                return mapPeriod.format(value);
-            }
-            else {
-                const [from, to] = value;
-                const transform = mapPeriod.transformMode;
-                if (transform.mode === 'join') {
-                    const period = [
-                        formatDate(from, this.config.mapPeriod.dateFormat),
-                        formatDate(to, this.config.mapPeriod.dateFormat),
-                    ];
-                    return period.join(transform.concat);
-                }
-            }
-        }
-        if (fields?.type === 'array' || Array.isArray(value)) {
-            return value.map((it) => this.serializeElement(it));
-        }
-        if (fields?.type === 'object' || isObject(value)) {
-            return (this.config.mapObject.format?.(value) ??
-                (this.config.mapObject.deep ? this.serialize(value) : JSON.stringify(value)));
-        }
-    }
-    deserializeElement(value, key) {
-        const field = this.config.mapFields?.[key || ''];
-        if (field && 'format' in field) {
-            return;
-        }
-        if (field?.type === 'array' || Array.isArray(value)) {
-            const array = Array.isArray(value) ? value : [value];
-            if (this.config.mapArray.removeNullable) {
-                if (!isNullable(value, this.config.mapNullable?.includeEmptyString)) {
-                    return array.map((it) => this.deserializeElement(it));
-                }
-                else {
-                    return;
-                }
-            }
-            else {
-                return !value ? [] : array.map((it) => this.deserializeElement(it));
-            }
-        }
-        if (field?.type === 'object') {
-            try {
-                if (this.config.mapObject.deep) {
-                    return isObject(value) ? this.deserialize(value) : value;
-                }
-                else {
-                    return typeof value === 'string' ? JSON.parse(value) : value;
-                }
-            }
-            catch {
-                return value;
-            }
-        }
-        if (field?.type === 'nullable' || isNullable(value, this.config.mapNullable?.includeEmptyString)) {
-            return this.config.mapNullable.parse?.(value) || value;
-        }
-        if (field?.type === 'boolean' ||
-            typeof value === 'boolean' ||
-            value === this.config.mapBoolean.true ||
-            value === this.config.mapBoolean.false) {
-            return this.config.mapBoolean.parse?.(value) ?? (value === this.config.mapBoolean.true || value === true);
-        }
-        const maybeDate = parseToDate(value, this.config.mapDate.dateFormat);
-        if (field?.type === 'date' || maybeDate) {
-            return this.config.mapDate.parse?.(value) || maybeDate;
-        }
-        const periodTransform = this.config.mapPeriod.transformMode;
-        if (periodTransform.mode === 'join') {
-            const maybePeriod = parseToDatePeriod(value, this.config.mapPeriod.dateFormat);
-            if (field?.type === 'period' || (maybePeriod || []).some(Boolean)) {
-                return this.config.mapPeriod.parse?.(value) || maybePeriod;
-            }
-        }
-        if (field?.type === 'number' || isNumber(value, this.config.mapNumber.fromString)) {
-            return this.config.mapNumber.parse?.(value) || Number(String(value).trim());
-        }
-        if (field?.type === 'string' || typeof value === 'string') {
-            const parsed = this.config.mapString.parse?.(value);
-            if (parsed !== undefined) {
-                return parsed;
-            }
-            return this.config.mapString.trim ? String(value).trim() : value;
-        }
-        return value;
-    }
-    parseQuery(val) {
-        return parseQueryParamsByMode(val, undefined, this.resolveArrayFieldModes());
-    }
-    parseJsonObject(val) {
-        try {
-            const parsed = JSON.parse(val);
-            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
-                return parsed;
-            }
-        }
-        catch (error) {
-            throw new Error(`Invalid JSON input: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        throw new Error('Invalid JSON input: expected a JSON object');
-    }
-    parseInputString(val) {
-        try {
-            return this.parseJsonObject(val);
-        }
-        catch {
-            return this.parseQuery(val);
-        }
-    }
-    mergeConfig(base, override) {
-        return {
-            ...base,
-            ...override,
-            mapString: { ...base.mapString, ...override.mapString },
-            mapNumber: { ...base.mapNumber, ...override.mapNumber },
-            mapBoolean: { ...base.mapBoolean, ...override.mapBoolean },
-            mapDate: { ...base.mapDate, ...override.mapDate },
-            mapPeriod: {
-                ...base.mapPeriod,
-                ...override.mapPeriod,
-                transformMode: {
-                    ...base.mapPeriod.transformMode,
-                    ...override.mapPeriod?.transformMode,
-                },
-            },
-            mapNullable: { ...base.mapNullable, ...override.mapNullable },
-            mapArray: { ...base.mapArray, ...override.mapArray },
-            mapObject: { ...base.mapObject, ...override.mapObject },
-            mapFields: { ...(base.mapFields || {}), ...(override.mapFields || {}) },
-        };
-    }
-    resolveArrayFieldModes() {
-        const result = {};
-        Object.entries(this.config.mapFields || {}).forEach(([key, field]) => {
-            if ('type' in field && field.type === 'array') {
-                result[key] = field.concatType ?? this.config.mapArray.concatType;
-            }
-        });
-        return result;
-    }
-}
-
 const createQuerySerializer = (config = {}) => {
     return new Serializer({
         mapArray: { concatType: 'comma' },
@@ -400,197 +30,6 @@ const createStrictSerializer = (config = {}) => {
     });
 };
 
-class LruCache {
-    map = new Map();
-    _limit = 100;
-    constructor(limit = 100) {
-        this.limit = limit;
-    }
-    get limit() {
-        return this._limit;
-    }
-    get length() {
-        return this.map.size;
-    }
-    set limit(value) {
-        this._limit = Math.max(1, Math.floor(value || 0));
-    }
-    get(key) {
-        if (!this.map.has(key)) {
-            return null;
-        }
-        const val = this.map.get(key);
-        this.map.delete(key);
-        this.map.set(key, val);
-        return val;
-    }
-    set(key, value) {
-        if (this.map.has(key)) {
-            this.map.delete(key);
-        }
-        else if (this.map.size >= this.limit) {
-            const oldest = this.map.keys().next().value;
-            oldest !== undefined && this.map.delete(oldest);
-        }
-        this.map.set(key, value);
-    }
-    remove(key) {
-        return this.map.delete(key);
-    }
-    clear() {
-        this.map.clear();
-    }
-    has(key) {
-        return this.map.has(key);
-    }
-    keys() {
-        return Array.from(this.map.keys());
-    }
-    values() {
-        return Array.from(this.map.values());
-    }
-    entries() {
-        return Array.from(this.map.entries());
-    }
-    toArray() {
-        return Array.from(this.map.values());
-    }
-    fromArray(entries) {
-        this.map.clear();
-        for (const [k, v] of entries) {
-            this.set(k, v);
-        }
-    }
-}
-
-class LocalStorage {
-    prefix;
-    constructor(prefix = 're') {
-        this.prefix = prefix;
-    }
-    get length() {
-        return Object.keys(localStorage).filter((key) => key.startsWith(this.safePrefix())).length;
-    }
-    get(key) {
-        const storageKey = this.getSafePrefix(key);
-        const raw = localStorage.getItem(storageKey);
-        if (raw == null) {
-            return null;
-        }
-        try {
-            const parsed = JSON.parse(raw);
-            return parsed ?? null;
-        }
-        catch {
-            localStorage.removeItem(storageKey);
-            return null;
-        }
-    }
-    set(key, value) {
-        const str = JSON.stringify(value);
-        localStorage.setItem(this.getSafePrefix(key), str);
-    }
-    remove(key) {
-        return localStorage.removeItem(this.getSafePrefix(key));
-    }
-    clear() {
-        const keys = Object.keys(localStorage).filter((key) => key.startsWith(this.safePrefix()));
-        keys.forEach((key) => localStorage.removeItem(key));
-    }
-    getSafePrefix(key) {
-        return this.prefix ? `${this.prefix}:${key}` : String(key);
-    }
-    safePrefix() {
-        return this.prefix ? `${this.prefix}:` : '';
-    }
-}
-
-class MemoryStorage {
-    cache = new Map();
-    get length() {
-        return this.cache.size;
-    }
-    get(key) {
-        return this.cache.get(key) ?? null;
-    }
-    set(key, value) {
-        this.cache.set(key, value);
-    }
-    remove(key) {
-        this.cache.delete(key);
-    }
-    clear() {
-        this.cache.clear();
-    }
-}
-
-class SessionStorage {
-    prefix;
-    constructor(prefix = 're') {
-        this.prefix = prefix;
-    }
-    get length() {
-        return Object.keys(sessionStorage).filter((key) => key.startsWith(this.safePrefix())).length;
-    }
-    get(key) {
-        const storageKey = this.getSafePrefix(key);
-        const raw = sessionStorage.getItem(storageKey);
-        if (raw == null) {
-            return null;
-        }
-        try {
-            const parsed = JSON.parse(raw);
-            return parsed ?? null;
-        }
-        catch {
-            sessionStorage.removeItem(storageKey);
-            return null;
-        }
-    }
-    set(key, value) {
-        const str = JSON.stringify(value);
-        sessionStorage.setItem(this.getSafePrefix(key), str);
-    }
-    remove(key) {
-        return sessionStorage.removeItem(this.getSafePrefix(key));
-    }
-    clear() {
-        const keys = Object.keys(sessionStorage).filter((key) => key.startsWith(this.safePrefix()));
-        keys.forEach((key) => sessionStorage.removeItem(key));
-    }
-    getSafePrefix(key) {
-        return this.prefix ? `${this.prefix}:${key}` : String(key);
-    }
-    safePrefix() {
-        return this.prefix ? `${this.prefix}:` : '';
-    }
-}
-
-/**
- * Factory for data storage strategies.
- *
- * Returns a `StorageInterface` implementation depending on the selected strategy:
- * - `'memory'`  — in-memory storage (for the session lifetime);
- * - `'session'` — `sessionStorage`, lives until the tab is closed;
- * - `'persist'` — `localStorage`, persists between sessions;
- * - `'lru'`     — size-limited cache (Least Recently Used).
- *
- * Used to choose an appropriate storage implementation
- * depending on the scenario: temporary data, long-term, cache, etc.
- *
- * @param strategy storage strategy type (`memory`, `session`, `persist`, `lru`)
- * @returns instance implementing `StorageInterface<Key, Type>`
- */
-const storageStrategy = (strategy, options = {}) => {
-    const fabrics = {
-        memory: () => new MemoryStorage(),
-        session: () => new SessionStorage(),
-        persist: () => new LocalStorage(),
-        lru: () => new LruCache(options.lruLimit ?? 100),
-    };
-    return fabrics[strategy]();
-};
-
 // noinspection ES6PreferShortImport
 const STATUM_CONFIG = new InjectionToken('RE_STATUM_CONFIG');
 const provideStatum = (config) => makeEnvironmentProviders([{ provide: STATUM_CONFIG, useValue: config }]);
@@ -638,6 +77,7 @@ class AbortError extends Error {
  */
 function isAbort(e) {
     return (e instanceof AbortError ||
+        (e instanceof DOMException && e.name === 'AbortError') ||
         (typeof e === 'object' && e != null && e?.name === 'AbortError' && e?.message === 'aborted'));
 }
 function joinUrl(base, path) {
@@ -837,10 +277,10 @@ class KeyedScheduler {
 class ResourceStore {
     http = inject(HttpClient);
     serializer;
-    #value = signal(null, ...(ngDevMode ? [{ debugName: "#value" }] : []));
-    #status = signal('idle', ...(ngDevMode ? [{ debugName: "#status" }] : []));
-    #error = signal(null, ...(ngDevMode ? [{ debugName: "#error" }] : []));
-    #activeRequests = signal(0, ...(ngDevMode ? [{ debugName: "#activeRequests" }] : []));
+    #value = signal(null, ...(ngDevMode ? [{ debugName: "#value" }] : /* istanbul ignore next */ []));
+    #status = signal('idle', ...(ngDevMode ? [{ debugName: "#status" }] : /* istanbul ignore next */ []));
+    #error = signal(null, ...(ngDevMode ? [{ debugName: "#error" }] : /* istanbul ignore next */ []));
+    #activeRequests = signal(0, ...(ngDevMode ? [{ debugName: "#activeRequests" }] : /* istanbul ignore next */ []));
     /**
      * Current resource value.
      * Returns `null` if no data yet or the request failed.
@@ -858,7 +298,7 @@ class ResourceStore {
      * Convenience loading flag: `true` when `loading` or `stale`.
      * Useful for spinners and disabling buttons.
      */
-    loading = computed(() => this.#activeRequests() > 0 || this.#status() === 'stale', ...(ngDevMode ? [{ debugName: "loading" }] : []));
+    loading = computed(() => this.#activeRequests() > 0 || this.#status() === 'stale', ...(ngDevMode ? [{ debugName: "loading" }] : /* istanbul ignore next */ []));
     routes;
     opts;
     maxEntries;
@@ -906,15 +346,20 @@ class ResourceStore {
         catch (error) {
             return Promise.reject(error);
         }
-        const entry = this.ensureEntry(key);
         const strategy = cfg.strategy ?? 'network-first';
         const ttlMs = cfg.ttlMs ?? this.opts.ttlMs ?? 0;
-        const fresh = entry.updatedAt != null && Date.now() - entry.updatedAt < ttlMs;
-        if (cfg.dedupe && entry.inflight) {
+        let entry = this.entries.get(key);
+        if (entry) {
+            // Keep hot keys at the end to approximate LRU order on cache reads too.
+            this.entries.delete(key);
+            this.entries.set(key, entry);
+        }
+        const fresh = entry?.updatedAt != null && Date.now() - entry.updatedAt < ttlMs;
+        if (cfg.dedupe && entry?.inflight) {
             return entry.inflight;
         }
         if (strategy === 'cache-only') {
-            if (fresh && entry.data != null) {
+            if (fresh && entry?.data != null) {
                 this.trace({ type: 'cache-hit', method: 'GET', key, strategy });
                 this.promoteCurrent(entry, cfg.promote);
                 return Promise.resolve(entry.data);
@@ -922,29 +367,44 @@ class ResourceStore {
             this.trace({ type: 'cache-miss', method: 'GET', key, strategy });
             return Promise.reject(new CacheMissError(key));
         }
-        if (strategy === 'cache-first' && fresh && !cfg.revalidate && entry.data != null) {
+        if (strategy === 'cache-first' && fresh && !cfg.revalidate && entry?.data != null) {
             this.trace({ type: 'cache-hit', method: 'GET', key, strategy });
             this.promoteCurrent(entry, cfg.promote);
             return Promise.resolve(entry.data);
         }
+        entry ??= this.ensureEntry(key);
         const delay = cfg.delay ?? this.opts.delay ?? 0;
         const mode = cfg.delayMode ?? this.opts.delayMode ?? 'debounce';
         const isSWR = strategy === 'cache-first' && entry.data != null;
         entry.status = isSWR ? 'stale' : 'loading';
+        if (!isSWR) {
+            entry.error = null;
+        }
         this.promoteCurrent(entry, cfg.promote);
         const retry = this.resolveRetryConfig(cfg.retry);
         const taskWithRetry = this.runWithRetry((attempt) => {
             this.trace({ type: 'request-start', method: 'GET', key, attempt });
-            return this.scheduler.schedule(key, mode, delay, this.exec$({
-                req$: this.http.get(url, { params: query, responseType: responseType }),
+            entry.controller = new AbortController();
+            const options = {
+                params: query,
+                responseType: responseType,
+                observe: 'response',
+                signal: entry.controller.signal,
+            };
+            const scheduled = this.scheduler.schedule(key, mode, delay, this.exec$({
+                req$: this.http.get(url, options),
                 entry,
                 promote: cfg.promote,
                 parseFn: cfg.parseResponse,
+                observe: cfg.observe,
             }));
+            void scheduled.catch(() => undefined);
+            return scheduled;
         }, retry, {
             method: 'GET',
             key,
         });
+        void taskWithRetry.catch(() => undefined);
         const resolvedTask = taskWithRetry
             .catch((error) => {
             if (isAbort(error)) {
@@ -1036,9 +496,12 @@ class ResourceStore {
         const entry = this.entries.get(key);
         this.trace({ type: 'abort', method, key });
         if (entry) {
+            entry.controller?.abort(reason instanceof Error ? reason : new AbortError(typeof reason === 'string' ? reason : undefined));
+            entry.controller = undefined;
             entry.inflight = undefined;
             if (entry.status === 'loading' || entry.status === 'stale') {
                 entry.status = 'idle';
+                this.promoteCurrent(entry, entry.promoted);
             }
         }
         this.scheduler.cancel?.(key, reason);
@@ -1050,10 +513,14 @@ class ResourceStore {
      */
     abortAll(reason) {
         this.trace({ type: 'abort', method: 'GET', key: '*' });
+        const abortReason = reason instanceof Error ? reason : new AbortError(typeof reason === 'string' ? reason : undefined);
         this.entries.forEach((entry) => {
+            entry.controller?.abort(abortReason);
+            entry.controller = undefined;
             entry.inflight = undefined;
             if (entry.status === 'loading' || entry.status === 'stale') {
                 entry.status = 'idle';
+                this.promoteCurrent(entry, entry.promoted);
             }
         });
         this.scheduler.cancelAll?.(reason);
@@ -1076,13 +543,18 @@ class ResourceStore {
         while (this.entries.size >= this.maxEntries) {
             let keyToDelete = null;
             for (const [key, value] of this.entries.entries()) {
-                if (!value.inflight) {
+                if (!value.inflight && !value.controller) {
                     keyToDelete = key;
                     break;
                 }
             }
             if (keyToDelete === null) {
+                // All entries have active requests — forced eviction. Dedupe for the evicted
+                // key will break: the in-flight request will finish but its result won't be cached.
                 keyToDelete = this.entries.keys().next().value ?? null;
+                if (keyToDelete !== null) {
+                    this.trace({ type: 'abort', method: 'GET', key: keyToDelete });
+                }
             }
             if (keyToDelete === null) {
                 break;
@@ -1114,25 +586,35 @@ class ResourceStore {
         const mode = config.delayMode ?? this.opts.delayMode ?? 'debounce';
         const retry = this.resolveRetryConfig(config.retry);
         entry.status = 'loading';
+        entry.error = null;
         this.promoteCurrent(entry, config.promote);
-        let req$;
-        if (method === 'DELETE') {
-            req$ = this.http.delete(url, {
-                body: payload,
-                params: query,
-                responseType: responseType,
-            });
-        }
-        else {
-            // @ts-ignore
-            req$ = this.mutationMethods[method](url, payload, {
-                params: query,
-                responseType: responseType,
-            });
-        }
         const task = this.runWithRetry((attempt) => {
             this.trace({ type: 'request-start', method, key, attempt });
-            return this.scheduler.schedule(key, mode, delay, this.exec$({ req$, entry, promote: config.promote, parseFn: config.parseResponse }));
+            entry.controller = new AbortController();
+            const signal = entry.controller.signal;
+            let req$;
+            if (method === 'DELETE') {
+                // @ts-ignore
+                req$ = this.http.delete(url, {
+                    body: payload,
+                    params: query,
+                    responseType: responseType,
+                    observe: 'response',
+                    signal,
+                });
+            }
+            else {
+                // @ts-ignore
+                req$ = this.mutationMethods[method](url, payload, {
+                    params: query,
+                    responseType: responseType,
+                    observe: 'response',
+                    signal,
+                });
+            }
+            const scheduled = this.scheduler.schedule(key, mode, delay, this.exec$({ req$, entry, promote: config.promote, parseFn: config.parseResponse, observe: config.observe }));
+            void scheduled.catch(() => undefined);
+            return scheduled;
         }, retry, { method, key })
             .then((data) => {
             this.trace({ type: 'cache-write', method, key });
@@ -1181,6 +663,9 @@ class ResourceStore {
         });
     }
     preparePayload(payload) {
+        if (payload instanceof FormData || payload instanceof Blob || payload instanceof ArrayBuffer) {
+            return payload;
+        }
         const presetPayload = this.opts.presetPayload;
         if (!presetPayload && !payload) {
             return {};
@@ -1214,6 +699,7 @@ class ResourceStore {
             attempts: Math.max(0, source.attempts ?? 0),
             delayMs: Math.max(0, source.delayMs ?? 0),
             backoff: source.backoff ?? 'constant',
+            jitter: source.jitter ?? false,
             shouldRetry: source.shouldRetry ?? this.defaultShouldRetry,
         };
     }
@@ -1228,29 +714,41 @@ class ResourceStore {
         }
         return status === 0 || status >= 500;
     }
-    async runWithRetry(exec, retry, context) {
-        let attempt = 1;
-        while (true) {
-            try {
-                return await exec(attempt);
+    runWithRetry(exec, retry, context) {
+        const runAttempt = (attempt) => exec(attempt).catch((error) => {
+            const canRetry = attempt <= retry.attempts && retry.shouldRetry(error, attempt);
+            if (!canRetry) {
+                throw error;
             }
-            catch (error) {
-                const canRetry = attempt <= retry.attempts && retry.shouldRetry(error, attempt);
-                if (!canRetry) {
-                    throw error;
-                }
-                const delayMs = retry.backoff === 'exponential' ? retry.delayMs * 2 ** (attempt - 1) : retry.delayMs;
-                this.trace({ type: 'request-retry', method: context.method, key: context.key, attempt, error });
-                attempt++;
-                if (delayMs > 0) {
-                    await new Promise((resolve) => setTimeout(resolve, delayMs));
-                }
+            const baseDelay = retry.backoff === 'exponential' ? retry.delayMs * 2 ** (attempt - 1) : retry.delayMs;
+            const jitterOffset = retry.jitter ? (Math.random() * 0.5 - 0.25) * baseDelay : 0;
+            const delayMs = Math.max(0, Math.round(baseDelay + jitterOffset));
+            this.trace({ type: 'request-retry', method: context.method, key: context.key, attempt, error });
+            if (delayMs > 0) {
+                return new Promise((resolve, reject) => {
+                    setTimeout(() => {
+                        void runAttempt(attempt + 1).then(resolve, reject);
+                    }, delayMs);
+                });
             }
-        }
+            return runAttempt(attempt + 1);
+        });
+        return runAttempt(1);
     }
-    exec$ = ({ req$, entry, promote = true, parseFn }) => () => {
+    exec$ = ({ req$, entry, promote = true, parseFn, observe }) => () => {
         promote && this.#activeRequests.update((n) => n + 1);
-        return req$.pipe(map((data) => (parseFn ? parseFn(data) : data)), tap({
+        return req$.pipe(map((httpResponse) => {
+            try {
+                this.opts.onResponse?.(httpResponse);
+            }
+            catch {
+                /* noop */
+            }
+            const payload = observe === 'response'
+                ? httpResponse
+                : httpResponse.body;
+            return parseFn ? parseFn(payload) : payload;
+        }), tap({
             next: (data) => {
                 entry.data = data;
                 entry.status = 'success';
@@ -1265,6 +763,7 @@ class ResourceStore {
             },
         }), finalize(() => {
             promote && this.#activeRequests.update((n) => Math.max(0, n - 1));
+            entry.controller = undefined;
             this.promoteCurrent(entry, promote);
         }));
     };
@@ -1272,6 +771,7 @@ class ResourceStore {
         if (!promote) {
             return;
         }
+        entry.promoted = true;
         this.#value.set(entry.data ?? null);
         this.#status.set(entry.status);
         this.#error.set(entry.error);
@@ -1339,22 +839,22 @@ class PagedQueryStore {
     #transport;
     #cache;
     /** Current page data (reactive). */
-    items = signal([], ...(ngDevMode ? [{ debugName: "items" }] : []));
+    items = signal([], ...(ngDevMode ? [{ debugName: "items" }] : /* istanbul ignore next */ []));
     /** Merged cache of pages (flat list) handy for search/export. */
-    cached = signal([], ...(ngDevMode ? [{ debugName: "cached" }] : []));
+    cached = signal([], ...(ngDevMode ? [{ debugName: "cached" }] : /* istanbul ignore next */ []));
     /** Loading flag of the current operation. */
-    loading = signal(false, ...(ngDevMode ? [{ debugName: "loading" }] : []));
+    loading = signal(false, ...(ngDevMode ? [{ debugName: "loading" }] : /* istanbul ignore next */ []));
     /** Last request error (if any). */
-    error = signal(null, ...(ngDevMode ? [{ debugName: "error" }] : []));
+    error = signal(null, ...(ngDevMode ? [{ debugName: "error" }] : /* istanbul ignore next */ []));
     /** Increments when the current dataset is reset/replaced. Useful for external consumers with local buffers. */
-    version = signal(0, ...(ngDevMode ? [{ debugName: "version" }] : []));
-    #page = signal(0, ...(ngDevMode ? [{ debugName: "#page" }] : []));
-    #pageSize = signal(20, ...(ngDevMode ? [{ debugName: "#pageSize" }] : []));
-    #totalElements = signal(0, ...(ngDevMode ? [{ debugName: "#totalElements" }] : []));
-    #filters = signal({}, ...(ngDevMode ? [{ debugName: "#filters" }] : []));
-    #query = signal({}, ...(ngDevMode ? [{ debugName: "#query" }] : []));
-    #sort = signal([], ...(ngDevMode ? [{ debugName: "#sort" }] : []));
-    #routeParams = signal({}, ...(ngDevMode ? [{ debugName: "#routeParams" }] : []));
+    version = signal(0, ...(ngDevMode ? [{ debugName: "version" }] : /* istanbul ignore next */ []));
+    #page = signal(0, ...(ngDevMode ? [{ debugName: "#page" }] : /* istanbul ignore next */ []));
+    #pageSize = signal(20, ...(ngDevMode ? [{ debugName: "#pageSize" }] : /* istanbul ignore next */ []));
+    #totalElements = signal(0, ...(ngDevMode ? [{ debugName: "#totalElements" }] : /* istanbul ignore next */ []));
+    #filters = signal({}, ...(ngDevMode ? [{ debugName: "#filters" }] : /* istanbul ignore next */ []));
+    #query = signal({}, ...(ngDevMode ? [{ debugName: "#query" }] : /* istanbul ignore next */ []));
+    #sort = signal([], ...(ngDevMode ? [{ debugName: "#sort" }] : /* istanbul ignore next */ []));
+    #routeParams = signal({}, ...(ngDevMode ? [{ debugName: "#routeParams" }] : /* istanbul ignore next */ []));
     pageState = this.#page.asReadonly();
     pageSizeState = this.#pageSize.asReadonly();
     totalElementsState = this.#totalElements.asReadonly();
@@ -1399,37 +899,18 @@ class PagedQueryStore {
     get sort() {
         return this.#sort();
     }
-    /**
-     * @deprecated Prefer `fetch(...)`, `refetchWith(...)`, or a dedicated setter method.
-     * Direct state mutation bypasses request semantics and should be treated as legacy.
-     */
     set filters(value) {
         this.#filters.set(value);
     }
-    /**
-     * @deprecated Prefer `fetch(...)`, `refetchWith(...)`, or a dedicated setter method.
-     * Direct state mutation bypasses request semantics and should be treated as legacy.
-     */
     set query(value) {
         this.#query.set(value);
     }
-    /**
-     * @deprecated Prefer `updatePage(...)`, `fetch(...)`, or `refetchWith(...)`.
-     * Direct state mutation bypasses request semantics and should be treated as legacy.
-     */
     set page(value) {
         this.#page.set(value);
     }
-    /**
-     * @deprecated Prefer `updatePageSize(...)`.
-     * Direct state mutation bypasses request semantics and should be treated as legacy.
-     */
     set pageSize(value) {
         this.#pageSize.set(value);
     }
-    /**
-     * @deprecated Managed by transport responses. Direct assignment should be treated as legacy.
-     */
     set totalElements(value) {
         this.#totalElements.set(value);
     }
@@ -1804,18 +1285,18 @@ class DictStore {
     metaStorage;
     ttlMs;
     revalidate;
-    cacheUpdatedAt = signal(null, ...(ngDevMode ? [{ debugName: "cacheUpdatedAt" }] : []));
+    cacheUpdatedAt = signal(null, ...(ngDevMode ? [{ debugName: "cacheUpdatedAt" }] : /* istanbul ignore next */ []));
     /**
      * Search text.
      * With `fixed: true` filters the local cache; with `fixed: false` triggers server search.
      */
-    searchText = signal('', ...(ngDevMode ? [{ debugName: "searchText" }] : []));
+    searchText = signal('', ...(ngDevMode ? [{ debugName: "searchText" }] : /* istanbul ignore next */ []));
     debouncedSearchText;
     /**
      * Additional filters for server request (or presets).
      */
-    filters = signal({}, ...(ngDevMode ? [{ debugName: "filters" }] : []));
-    cachedItems = signal([], ...(ngDevMode ? [{ debugName: "cachedItems" }] : []));
+    filters = signal({}, ...(ngDevMode ? [{ debugName: "filters" }] : /* istanbul ignore next */ []));
+    cachedItems = signal([], ...(ngDevMode ? [{ debugName: "cachedItems" }] : /* istanbul ignore next */ []));
     /**
      * Current list of dictionary items.
      * Source — local cache (fixed=true) or data from `PagedQueryStore`.
@@ -1826,7 +1307,7 @@ class DictStore {
             return this.debouncedSearchText() || !cached.length ? this.#helper.items() : cached;
         }
         return cached.length ? this.filterLocal() : this.#helper.items();
-    }, ...(ngDevMode ? [{ debugName: "items" }] : []));
+    }, ...(ngDevMode ? [{ debugName: "items" }] : /* istanbul ignore next */ []));
     /**
      * Ready-to-use dropdown options: `{ label, value }`.
      * Respects `maxOptionsSize` for truncating the list.
@@ -1834,9 +1315,9 @@ class DictStore {
     options = computed(() => {
         const options = this.items().map((it) => ({ label: String(it[this.labelKey] ?? ''), value: it[this.valueKey] }));
         return this.maxOptionsSize ? options.slice(0, this.maxOptionsSize) : options;
-    }, ...(ngDevMode ? [{ debugName: "options" }] : []));
+    }, ...(ngDevMode ? [{ debugName: "options" }] : /* istanbul ignore next */ []));
     _lastPromise = null;
-    _armed = signal(false, ...(ngDevMode ? [{ debugName: "_armed" }] : []));
+    _armed = signal(false, ...(ngDevMode ? [{ debugName: "_armed" }] : /* istanbul ignore next */ []));
     // todo add i18n support
     /**
      * @param apiUrl      dictionary endpoint (e.g., `'/api/dicts/countries'`)
@@ -2090,8 +1571,8 @@ class DictLocalStore {
      * Represents the full, unfiltered list of dictionary entries.
      * Used as the base data set for search and option generation.
      */
-    items = signal([], ...(ngDevMode ? [{ debugName: "items" }] : []));
-    #draftItems = signal([], ...(ngDevMode ? [{ debugName: "#draftItems" }] : []));
+    items = signal([], ...(ngDevMode ? [{ debugName: "items" }] : /* istanbul ignore next */ []));
+    #draftItems = signal([], ...(ngDevMode ? [{ debugName: "#draftItems" }] : /* istanbul ignore next */ []));
     /**
      * Computed list of options in `{ label, value }` format.
      *
@@ -2106,7 +1587,7 @@ class DictLocalStore {
             value: it[this.valueKey],
         }));
         return this.maxOptionsSize ? options.slice(0, this.maxOptionsSize) : options;
-    }, ...(ngDevMode ? [{ debugName: "options" }] : []));
+    }, ...(ngDevMode ? [{ debugName: "options" }] : /* istanbul ignore next */ []));
     labelKey;
     valueKey;
     maxOptionsSize;
@@ -2191,14 +1672,14 @@ class DictLocalStore {
 class EntityStore {
     idKey;
     sortIds;
-    byId = signal({}, ...(ngDevMode ? [{ debugName: "byId" }] : []));
-    ids = signal([], ...(ngDevMode ? [{ debugName: "ids" }] : []));
+    byId = signal({}, ...(ngDevMode ? [{ debugName: "byId" }] : /* istanbul ignore next */ []));
+    ids = signal([], ...(ngDevMode ? [{ debugName: "ids" }] : /* istanbul ignore next */ []));
     items = computed(() => {
         const byId = this.byId();
         return this.ids()
             .map((id) => byId[String(id)])
             .filter((item) => item !== undefined);
-    }, ...(ngDevMode ? [{ debugName: "items" }] : []));
+    }, ...(ngDevMode ? [{ debugName: "items" }] : /* istanbul ignore next */ []));
     constructor(config) {
         this.idKey = config.idKey;
         this.sortIds = config.sortIds;
@@ -2321,5 +1802,5 @@ class EntityStore {
  * Generated bundle index. Do not edit.
  */
 
-export { AbortError, CacheMissError, DictLocalStore, DictStore, EntityStore, LruCache, PagedQueryStore, RESOURCE_PROFILES, ResourceStore, STATUM_CONFIG, Serializer, SerializerFieldError, createBodySerializer, createQuerySerializer, createResourceProfile, createStrictSerializer, isAbort, provideStatum, storageStrategy };
+export { AbortError, CacheMissError, DictLocalStore, DictStore, EntityStore, PagedQueryStore, RESOURCE_PROFILES, ResourceStore, STATUM_CONFIG, createBodySerializer, createQuerySerializer, createResourceProfile, createStrictSerializer, isAbort, provideStatum };
 //# sourceMappingURL=reforgium-statum.mjs.map