@reforgium/statum 1.0.0

package/fesm2022/reforgium-statum.mjs

@@ -0,0 +1,1401 @@
+import { formatDate, isNullable, isDatePeriod, parseToDate, makeQuery, isNumber, isObject, parseToDatePeriod, parseQueryArray, fillUrlWithParams, concatArray } from '@reforgium/internal';
+import { InjectionToken, inject, signal, computed, DestroyRef, effect, untracked } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+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);
+
+/**
+ * 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 = {
+            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) {
+                result[key] = fields.format(value, obj);
+                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.parseQuery(val) : val;
+        const result = {};
+        for (const [key, value] of Object.entries(data ?? {})) {
+            const field = this.config.mapFields?.[key];
+            if (field && 'parse' in field) {
+                result[key] = field.parse(value, data);
+                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];
+                // @ts-ignore
+                if (field?.['type'] === '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;
+    };
+    /**
+     * 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 makeQuery(this.serialize(val), this.config.mapArray.concatType);
+    };
+    /**
+     * 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.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) {
+                    // @ts-ignore
+                    return this.deserializeElement(value);
+                }
+                else {
+                    // @ts-ignore
+                    return JSON.parse(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') {
+            return this.config.mapString.parse?.(value) || this.config.mapString.trim ? String(value).trim() : value;
+        }
+        return value;
+    }
+    parseQuery(val) {
+        try {
+            return JSON.parse(val);
+        }
+        catch {
+            const params = new URLSearchParams(val);
+            const data = {};
+            params.forEach((value, key) => {
+                const field = this.config.mapFields?.[key] || {};
+                const concatType = this.config.mapArray.concatType;
+                if ('type' in field && field.type === 'array') {
+                    data[key] ??= [];
+                    concatType !== 'multi' && (data[key] = parseQueryArray(value, concatType, key));
+                    concatType === 'multi' && data[key].push(value);
+                }
+                else {
+                    data[key] = value;
+                }
+            });
+            return data;
+        }
+    }
+}
+
+const SERIALIZER_CONFIG = new InjectionToken('SERIALIZER_CONFIG');
+
+class LruCache {
+    limit;
+    map = new Map();
+    constructor(limit = 100) {
+        this.limit = limit;
+    }
+    get length() {
+        return this.map.size;
+    }
+    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());
+    }
+    toArray() {
+        return Array.from(this.map.values());
+    }
+    fromArray(entries) {
+        this.map.clear();
+        for (const [k, v] of entries) {
+            this.set(k, v);
+        }
+    }
+}
+
+class LocalStorage {
+    get length() {
+        return localStorage.length;
+    }
+    get(key) {
+        const raw = localStorage.getItem(String(key));
+        const parsed = JSON.parse(raw ?? 'null');
+        return parsed ?? null;
+    }
+    set(key, value) {
+        const str = JSON.stringify(value);
+        localStorage.setItem(String(key), str);
+    }
+    remove(key) {
+        return localStorage.removeItem(String(key));
+    }
+    clear() {
+        return localStorage.clear();
+    }
+}
+
+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 {
+    get length() {
+        return sessionStorage.length;
+    }
+    get(key) {
+        const raw = sessionStorage.getItem(String(key));
+        const parsed = JSON.parse(raw ?? 'null');
+        return parsed ?? null;
+    }
+    set(key, value) {
+        const str = JSON.stringify(value);
+        sessionStorage.setItem(String(key), str);
+    }
+    remove(key) {
+        return sessionStorage.removeItem(String(key));
+    }
+    clear() {
+        return sessionStorage.clear();
+    }
+}
+
+/**
+ * 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) => {
+    const fabrics = {
+        memory: () => new MemoryStorage(),
+        session: () => new SessionStorage(),
+        persist: () => new LocalStorage(),
+        lru: () => new LruCache(),
+    };
+    return fabrics[strategy]();
+};
+
+/**
+ * Error thrown when requested data is missing in the cache.
+ *
+ * Used by the `cache-only` strategy when data is not found
+ * and a network request is not allowed.
+ *
+ * Example:
+ * ```ts
+ * try {
+ *   await store.get({ query }, { strategy: 'cache-only' });
+ * } catch (e) {
+ *   if (e instanceof CacheMissError) console.warn(e.key, 'not found in cache');
+ * }
+ * ```
+ */
+class CacheMissError extends Error {
+    key;
+    constructor(key) {
+        super(`Cache miss for key: ${key}`);
+        this.key = key;
+        this.name = 'CacheMissError';
+    }
+}
+/**
+ * Error indicating an aborted (canceled) request.
+ *
+ * May be thrown by `abort()` or `abortAll()` in `ResourceStore`.
+ * Usually does not require handling as an error — used to ignore canceled operations.
+ */
+class AbortError extends Error {
+    constructor(message = 'aborted') {
+        super(message);
+        this.name = 'AbortError';
+    }
+}
+/**
+ * Checks whether the exception is an `AbortError` (including compatible objects).
+ *
+ * @param e — any value that may be an error
+ * @returns `true` if it's an `AbortError`
+ */
+function isAbort(e) {
+    return (e instanceof AbortError ||
+        (typeof e === 'object' && e != null && e?.name === 'AbortError' && e?.message === 'aborted'));
+}
+function joinUrl(base, path) {
+    return base ? `${base.replace(/\/$/, '')}/${path.replace(/^\//, '')}` : path;
+}
+function buildKey(method, path) {
+    return `${method}|${path}`;
+}
+
+/**
+ * Per-key task scheduler with `debounce`/`throttle` and result deduplication.
+ *
+ * Allows applying delays and rate limiting separately for each key.
+ * All `schedule` calls for the same key are coalesced: consumers receive a single shared `Promise`
+ * that resolves with the value of the last started task.
+ *
+ * Suitable for API requests, auto-saving forms, incremental search, etc.
+ *
+ * Example:
+ * ```ts
+ * const ks = new KeyedScheduler();
+ * // these three calls collapse into one request after 300ms
+ * ks.schedule('users:list', 'debounce', 300, () => http.get<User[]>('/api/users'));
+ * ks.schedule('users:list', 'debounce', 300, () => http.get<User[]>('/api/users'));
+ * const users = await ks.schedule('users:list', 'debounce', 300, () => http.get<User[]>('/api/users'));
+ * ```
+ */
+class KeyedScheduler {
+    channels = new Map();
+    /**
+     * Schedule task execution for the specified key.
+     *
+     * Multiple calls with the same key are merged according to the mode:
+     * `debounce` — runs the last task after a pause;
+     * `throttle` — runs no more often than the specified delay (uses the last accumulated).
+     *
+     * All waiters receive the result of a single execution.
+     *
+     * @param key   logical channel key (e.g., `'users:list'`)
+     * @param mode  delay mode (`'debounce' | 'throttle'`)
+     * @param delay delay in milliseconds
+     * @param exec  Observable factory with the actual work (HTTP request, etc.)
+     * @returns Promise with the result of `exec`
+     */
+    schedule(key, mode, delay, exec) {
+        const channel = this.ensureChannel(key);
+        const promise = new Promise((resolve, reject) => {
+            channel.waiters.push({ resolve, reject });
+        });
+        channel.lastExec = exec;
+        if (delay <= 0) {
+            this.startExecution(channel);
+        }
+        else {
+            channel.subject.next({ mode, delay, exec });
+        }
+        return promise;
+    }
+    /**
+     * Cancels scheduled/running tasks for a key.
+     * All pending `Promise`s will be rejected with `AbortError` (or the provided reason).
+     *
+     * @param key    channel key
+     * @param reason cancellation reason (defaults to `AbortError('aborted')`)
+     */
+    cancel(key, reason = new AbortError()) {
+        const ch = this.channels.get(key);
+        if (!ch) {
+            return;
+        }
+        ch.timerSub?.unsubscribe();
+        ch.inflight?.unsubscribe();
+        ch.inflight = undefined;
+        ch.subject.complete();
+        const waiters = ch.waiters.splice(0);
+        waiters.forEach((w) => w.reject(reason));
+        this.channels.delete(key);
+    }
+    /**
+     * Cancels all channels and their pending tasks.
+     *
+     * @param reason cancellation reason (defaults to `AbortError('aborted')`)
+     */
+    cancelAll(reason = new AbortError()) {
+        for (const key of Array.from(this.channels.keys())) {
+            this.cancel(key, reason);
+        }
+    }
+    ensureChannel(key) {
+        let ch = this.channels.get(key);
+        if (ch) {
+            return ch;
+        }
+        const subject = new Subject();
+        ch = { subject, waiters: [] };
+        this.channels.set(key, ch);
+        const debounced$ = subject.pipe(filter((t) => t.mode === 'debounce'), debounce((t) => timer(t.delay)), tap(() => this.startExecution(ch)));
+        const throttled$ = subject.pipe(filter((t) => t.mode === 'throttle'), throttle((t) => timer(t.delay), { leading: false, trailing: true }), tap(() => this.startExecution(ch)));
+        ch.timerSub = merge(debounced$, throttled$)
+            .pipe(finalize(() => this.channels.delete(key)))
+            .subscribe();
+        return ch;
+    }
+    startExecution(ch) {
+        const exec = ch.lastExec;
+        if (!exec) {
+            return;
+        }
+        ch.inflight?.unsubscribe();
+        ch.inflight = exec().subscribe({
+            next: (val) => {
+                const waiters = ch.waiters.splice(0);
+                waiters.forEach((w) => w.resolve(val));
+            },
+            error: (err) => {
+                const waiters = ch.waiters.splice(0);
+                waiters.forEach((w) => w.reject(err));
+            },
+            complete: () => (ch.inflight = undefined),
+        });
+    }
+}
+
+/**
+ * Store for REST resources with caching and request deduplication.
+ *
+ * Provides reactive access to current value, status, and error;
+ * supports cache strategies (cache-first / cache-only / network-first),
+ * TTL, delays (debounce/throttle), request cancellation, and auto-serialization of query/payload.
+ *
+ * Example:
+ * ```ts
+ * const store = new ResourceStore({ GET: '/users/:id' }, { baseUrl: '/api', ttlMs: 30_000 });
+ *
+ * effect(() => {
+ *   if (store.loading()) showSpinner();
+ *   if (store.error()) showError(store.error());
+ *   const user = store.value();
+ * });
+ *
+ * await store.get({ params: { id: '42' }, query: { expand: ['roles'] } }, { strategy: 'cache-first', dedupe: true });
+ * ```
+ */
+class ResourceStore {
+    http = inject(HttpClient);
+    serializer = new Serializer(inject(SERIALIZER_CONFIG, { optional: true }) ?? {});
+    #value = signal(null, ...(ngDevMode ? [{ debugName: "#value" }] : []));
+    #status = signal('idle', ...(ngDevMode ? [{ debugName: "#status" }] : []));
+    #error = signal(null, ...(ngDevMode ? [{ debugName: "#error" }] : []));
+    /**
+     * Current resource value.
+     * Returns `null` if no data yet or the request failed.
+     */
+    value = this.#value.asReadonly();
+    /**
+     * Current loading status of the resource: `idle | loading | stale | success | error`.
+     */
+    status = this.#status.asReadonly();
+    /**
+     * Last error (if any). Otherwise `null`.
+     */
+    error = this.#error.asReadonly();
+    /**
+     * Convenience loading flag: `true` when `loading` or `stale`.
+     * Useful for spinners and disabling buttons.
+     */
+    loading = computed(() => ['loading', 'stale'].includes(this.#status()), ...(ngDevMode ? [{ debugName: "loading" }] : []));
+    routes;
+    opts;
+    entries = new Map();
+    scheduler = new KeyedScheduler();
+    /**
+     * @param routes Map of path templates for methods (`GET/POST/...` → `/users/:id`)
+     * @param opts   Global options (baseUrl, ttlMs, delay, delayMode, presetQueries/payload, etc.)
+     */
+    constructor(routes, opts = {}) {
+        this.routes = routes;
+        this.opts = opts;
+    }
+    /**
+     * Perform a GET request.
+     *
+     * Supports cache strategies (`strategy`), TTL (`ttlMs`), revalidation,
+     * deduplication (`dedupe`), and response parsing (`parseResponse`).
+     *
+     * @param args { params, query }
+     * @param cfg  Call settings (strategy, ttlMs, revalidate, parseResponse, delay, delayMode, dedupe, promote)
+     * @returns Deserialized `Data`
+     */
+    async get(args, cfg = {}) {
+        const url = this.buildUrl('GET', args);
+        const key = buildKey('GET', url);
+        const query = this.prepareQuery(args);
+        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) {
+            return entry.inflight;
+        }
+        if (strategy === 'cache-only') {
+            if (fresh && entry.data != null) {
+                this.promoteCurrent(entry, cfg.promote);
+                return entry.data;
+            }
+            throw new CacheMissError(key);
+        }
+        if (strategy === 'cache-first' && fresh && !cfg.revalidate && entry.data != null) {
+            this.promoteCurrent(entry, cfg.promote);
+            return entry.data;
+        }
+        const delay = cfg.delay ?? this.opts.delay ?? 0;
+        const mode = cfg.delayMode ?? this.opts.delayMode ?? 'debounce';
+        entry.status = strategy === 'cache-first' && fresh && entry.data != null ? 'stale' : 'loading';
+        this.promoteCurrent(entry, cfg.promote);
+        const task = this.scheduler.schedule(key, mode, delay, this.exec$({
+            req$: this.http.get(url, { params: query }),
+            entry,
+            promote: cfg.promote,
+            parseFn: cfg.parseResponse,
+        }));
+        cfg.dedupe && (entry.inflight = task);
+        void task.catch((e) => {
+            if (!isAbort(e)) {
+                throw e;
+            }
+        });
+        return task;
+    }
+    /**
+     * POST request.
+     *
+     * @param args { params, query, payload }
+     * @param cfg  Call settings (parseResponse, delay, delayMode, dedupe, promote)
+     * @returns API response (by default — as returned by the server)
+     */
+    async post(args, cfg = {}) {
+        return await this.callApi('POST', args, cfg);
+    }
+    /**
+     * PUT request (full resource update).
+     *
+     * @param args { params, query, payload }
+     * @param cfg  Call settings (parseResponse, delay, delayMode, dedupe, promote)
+     * @returns API response (by default — as returned by the server)
+     */
+    async put(args, cfg = {}) {
+        return await this.callApi('PUT', args, cfg);
+    }
+    /**
+     * PATCH request (partial update).
+     *
+     * @param args { params, query, payload }
+     * @param cfg  Call settings (parseResponse, delay, delayMode, dedupe, promote)
+     * @returns API response (by default — as returned by the server)
+     */
+    async patch(args, cfg = {}) {
+        return await this.callApi('PATCH', args, cfg);
+    }
+    /**
+     * DELETE request.
+     *
+     * @param args { params, query, payload }
+     * @param cfg  Call settings (parseResponse, delay, delayMode, dedupe, promote)
+     * @returns API response (by default — as returned by the server)
+     */
+    async delete(args, cfg = {}) {
+        return await this.callApi('DELETE', args, cfg);
+    }
+    /**
+     * Cancel scheduled/running requests for a specific call.
+     *
+     * @param method HTTP method
+     * @param args   Arguments used to build the URL (params, query)
+     * @param reason Cancellation reason (optional)
+     */
+    abort(method, args, reason) {
+        const url = this.buildUrl(method, args);
+        const key = buildKey(method, url);
+        this.scheduler.cancel?.(key, reason);
+    }
+    /**
+     * Cancel all scheduled/running requests for this store.
+     *
+     * @param reason Cancellation reason (optional)
+     */
+    abortAll(reason) {
+        this.scheduler.cancelAll?.(reason);
+    }
+    ensureEntry(key) {
+        let entry = this.entries.get(key);
+        if (!entry) {
+            entry = { data: null, status: 'idle', error: null, updatedAt: null };
+            this.entries.set(key, entry);
+        }
+        return entry;
+    }
+    async callApi(method, args, config = {}) {
+        const url = this.buildUrl(method, args);
+        const key = buildKey(method, url);
+        const query = this.prepareQuery(args);
+        const payload = { ...(this.opts.presetPayload || {}), ...(args.payload || {}) };
+        const serializedPayload = this.serializer.serialize(payload);
+        const entry = this.ensureEntry(key);
+        if (config.dedupe && entry.inflight) {
+            return entry.inflight;
+        }
+        const delay = config.delay ?? this.opts.delay ?? 0;
+        const mode = config.delayMode ?? this.opts.delayMode ?? 'debounce';
+        entry.status = 'loading';
+        this.promoteCurrent(entry, config.promote);
+        let req$;
+        if (method === 'DELETE') {
+            req$ = this.http.delete(url, { body: serializedPayload, params: query });
+        }
+        else {
+            // @ts-ignore
+            req$ = this.http[method.toLowerCase()](url, serializedPayload, { params: query });
+        }
+        const task = this.scheduler.schedule(key, mode, delay, this.exec$({ req$, entry, promote: config.promote, parseFn: config.parseResponse }));
+        config.dedupe && (entry.inflight = task);
+        void task.catch((e) => {
+            if (!isAbort(e)) {
+                throw e;
+            }
+        });
+        return task;
+    }
+    buildUrl(method, args) {
+        const tpl = this.routes[method];
+        if (!tpl) {
+            throw new Error(`${method} route not configured`);
+        }
+        const path = fillUrlWithParams(tpl, args.params);
+        return joinUrl(this.opts.baseUrl, path);
+    }
+    prepareQuery(args) {
+        const mergedQuery = { ...(this.opts.presetQueries || {}), ...(args.query || {}) };
+        return this.serializer.serialize(mergedQuery);
+    }
+    exec$ = ({ req$, entry, promote = true, parseFn }) => () => req$.pipe(map((data) => (parseFn ? parseFn(data) : data)), tap({
+        next: (data) => {
+            promote && (entry.data = data);
+            entry.status = 'success';
+            entry.updatedAt = Date.now();
+            entry.error = null;
+            this.promoteCurrent(entry, promote);
+        },
+        error: (err) => {
+            entry.error = err;
+            entry.status = 'error';
+            this.promoteCurrent(entry, promote);
+        },
+    }), finalize(() => {
+        entry.inflight = undefined;
+        this.promoteCurrent(entry, promote);
+    }));
+    promoteCurrent(entry, promote = true) {
+        if (!promote) {
+            return;
+        }
+        this.#value.set(entry.data ?? null);
+        this.#status.set(entry.status);
+        this.#error.set(entry.error);
+    }
+}
+
+const PDS_CONFIG = new InjectionToken('RE_PDS_CONFIG');
+
+// noinspection ES6PreferShortImport
+/**
+ * Store for paginated data (tables/lists) with per-page cache and unified requests.
+ *
+ * Provides:
+ * - reactive signals: `items`, `loading`, `cached`;
+ * - methods to control page/size/filters/sorting;
+ * - optional LRU cache by pages;
+ * - configurable transport (GET/POST/PATCH/…).
+ *
+ * Example:
+ * ```ts
+ * const ds = new PaginatedDataStore<User>('/users', { method: 'GET', hasCache: true });
+ * await ds.updatePage(0); // load the first page
+ * effect(() => console.log(ds.items(), ds.loading()));
+ * ```
+ */
+class PaginatedDataStore {
+    route;
+    config;
+    defaultConfig = inject(PDS_CONFIG);
+    #transport;
+    #cache;
+    /** Current page data (reactive). */
+    items = signal([], ...(ngDevMode ? [{ debugName: "items" }] : []));
+    /** Merged cache of pages (flat list) — handy for search/export. */
+    cached = signal([], ...(ngDevMode ? [{ debugName: "cached" }] : []));
+    /** Loading flag of the current operation. */
+    loading = signal(false, ...(ngDevMode ? [{ debugName: "loading" }] : []));
+    /** Current filters (applied to requests). */
+    filters = {};
+    /** Current sorting (`field,asc|desc`). */
+    sort;
+    /** Current page index (0-based). */
+    page = 0;
+    /** Default page size. */
+    pageSize = 20;
+    /** Total number of elements reported by the server. */
+    totalElements = 0;
+    /**
+     * @param route  Resource URL pattern (e.g., `'/users'`)
+     * @param config Store behavior: method, cache, request/response parsers, debounce, presets, etc.
+     */
+    constructor(route, config = {}) {
+        this.route = route;
+        this.config = config;
+        this.#cache = new LruCache(config.cacheSize);
+        this.applyConfig(config);
+        this.applyPresetMeta();
+        this.initTransport();
+        inject(DestroyRef).onDestroy(() => this.destroy());
+    }
+    /** Force reload current data (with the same page/filters/sort). */
+    refresh() {
+        return this.#fetchItems({});
+    }
+    /**
+     * Switch page with a request.
+     * If cache is enabled and the page is present in LRU — returns it from cache.
+     * @param page        page index (0-based)
+     * @param ignoreCache ignore cache and fetch from network
+     */
+    updatePage = (page = this.page, ignoreCache = false) => {
+        if (this.config.hasCache && this.#cache.has(page) && !ignoreCache) {
+            const cached = this.#cache.get(page);
+            this.items.set(cached);
+            this.page = page;
+            return Promise.resolve(cached);
+        }
+        else {
+            return this.#fetchItems({ page });
+        }
+    };
+    /**
+     * Change page size (will go to the first page) and fetch.
+     * @param size new size (rows per page)
+     */
+    updatePageSize = (size = this.pageSize) => {
+        return this.#fetchItems({ page: 0, size });
+    };
+    /**
+     * Update filters (goes to the first page) and fetch.
+     * Previous cache is cleared.
+     */
+    updateFilters = (filters) => {
+        this.#cache.clear();
+        this.cached.set([]);
+        return this.#fetchItems({ page: 0, filters: { ...this.filters, ...filters } });
+    };
+    /**
+     * Update state from table events (PrimeNG, etc.) and fetch.
+     * Supports `page/first/rows/sortField/sortOrder`.
+     */
+    updateQuery = ({ page: pageNum, first = 0, rows = 0, sortOrder, sortField }) => {
+        const page = (pageNum ?? (first && rows && Math.floor(first / rows))) || 0;
+        const sort = sortField ? `${sortField},${sortOrder === 1 ? 'asc' : 'desc'}` : '';
+        return this.#fetchItems({ page, sort });
+    };
+    /**
+     * Set filters from scratch (goes to the first page and resets sorting) and fetch.
+     * Useful for quick presets.
+     */
+    setFilters = (filters = {}) => {
+        this.#cache.clear();
+        this.cached.set([]);
+        return this.#fetchItems({ page: 0, filters, sort: undefined });
+    };
+    /**
+     * Change resource route (resets page, cache, and presets) without fetching.
+     * Useful when one store should work with different endpoints.
+     */
+    updateRoute = (route) => {
+        this.route = route;
+        this.page = 0;
+        this.pageSize = 20;
+        this.totalElements = 0;
+        this.#cache.clear();
+        this.cached.set([]);
+        this.initTransport();
+    };
+    /**
+     * Update store config on the fly (without re-creation).
+     * Does not trigger loading automatically.
+     */
+    updateConfig = (config) => {
+        this.config = { ...this.config, ...config };
+        this.applyPresetMeta();
+    };
+    /**
+     * Copy configuration and presets from another store of the same type.
+     */
+    copy(helper) {
+        this.applyConfig(helper.config);
+        this.applyPresetMeta();
+    }
+    /** Clean up resources and cancel active requests. Called automatically onDestroy. */
+    destroy() {
+        try {
+            this.#transport?.abortAll?.('PaginatedDataStore destroyed');
+        }
+        catch (e) {
+            if (!isAbort(e)) {
+                throw e;
+            }
+        }
+    }
+    #fetchItems = async ({ page = this.page, size = this.pageSize, sort = this.sort, filters = this.filters, }) => {
+        const query = this.parseQuery({ page, size, sort, filters });
+        this.loading.set(true);
+        this.#transport.abortAll();
+        try {
+            const response = await this.runTransport(filters, query);
+            const parsed = this.parseResponseData(response);
+            this.page = page;
+            this.sort = sort;
+            this.filters = filters;
+            this.pageSize = parsed.pageable?.pageSize || size;
+            this.totalElements = parsed.totalElements;
+            this.items.set(parsed.content);
+            this.updateCache(parsed.content);
+            return parsed.content;
+        }
+        catch (e) {
+            if (isAbort(e)) {
+                return;
+            }
+            throw e;
+        }
+        finally {
+            this.loading.set(false);
+        }
+    };
+    initTransport() {
+        this.#transport = new ResourceStore({ [this.config.method || 'GET']: this.route }, {
+            delay: this.config.debounceTime,
+            delayMode: 'debounce',
+            presetQueries: { page: this.page, size: this.pageSize, sort: this.sort },
+            presetPayload: this.filters,
+        });
+    }
+    async runTransport(payload, query) {
+        if (this.config.method === 'GET') {
+            return this.#transport.get({ query }, { promote: false, dedupe: true });
+        }
+        const method = this.config.method?.toLowerCase() || 'post';
+        // @ts-ignore
+        return this.#transport[method]({ query, payload }, { promote: false, dedupe: true });
+    }
+    parseQuery({ page = 0, size, sort, filters }) {
+        const method = this.config.method || 'GET';
+        const requestPayload = { page, size, ...(method === 'GET' ? filters : {}) };
+        const rawQueries = this.config.parseRequest?.({ ...requestPayload, sort }) || requestPayload;
+        const queries = {};
+        Object.entries(rawQueries).forEach(([key, value]) => {
+            if (Array.isArray(value)) {
+                queries[key] = concatArray(value, 'comma');
+            }
+            else if (!isNullable(value)) {
+                queries[key] = value;
+            }
+        });
+        sort && (queries['sort'] = sort);
+        return queries;
+    }
+    parseResponseData = (data) => {
+        if (this.config?.parseResponse) {
+            return this.config.parseResponse(data);
+        }
+        if (Array.isArray(data)) {
+            return this.parseFlatArray(data);
+        }
+        return data;
+    };
+    updateCache = (data) => {
+        if (this.config.hasCache) {
+            this.#cache.set(this.page, data);
+        }
+        this.cached.set(Array.from(this.#cache.values()).flat());
+    };
+    parseFlatArray(data) {
+        return { content: data, totalElements: data.length };
+    }
+    applyConfig(config) {
+        this.config = {
+            ...config,
+            method: config.method || this.defaultConfig.defaultMethod || 'POST',
+            presetQuery: config.presetQuery || this.defaultConfig.defaultQuery,
+            parseRequest: config.parseRequest || this.defaultConfig.defaultParseRequest,
+            debounceTime: config.debounceTime || 0,
+            hasCache: config.hasCache === undefined ? this.defaultConfig.defaultHasCache : config.hasCache,
+            cacheSize: config.cacheSize || this.defaultConfig.defaultCacheSize || 5,
+        };
+    }
+    applyPresetMeta() {
+        this.filters = this.config.presetFilters || {};
+        this.pageSize = this.config.presetQuery?.pageSize || 20;
+        this.page = this.config.presetQuery?.page || 0;
+        this.sort = this.config.presetQuery?.sort;
+    }
+}
+
+var _a;
+/**
+ * Dictionary store (select/options) with local LRU cache and optional persistence.
+ *
+ * Provides:
+ * - reactive `items` (current list) and `options` (label/value),
+ * - local cache filtering (`fixed: true`) or server-side search by name (`fixed: false`),
+ * - preload and restore cache from `storage` (`localStorage/session/LRU`),
+ * - smooth integration with `PaginatedDataStore` for server fetching.
+ *
+ * Example:
+ * ```ts
+ * const dict = new DictStore<Country>('/countries', 'countries', { labelKey: 'name', valueKey: 'code' });
+ * dict.search('ki'); // filters locally (fixed=true) or goes to server (fixed=false)
+ * effect(() => console.log(dict.options())); // [{label:'Kyrgyzstan', value:'KG'}, ...]
+ * ```
+ */
+class DictStore {
+    apiUrl;
+    storageKey;
+    static MAX_CACHE_SIZE = 400;
+    #helper;
+    #lru = new LruCache(_a.MAX_CACHE_SIZE);
+    #effectRefs = [];
+    fixed = true;
+    labelKey;
+    valueKey;
+    maxOptionsSize;
+    storage;
+    /**
+     * Search text.
+     * With `fixed: true` filters the local cache; with `fixed: false` triggers server search.
+     */
+    searchText = signal('', ...(ngDevMode ? [{ debugName: "searchText" }] : []));
+    /**
+     * Additional filters for server request (or presets).
+     */
+    filters = signal({}, ...(ngDevMode ? [{ debugName: "filters" }] : []));
+    cachedItems = signal([], ...(ngDevMode ? [{ debugName: "cachedItems" }] : []));
+    /**
+     * Current list of dictionary items.
+     * Source — local cache (fixed=true) or data from `PaginatedDataStore`.
+     */
+    items = computed(() => {
+        const cached = this.cachedItems();
+        if (!this.fixed) {
+            return this.searchText() || !cached.length ? this.#helper.items() : cached;
+        }
+        return cached.length ? this.filterLocal() : this.#helper.items();
+    }, ...(ngDevMode ? [{ debugName: "items" }] : []));
+    /**
+     * Ready-to-use dropdown options: `{ label, value }`.
+     * Respects `maxOptionsSize` for truncating the list.
+     */
+    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" }] : []));
+    _lastPromise = null;
+    _armed = false;
+    // todo add i18n support
+    /**
+     * @param apiUrl      dictionary endpoint (e.g., `'/api/dicts/countries'`)
+     * @param storageKey  key for saving cache in the selected strategy
+     * @param cfg         behavior (fixed/search, parsers, label/value keys, cache strategy, etc.)
+     */
+    constructor(apiUrl, storageKey, { method, autoLoad = true, presetFilters, parseResponse, parseRequest, debounceTime, fixed = true, maxOptionsSize, labelKey = 'name', valueKey = 'code', cacheStrategy = 'persist', }) {
+        this.apiUrl = apiUrl;
+        this.storageKey = storageKey;
+        this.#helper = new PaginatedDataStore(this.apiUrl, {
+            method: method,
+            hasCache: false,
+            presetFilters: { name: '', ...presetFilters },
+            parseResponse: parseResponse,
+            parseRequest: parseRequest,
+            debounceTime: debounceTime,
+        });
+        this.fixed = fixed;
+        this.labelKey = labelKey;
+        this.valueKey = valueKey;
+        this.maxOptionsSize = maxOptionsSize;
+        this._armed = autoLoad;
+        if (cacheStrategy !== 'memory') {
+            this.storage = storageStrategy(cacheStrategy);
+        }
+        this.restoreFromStorage();
+        this.#effectRefs.push(effect(() => {
+            const incoming = this.#helper.items();
+            if (incoming.length === 0) {
+                return;
+            }
+            untracked(() => this.mergeIntoCache(incoming));
+        }));
+        this.#effectRefs.push(effect(() => {
+            if (!this._armed) {
+                return;
+            }
+            const rest = this.filters();
+            if (!this.fixed) {
+                const query = this.searchText().trim();
+                this._lastPromise = untracked(() => this.#helper.updateFilters({ name: query, ...rest }));
+            }
+            else if (!this.cachedItems().length) {
+                this._lastPromise = untracked(() => this.#helper.updateFilters({ name: '', ...rest }));
+            }
+        }));
+    }
+    /** Восстановить кэш из выбранного хранилища (`persist`/`session`/`lru`/`memory`). */
+    restoreCache() {
+        this.restoreFromStorage();
+    }
+    /**
+     * Установить запрос и фильтры.
+     * При `fixed: false` инициирует серверный поиск; при `fixed: true` — локальную фильтрацию.
+     */
+    search = (name = '', filters = {}) => {
+        this._armed = true;
+        this.searchText.set(name);
+        this.filters.set(filters);
+    };
+    /**
+     * Найти отображаемую метку по значению (обычно для обратного биндинга).
+     * @returns строка метки или `undefined`, если не найдено
+     */
+    findLabel = (value) => {
+        for (const item of this.cachedItems()) {
+            if (item[this.valueKey] === value) {
+                return String(item[this.labelKey] ?? undefined);
+            }
+        }
+        return undefined;
+    };
+    /**
+     * Предзагрузить элементы словаря в локальный кэш.
+     * Удобно для SSR/статических списков/быстрых пресетов.
+     *
+     * @param items список элементов
+     * @param opts  `{ replace?: true }` — полностью заменить текущий кэш
+     */
+    preload = (items, opts) => {
+        opts?.replace && this.#lru.clear();
+        let changed = false;
+        for (const it of items) {
+            const key = this.keyOf(it);
+            if (!key) {
+                continue;
+            }
+            const existed = this.#lru.has(key);
+            this.#lru.set(key, it);
+            !existed && (changed = true);
+        }
+        if (changed || opts?.replace) {
+            const arr = this.#lru.toArray();
+            this.cachedItems.set(arr);
+            this.storage?.set(this.storageKey, arr.slice(0, _a.MAX_CACHE_SIZE));
+        }
+    };
+    /** Освободить ресурсы и остановить внутренние эффекты. */
+    dispose() {
+        this.#effectRefs.forEach((e) => e.destroy());
+        this.#effectRefs = [];
+    }
+    /** Синтаксический сахар для `using`/`Symbol.dispose`. */
+    [Symbol.dispose]() {
+        this.dispose();
+    }
+    mergeIntoCache(items) {
+        let changed = 0;
+        for (const it of items) {
+            const key = this.keyOf(it);
+            const before = this.#lru.has(key);
+            this.#lru.set(key, it);
+            !before && changed++;
+        }
+        if (changed > 0) {
+            const arr = this.#lru.toArray();
+            this.cachedItems.set(arr);
+            this.storage?.set(this.storageKey, arr.slice(0, _a.MAX_CACHE_SIZE));
+        }
+    }
+    restoreFromStorage() {
+        try {
+            const array = this.storage?.get(this.storageKey);
+            if (!array) {
+                return;
+            }
+            for (const it of array) {
+                const key = this.keyOf(it);
+                this.#lru.set(key, it);
+            }
+            this.cachedItems.set(this.#lru.toArray());
+        }
+        catch {
+            try {
+                this.storage?.remove(this.storageKey);
+            }
+            catch {
+                /* noop */
+            }
+        }
+    }
+    filterLocal() {
+        const list = this.cachedItems();
+        const query = this.searchText().toLowerCase();
+        if (!query) {
+            return list;
+        }
+        const key = this.labelKey;
+        const out = [];
+        for (let i = 0; i < list.length; i++) {
+            const val = list[i][key];
+            val.toLowerCase().includes(query) && out.push(list[i]);
+        }
+        return out;
+    }
+    keyOf(it) {
+        const raw = it[this.valueKey];
+        if (raw == null) {
+            return '';
+        }
+        return typeof raw === 'string' ? raw : String(raw);
+    }
+}
+_a = DictStore;
+
+class DictLocalStore {
+    items = signal([], ...(ngDevMode ? [{ debugName: "items" }] : []));
+    #draftItems = signal([], ...(ngDevMode ? [{ debugName: "#draftItems" }] : []));
+    /**
+     * Ready-to-use options for dropdowns: `{ label, value }`.
+     * Respects `maxOptionsSize` to truncate the list.
+     */
+    options = computed(() => {
+        const options = this.#draftItems().map((it) => ({
+            label: String(it[this.labelKey] ?? ''),
+            value: it[this.valueKey],
+        }));
+        return this.maxOptionsSize ? options.slice(0, this.maxOptionsSize) : options;
+    }, ...(ngDevMode ? [{ debugName: "options" }] : []));
+    labelKey;
+    valueKey;
+    maxOptionsSize;
+    constructor(items, config) {
+        this.labelKey = config?.labelKey ?? 'label';
+        this.valueKey = config?.valueKey ?? 'value';
+        this.maxOptionsSize = config?.maxOptionsSize ?? 1000;
+        this.items.set(items);
+        this.#draftItems.set(items);
+    }
+    /**
+     * No-op method for API compatibility with DictStore.
+     */
+    restoreCache() { }
+    /**
+     * Find display label by value (usually for reverse binding).
+     * @returns label string or `undefined` if not found
+     */
+    findLabel = (value) => {
+        for (const item of this.items()) {
+            if (item[this.valueKey] === value) {
+                return String(item[this.labelKey] ?? undefined);
+            }
+        }
+        return undefined;
+    };
+    search = (name = '') => {
+        const items = this.items();
+        if (name?.length) {
+            this.#draftItems.set(items.filter((item) => String(item[this.labelKey]).toLowerCase().includes(name.toLowerCase())));
+        }
+        else {
+            this.#draftItems.set(items);
+        }
+    };
+    preload = (items, opts) => {
+        if (opts?.replace) {
+            this.items.set(items);
+            this.#draftItems.set(items);
+        }
+        else {
+            const patch = [...this.items(), ...items];
+            this.items.set(patch);
+            this.#draftItems.set(patch);
+        }
+    };
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AbortError, CacheMissError, DictLocalStore, DictStore, LruCache, PDS_CONFIG, PaginatedDataStore, ResourceStore, SERIALIZER_CONFIG, Serializer, isAbort, storageStrategy };
+//# sourceMappingURL=reforgium-statum.mjs.map