@reforgium/statum 1.1.0 → 2.0.1

package/fesm2022/reforgium-statum.mjs

@@ -1,6 +1,6 @@
 import { formatDate, isNullable, isDatePeriod, parseToDate, makeQuery, isNumber, isObject, parseToDatePeriod, parseQueryArray, fillUrlWithParams, deepEqual, concatArray, debounceSignal } from '@reforgium/internal';
-import { InjectionToken, inject, signal, computed, DestroyRef, effect, untracked } from '@angular/core';
 import { HttpClient } from '@angular/common/http';
+import { InjectionToken, inject, signal, computed, DestroyRef, effect, untracked } from '@angular/core';
 import { Subject, filter, timer, merge, map } from 'rxjs';
 import { debounce, tap, throttle, finalize } from 'rxjs/operators';
 
@@ -182,7 +182,7 @@ class Serializer {
             return;
         }
         if (fields?.type === 'nullable' || isNullable(value, this.config.mapNullable?.includeEmptyString)) {
-            const nullableVal = value || null;
+            const nullableVal = value ?? null;
             return this.config.mapNullable.format?.(nullableVal) || this.config.mapNullable.replaceWith || nullableVal;
         }
         if (fields?.type === 'string') {
@@ -247,8 +247,7 @@ class Serializer {
         if (field?.type === 'object') {
             try {
                 if (this.config.mapObject.deep) {
-                    // @ts-ignore
-                    return this.deserializeElement(value);
+                    return isObject(value) ? this.deserialize(value) : value;
                 }
                 else {
                     // @ts-ignore
@@ -283,7 +282,11 @@ class Serializer {
             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;
+            const parsed = this.config.mapString.parse?.(value);
+            if (parsed !== undefined) {
+                return parsed;
+            }
+            return this.config.mapString.trim ? String(value).trim() : value;
         }
         return value;
     }
@@ -311,8 +314,6 @@ class Serializer {
     }
 }
 
-const SERIALIZER_CONFIG = new InjectionToken('SERIALIZER_CONFIG');
-
 class LruCache {
     limit;
     map = new Map();
@@ -356,6 +357,9 @@ class LruCache {
     values() {
         return Array.from(this.map.values());
     }
+    entries() {
+        return Array.from(this.map.entries());
+    }
     toArray() {
         return Array.from(this.map.values());
     }
@@ -368,23 +372,31 @@ class LruCache {
 }
 
 class LocalStorage {
+    prefix;
+    constructor(prefix = 're') {
+        this.prefix = prefix;
+    }
     get length() {
-        return localStorage.length;
+        return Object.keys(localStorage).filter((key) => key.startsWith(this.prefix || '')).length;
     }
     get(key) {
-        const raw = localStorage.getItem(String(key));
+        const raw = localStorage.getItem(this.getSafePrefix(key));
         const parsed = JSON.parse(raw ?? 'null');
         return parsed ?? null;
     }
     set(key, value) {
         const str = JSON.stringify(value);
-        localStorage.setItem(String(key), str);
+        localStorage.setItem(this.getSafePrefix(key), str);
     }
     remove(key) {
-        return localStorage.removeItem(String(key));
+        return localStorage.removeItem(this.getSafePrefix(key));
     }
     clear() {
-        return localStorage.clear();
+        const keys = Object.keys(localStorage).filter((key) => key.startsWith(this.prefix || ''));
+        keys.forEach((key) => localStorage.removeItem(key));
+    }
+    getSafePrefix(key) {
+        return this.prefix ? `${this.prefix}:${key}` : String(key);
     }
 }
 
@@ -408,23 +420,31 @@ class MemoryStorage {
 }
 
 class SessionStorage {
+    prefix;
+    constructor(prefix = 're') {
+        this.prefix = prefix;
+    }
     get length() {
-        return sessionStorage.length;
+        return Object.keys(sessionStorage).filter((key) => key.startsWith(this.prefix || '')).length;
     }
     get(key) {
-        const raw = sessionStorage.getItem(String(key));
+        const raw = sessionStorage.getItem(this.getSafePrefix(key));
         const parsed = JSON.parse(raw ?? 'null');
         return parsed ?? null;
     }
     set(key, value) {
         const str = JSON.stringify(value);
-        sessionStorage.setItem(String(key), str);
+        sessionStorage.setItem(this.getSafePrefix(key), str);
     }
     remove(key) {
-        return sessionStorage.removeItem(String(key));
+        return sessionStorage.removeItem(this.getSafePrefix(key));
     }
     clear() {
-        return sessionStorage.clear();
+        const keys = Object.keys(sessionStorage).filter((key) => key.startsWith(this.prefix || ''));
+        keys.forEach((key) => sessionStorage.removeItem(key));
+    }
+    getSafePrefix(key) {
+        return this.prefix ? `${this.prefix}:${key}` : String(key);
     }
 }
 
@@ -453,6 +473,9 @@ const storageStrategy = (strategy) => {
     return fabrics[strategy]();
 };
 
+// noinspection ES6PreferShortImport
+const STATUM_CONFIG = new InjectionToken('RE_STATUM_CONFIG');
+
 /**
  * Error thrown when requested data is missing in the cache.
  *
@@ -502,13 +525,32 @@ function joinUrl(base, path) {
     return base ? `${base.replace(/\/$/, '')}/${path.replace(/^\//, '')}` : path;
 }
 function buildKey(method, path, args) {
-    const params = Object.entries(args.params || {})
-        .map(([key, value]) => `${key}=${value}`)
-        .join('&');
-    const query = Object.entries(args.query || {})
-        .map(([key, value]) => `${key}=${value}`)
-        .join('&');
-    return `${method}|${path}|${params}|${query}`;
+    const params = stableStringify(args.params || {});
+    const query = stableStringify(args.query || {});
+    const payload = stableStringify(args.payload || {});
+    return `${method}|${path}|${params}|${query}|${payload}`;
+}
+function stableStringify(value) {
+    if (value === null || value === undefined) {
+        return '';
+    }
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+        return String(value);
+    }
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map((entry) => stableStringify(entry)).join(',')}]`;
+    }
+    if (typeof value === 'object') {
+        const entries = Object.entries(value)
+            .filter(([, v]) => v !== undefined)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([k, v]) => `${k}:${stableStringify(v)}`);
+        return `{${entries.join(',')}}`;
+    }
+    return String(value);
 }
 
 /**
@@ -647,7 +689,7 @@ class KeyedScheduler {
  */
 class ResourceStore {
     http = inject(HttpClient);
-    serializer = new Serializer(inject(SERIALIZER_CONFIG, { optional: true }) ?? {});
+    serializer = new Serializer(inject(STATUM_CONFIG, { optional: true })?.serializer ?? {});
     #value = signal(null, ...(ngDevMode ? [{ debugName: "#value" }] : []));
     #status = signal('idle', ...(ngDevMode ? [{ debugName: "#status" }] : []));
     #error = signal(null, ...(ngDevMode ? [{ debugName: "#error" }] : []));
@@ -696,6 +738,7 @@ class ResourceStore {
         const url = this.buildUrl('GET', args);
         const key = buildKey('GET', url, args);
         const query = this.prepareQuery(args);
+        const responseType = cfg.responseType ?? 'json';
         const entry = this.ensureEntry(key);
         const strategy = cfg.strategy ?? 'network-first';
         const ttlMs = cfg.ttlMs ?? this.opts.ttlMs ?? 0;
@@ -720,15 +763,15 @@ class ResourceStore {
         entry.status = isSWR ? 'stale' : 'loading';
         this.promoteCurrent(entry, cfg.promote);
         const task = this.scheduler.schedule(key, mode, delay, this.exec$({
-            req$: this.http.get(url, { params: query }),
+            req$: this.http.get(url, { params: query, responseType: responseType }),
             entry,
             promote: cfg.promote,
             parseFn: cfg.parseResponse,
         }));
         cfg.dedupe && (entry.inflight = task);
         void task.catch((e) => {
-            if (!isAbort(e)) {
-                throw e;
+            if (isAbort(e)) {
+                return;
             }
         });
         return task;
@@ -807,6 +850,7 @@ class ResourceStore {
         const query = this.prepareQuery(args);
         const payload = { ...(this.opts.presetPayload || {}), ...(args.payload || {}) };
         const serializedPayload = this.serializer.serialize(payload);
+        const responseType = config.responseType ?? 'json';
         const entry = this.ensureEntry(key);
         if (config.dedupe && entry.inflight) {
             return entry.inflight;
@@ -817,17 +861,24 @@ class ResourceStore {
         this.promoteCurrent(entry, config.promote);
         let req$;
         if (method === 'DELETE') {
-            req$ = this.http.delete(url, { body: serializedPayload, params: query });
+            req$ = this.http.delete(url, {
+                body: serializedPayload,
+                params: query,
+                responseType: responseType,
+            });
         }
         else {
             // @ts-ignore
-            req$ = this.http[method.toLowerCase()](url, serializedPayload, { params: query });
+            req$ = this.http[method.toLowerCase()](url, serializedPayload, {
+                params: query,
+                responseType: responseType,
+            });
         }
         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;
+            if (isAbort(e)) {
+                return;
             }
         });
         return task;
@@ -875,8 +926,6 @@ class ResourceStore {
     }
 }
 
-const PDS_CONFIG = new InjectionToken('RE_PDS_CONFIG');
-
 // noinspection ES6PreferShortImport
 /**
  * Store for paginated data (tables/lists) with per-page cache and unified requests.
@@ -897,7 +946,7 @@ const PDS_CONFIG = new InjectionToken('RE_PDS_CONFIG');
 class PaginatedDataStore {
     route;
     config;
-    defaultConfig = inject(PDS_CONFIG, { optional: true }) || {};
+    defaultConfig = inject(STATUM_CONFIG, { optional: true })?.paginatedData || {};
     #transport;
     #cache;
     /** Current page data (reactive). */
@@ -924,8 +973,8 @@ class PaginatedDataStore {
     constructor(route, config = {}) {
         this.route = route;
         this.config = config;
-        this.#cache = new LruCache(config.cacheSize);
         this.applyConfig(config);
+        this.#cache = new LruCache(this.config.cacheSize);
         this.applyPresetMeta();
         this.initTransport();
         inject(DestroyRef).onDestroy(() => this.destroy());
@@ -1004,7 +1053,7 @@ class PaginatedDataStore {
      *
      * @param params Dictionary of route parameters (e.g., `{ id: '123' }`)
      * @param opts   Options object
-     * @param opts.reset  If `true` (default), resets page to 0, clears cache, total elements count, and items
+     * @param opts.reset  If `true`, resets page to 0, clears cache, total elements count, and items
      * @param opts.abort  If `true`, aborts all active transport requests and sets loading to false
      *
      * @example
@@ -1044,6 +1093,7 @@ class PaginatedDataStore {
      */
     updateConfig = (config) => {
         this.config = { ...this.config, ...config };
+        this.#cache.limit = this.config.cacheSize || this.defaultConfig.defaultCacheSize || 5;
         this.applyPresetMeta();
     };
     /**
@@ -1152,6 +1202,9 @@ class PaginatedDataStore {
             hasCache: config.hasCache === undefined ? this.defaultConfig.defaultHasCache : config.hasCache,
             cacheSize: config.cacheSize || this.defaultConfig.defaultCacheSize || 5,
         };
+        if (this.#cache) {
+            this.#cache.limit = this.config.cacheSize;
+        }
     }
     applyPresetMeta() {
         this.filters = this.config.presetFilters || {};
@@ -1182,6 +1235,12 @@ class DictStore {
     apiUrl;
     storageKey;
     static MAX_CACHE_SIZE = 400;
+    /**
+     * Default dictionary configuration resolved from {@link STATUM_CONFIG}.
+     *
+     * Used as a global fallback when local configuration does not explicitly
+     */
+    defaultConfig = inject(STATUM_CONFIG, { optional: true })?.dict || {};
     #helper;
     #lru = new LruCache(_a.MAX_CACHE_SIZE);
     #effectRefs = [];
@@ -1195,7 +1254,7 @@ class DictStore {
      * With `fixed: true` filters the local cache; with `fixed: false` triggers server search.
      */
     searchText = signal('', ...(ngDevMode ? [{ debugName: "searchText" }] : []));
-    debouncedSearchText = debounceSignal(this.searchText, 300);
+    debouncedSearchText;
     /**
      * Additional filters for server request (or presets).
      */
@@ -1228,9 +1287,11 @@ class DictStore {
      * @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', }) {
+    constructor(apiUrl, storageKey, { autoLoad = true, method = this.defaultConfig.defaultRestMethod, presetFilters = this.defaultConfig.defaultPresetFilters, parseResponse, parseRequest, debounceTime = this.defaultConfig.defaultDebounceTime, fixed = true, maxOptionsSize = this.defaultConfig.defaultMaxOptionsSize, labelKey = this.defaultConfig.defaultLabelKey || 'name', valueKey = this.defaultConfig.defaultValueKey || 'code', keyPrefix = this.defaultConfig.defaultPrefix || 're', cacheStrategy = this.defaultConfig.defaultCacheStrategy || 'persist', }) {
         this.apiUrl = apiUrl;
         this.storageKey = storageKey;
+        const searchDebounce = debounceTime ?? 300;
+        this.debouncedSearchText = debounceSignal(this.searchText, searchDebounce);
         this.#helper = new PaginatedDataStore(this.apiUrl, {
             method: method,
             hasCache: false,
@@ -1243,10 +1304,11 @@ class DictStore {
         this.labelKey = labelKey;
         this.valueKey = valueKey;
         this.maxOptionsSize = maxOptionsSize;
-        this._armed.set(autoLoad);
         if (cacheStrategy !== 'memory') {
             this.storage = storageStrategy(cacheStrategy);
+            this.storage.prefix = keyPrefix;
         }
+        this.setAutoload(autoLoad);
         this.restoreFromStorage();
         this.#effectRefs.push(effect(() => {
             const incoming = this.#helper.items();
@@ -1377,7 +1439,9 @@ class DictStore {
         const out = [];
         for (let i = 0; i < list.length; i++) {
             const val = list[i][key];
-            val.toLowerCase().includes(query) && out.push(list[i]);
+            String(val ?? '')
+                .toLowerCase()
+                .includes(query) && out.push(list[i]);
         }
         return out;
     }
@@ -1388,15 +1452,41 @@ class DictStore {
         }
         return typeof raw === 'string' ? raw : String(raw);
     }
+    setAutoload(autoLoad) {
+        if (autoLoad === 'whenEmpty') {
+            const isEmpty = !this.storage?.get(this.storageKey)?.length;
+            this._armed.set(isEmpty);
+        }
+        else {
+            this._armed.set(autoLoad);
+        }
+    }
 }
 _a = DictStore;
 
 class DictLocalStore {
+    /**
+     * Default dictionary configuration resolved from {@link STATUM_CONFIG}.
+     *
+     * Used as a global fallback when local configuration does not explicitly
+     * define dictionary keys.
+     */
+    defaultConfig = inject(STATUM_CONFIG, { optional: true })?.dict || {};
+    /**
+     * Source dictionary items.
+     *
+     * 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" }] : []));
     /**
-     * Ready-to-use options for dropdowns: `{ label, value }`.
-     * Respects `maxOptionsSize` to truncate the list.
+     * Computed list of options in `{ label, value }` format.
+     *
+     * Based on the current draft items (after search/filtering).
+     * Respects `maxOptionsSize` to limit the number of generated options.
+     *
+     * Intended for direct use in dropdowns and select-like components.
      */
     options = computed(() => {
         const options = this.#draftItems().map((it) => ({
@@ -1409,19 +1499,30 @@ class DictLocalStore {
     valueKey;
     maxOptionsSize;
     constructor(items, config) {
-        this.labelKey = config?.labelKey ?? 'label';
-        this.valueKey = config?.valueKey ?? 'value';
-        this.maxOptionsSize = config?.maxOptionsSize ?? 1000;
+        this.labelKey = config?.labelKey ?? (this.defaultConfig.defaultLabelKey || 'name');
+        this.valueKey = config?.valueKey ?? (this.defaultConfig.defaultValueKey || 'code');
+        this.maxOptionsSize = config?.maxOptionsSize ?? this.defaultConfig.defaultMaxOptionsSize ?? 1000;
         this.items.set(items);
         this.#draftItems.set(items);
     }
+    // noinspection JSUnusedGlobalSymbols
     /**
-     * No-op method for API compatibility with DictStore.
+     * Restore cached dictionary state.
+     *
+     * This implementation is a no-op and exists only for API compatibility
+     * with {@link DictStore}.
      */
     restoreCache() { }
     /**
-     * Find display label by value (usually for reverse binding).
-     * @returns label string or `undefined` if not found
+     * Resolve display label by value.
+     *
+     * Performs a linear search over dictionary items and returns
+     * the corresponding label for the given value.
+     *
+     * Commonly used for reverse binding (value → label).
+     *
+     * @param value Dictionary value to look up
+     * @returns Resolved label string, or `undefined` if not found
      */
     findLabel = (value) => {
         for (const item of this.items()) {
@@ -1431,6 +1532,16 @@ class DictLocalStore {
         }
         return undefined;
     };
+    /**
+     * Filter dictionary items by label.
+     *
+     * Applies a case-insensitive substring match against the label field
+     * and updates the internal draft items used for option generation.
+     *
+     * Passing an empty string resets the filter and restores all items.
+     *
+     * @param name Search query string
+     */
     search = (name = '') => {
         const items = this.items();
         if (name?.length) {
@@ -1440,6 +1551,18 @@ class DictLocalStore {
             this.#draftItems.set(items);
         }
     };
+    /**
+     * Preload additional dictionary items.
+     *
+     * Can either replace the current items completely or append
+     * new entries to the existing list.
+     *
+     * Updates both the source items and the current draft items.
+     *
+     * @param items Items to preload
+     * @param opts Preload options
+     * @param opts.replace When `true`, replaces existing items instead of appending
+     */
     preload = (items, opts) => {
         if (opts?.replace) {
             this.items.set(items);
@@ -1457,5 +1580,5 @@ class DictLocalStore {
  * Generated bundle index. Do not edit.
  */
 
-export { AbortError, CacheMissError, DictLocalStore, DictStore, LruCache, PDS_CONFIG, PaginatedDataStore, ResourceStore, SERIALIZER_CONFIG, Serializer, isAbort, storageStrategy };
+export { AbortError, CacheMissError, DictLocalStore, DictStore, LruCache, PaginatedDataStore, ResourceStore, STATUM_CONFIG, Serializer, isAbort, storageStrategy };
 //# sourceMappingURL=reforgium-statum.mjs.map