http-request-manager 18.0.12 → 18.1.1

package/esm2022/lib/services/local-storage-manager-service/local-storage-signals-manager.service.mjs

@@ -0,0 +1,277 @@
+import { Inject, Injectable, Optional, signal, computed, effect, inject } from '@angular/core';
+import { UtilsService } from '../utils/utils.service';
+import { SymmetricalEncryptionService } from '../utils/encryption/symmetrical-encryption.service';
+import { StorageOption, StorageType } from './models';
+import { SettingOptions } from './models/setting-options.model';
+import { EncryptionTestService } from '../utils/encryption/encryption-test.service';
+import { AppService } from '../utils/app.service';
+import { CONFIG_SETTINGS_TOKEN } from '../../models/config-token.model';
+import { ObjectMergerService } from '../utils/object-merger.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../request-manager-services";
+const initialState = {
+    localStores: [],
+    sessionStores: [],
+    settings: [],
+};
+export class LocalStorageSignalsManagerService {
+    constructor(configOptions) {
+        this.configOptions = configOptions;
+        this.state = signal(initialState);
+        this.storageName = 'storage';
+        this.storageSettingsName = 'global-storage';
+        this.defaultOptions = SettingOptions.adapt();
+        this.stateRetrieved = false;
+        this.encrypted = false;
+        this.app = inject(AppService);
+        this.utils = inject(UtilsService);
+        this.objectMergerService = inject(ObjectMergerService);
+        this.encryption = inject(SymmetricalEncryptionService);
+        this.encryptionTest = inject(EncryptionTestService);
+        // --- SELECTORS ---
+        this.stores = computed(() => this.state().settings);
+        this.storeExists = (store) => computed(() => !!this.state().settings.find(item => item.name === store));
+        this.store = (store) => computed(() => {
+            const data = this.state();
+            const foundStore = data.settings.find(item => item.name === store);
+            if (!foundStore)
+                return null;
+            const options = SettingOptions.adapt(foundStore.options);
+            const found = options.storage === StorageType.GLOBAL
+                ? data.localStores.find(item => item.id === foundStore.id)
+                : data.sessionStores.find(item => item.id === foundStore.id);
+            if (!found) {
+                this.deleteStore({ name: store });
+                return null;
+            }
+            if (!this.app?.appID) {
+                console.warn('No App ID found - AppId not Provided');
+                return null;
+            }
+            const storageData = options.encrypted
+                ? this.encryption.decrypt(found.data, this.app.appID)
+                : found.data;
+            return this.isString(storageData) ? JSON.parse(storageData) : storageData;
+        });
+        this.settings = computed(() => this.state().settings);
+        this.setting = (store) => computed(() => this.state().settings.find(item => item.name === store) ?? null);
+        this.storageName = configOptions?.LocalStorageOptions?.storageName || this.storageName;
+        this.storageSettingsName = configOptions?.LocalStorageOptions?.storageSettingsName || this.storageSettingsName;
+        this.defaultOptions = configOptions?.LocalStorageOptions?.options || this.defaultOptions;
+        this.retrieveState();
+        // Auto-persist when state changes
+        effect(() => {
+            if (this.stateRetrieved) {
+                this.persistState(this.state());
+            }
+        });
+        // Expiration timer every 3s
+        setInterval(() => {
+            const state = this.state();
+            const expired = this.expired(state);
+            if (expired.length > 0) {
+                const ids = expired.map(i => i.id);
+                const updated = {
+                    ...state,
+                    localStores: state.localStores.filter(i => !ids.includes(i.id)),
+                    sessionStores: state.sessionStores.filter(i => !ids.includes(i.id)),
+                    settings: state.settings.filter(i => !ids.includes(i.id)),
+                };
+                this.state.set(updated);
+                this.persistState(updated);
+            }
+        }, 3000);
+    }
+    // --- STATE MUTATORS ---
+    setStore(store) {
+        this.state.update(state => {
+            const settings = StorageOption.adapt(store);
+            settings.options = this.objectMergerService.mergeStorageOptions(settings.options);
+            store.name = this.validStoreName(store.name);
+            const str = this.encryptionTest.isEncrypted(store.data) ? store.data : JSON.stringify(store.data);
+            const dataStr = this.isObjectOrArray(str) && store.options.encrypted
+                ? this.encryption.encrypt(str, this.app.appID)
+                : store.data;
+            const localData = dataStr && settings.options?.storage === StorageType.GLOBAL
+                ? [{ data: dataStr, id: settings.id }]
+                : [];
+            const sessionData = dataStr && settings.options?.storage === StorageType.SESSION
+                ? [{ data: dataStr, id: settings.id }]
+                : [];
+            return {
+                ...state,
+                localStores: [...state.localStores, ...localData],
+                sessionStores: [...state.sessionStores, ...sessionData],
+                settings: [...state.settings, settings],
+            };
+        });
+    }
+    createStore(store) {
+        this.state.update(state => {
+            const settings = StorageOption.adapt(store);
+            settings.options = this.objectMergerService.mergeStorageOptions(settings.options);
+            if (state.settings.some(item => item.name === store.name)) {
+                return state;
+            }
+            if (!this.isObjectOrArray(store.data)) {
+                console.warn('Data must be an Object or Array');
+                return state;
+            }
+            const dataStr = store.options.encrypted ? this.encryption.encrypt(store.data, this.app.appID) : store.data;
+            const localData = settings.options?.storage === StorageType.GLOBAL ? [{ data: dataStr, id: settings.id }] : [];
+            const sessionData = settings.options?.storage === StorageType.SESSION ? [{ data: dataStr, id: settings.id }] : [];
+            return {
+                ...state,
+                localStores: [...state.localStores, ...localData],
+                sessionStores: [...state.sessionStores, ...sessionData],
+                settings: [...state.settings, settings],
+            };
+        });
+    }
+    updateStore(store) {
+        this.state.update(state => {
+            const settings = state.settings.find(item => item.name === store.name);
+            if (!settings)
+                return state;
+            const dataStr = settings.options?.encrypted
+                ? this.encryption.encrypt(store.data, this.app.appID)
+                : store.data;
+            const localData = settings.options?.storage === StorageType.GLOBAL ? [{ data: dataStr, id: settings.id }] : [];
+            const sessionData = settings.options?.storage === StorageType.SESSION ? [{ data: dataStr, id: settings.id }] : [];
+            return {
+                ...state,
+                localStores: [...state.localStores.filter(i => i.id !== settings.id), ...localData],
+                sessionStores: [...state.sessionStores.filter(i => i.id !== settings.id), ...sessionData],
+            };
+        });
+    }
+    deleteStore(store) {
+        this.state.update(state => {
+            const id = state.settings.find(item => item.name === store.name)?.id;
+            if (!id)
+                return state;
+            return {
+                ...state,
+                localStores: state.localStores.filter(i => i.id !== id),
+                sessionStores: state.sessionStores.filter(i => i.id !== id),
+                settings: state.settings.filter(i => i.id !== id),
+            };
+        });
+    }
+    resetStore() {
+        const cleared = { localStores: [], sessionStores: [], settings: [] };
+        this.state.set(cleared);
+        this.persistState(cleared);
+    }
+    // --- HELPERS ---
+    persistState(state) {
+        localStorage.setItem(this.storageName, JSON.stringify(state.localStores));
+        sessionStorage.setItem(this.storageName, JSON.stringify(state.sessionStores));
+        const settingsStr = this.encryption.encrypt(state.settings, this.app.appID);
+        localStorage.setItem(this.storageSettingsName, settingsStr || '');
+    }
+    expired(state) {
+        return state.settings.filter(s => (s.options?.expires || 0) > 0 && this.utils.hasExpired(s.options?.expires));
+    }
+    retrieveState() {
+        const str = localStorage.getItem(this.storageSettingsName);
+        const localStr = localStorage.getItem(this.storageName);
+        const sessionStr = sessionStorage.getItem(this.storageName);
+        const localData = localStr ? JSON.parse(localStr) : [];
+        const sessionData = sessionStr ? JSON.parse(sessionStr) : [];
+        const decryptedStr = str ? this.encryption.decrypt(str, this.app.appID) : null;
+        const settings = decryptedStr ? JSON.parse(decryptedStr) : [];
+        settings.forEach(store => {
+            // normalize options so we compare numbers and compute expires correctly
+            const options = SettingOptions.adapt(store.options);
+            // if persisted data included expiresIn but not numeric expires, compute it now
+            if ((!options.expires || options.expires === 0) && options.expiresIn) {
+                try {
+                    const computed = this.utils.expires(options.expiresIn);
+                    options.expires = computed || 0;
+                }
+                catch {
+                    options.expires = 0;
+                }
+            }
+            const expired = (options.expires || 0) > 0 && this.utils.hasExpired(options.expires || 0);
+            if (!expired) {
+                const hasStorage = this.hasGlobalStorage(options.storage, store.id || '');
+                if (!hasStorage) {
+                    this.createStore({ id: store.id, name: store.name, data: [], options });
+                }
+                else {
+                    const storeData = (options.storage === StorageType.GLOBAL)
+                        ? localData.find(item => item.id === store.id)
+                        : sessionData.find(item => item.id === store.id);
+                    this.setStore({ id: store.id || '', name: store.name, data: storeData?.data, options });
+                }
+            }
+        });
+        this.stateRetrieved = true;
+        // Ensure all stored settings have numeric expires computed and persisted
+        try {
+            const current = this.state();
+            let changed = false;
+            const normalizedSettings = current.settings.map(s => {
+                const opts = SettingOptions.adapt(s.options);
+                if ((!opts.expires || opts.expires === 0) && opts.expiresIn) {
+                    const computed = this.utils.expires(opts.expiresIn) || 0;
+                    if (computed && computed !== opts.expires) {
+                        opts.expires = computed;
+                        changed = true;
+                    }
+                }
+                return { ...s, options: opts };
+            });
+            if (changed) {
+                const updated = { ...current, settings: normalizedSettings };
+                this.state.set(updated);
+                this.persistState(updated);
+            }
+        }
+        catch (e) {
+            // swallow normalization errors to avoid breaking init
+        }
+    }
+    hasGlobalStorage(type = StorageType.GLOBAL, id) {
+        const strData = [];
+        if (type === StorageType.GLOBAL) {
+            const str = localStorage.getItem(this.storageName);
+            strData.push(...(str ? JSON.parse(str) : []));
+        }
+        else {
+            const str = sessionStorage.getItem(this.storageName);
+            strData.push(...(str ? JSON.parse(str) : []));
+        }
+        const found = strData.find(store => store.id === id);
+        return !!found;
+    }
+    isObjectOrArray(obj) {
+        try {
+            const parsed = typeof obj === 'object' ? obj : JSON.parse(obj);
+            return typeof parsed === 'object' && parsed !== null;
+        }
+        catch {
+            return false;
+        }
+    }
+    isString(obj) {
+        return Object.prototype.toString.call(obj) === '[object String]';
+    }
+    validStoreName(str) {
+        return str.toLowerCase().replace(/\s+/g, '_').replace(/[^ -~]/g, '');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LocalStorageSignalsManagerService, deps: [{ token: CONFIG_SETTINGS_TOKEN, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LocalStorageSignalsManagerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LocalStorageSignalsManagerService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.ConfigOptions, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [CONFIG_SETTINGS_TOKEN]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"local-storage-signals-manager.service.js","sourceRoot":"","sources":["../../../../../../projects/http-request-manager/src/lib/services/local-storage-manager-service/local-storage-signals-manager.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, Optional, WritableSignal, signal, computed, effect, inject } from '@angular/core';\n\nimport { UtilsService } from '../utils/utils.service';\nimport { SymmetricalEncryptionService } from '../utils/encryption/symmetrical-encryption.service';\n\nimport { StorageOption, StorageType } from './models';\nimport { SettingOptions } from './models/setting-options.model';\nimport { StorageData } from './models/storage-data.model';\nimport { EncryptionTestService } from '../utils/encryption/encryption-test.service';\nimport { AppService } from '../utils/app.service';\nimport { CONFIG_SETTINGS_TOKEN } from '../../models/config-token.model';\nimport { ConfigOptions } from '../request-manager-services';\nimport { ObjectMergerService } from '../utils/object-merger.service';\n\nexport interface State {\n  localStores: StorageData[];\n  sessionStores: StorageData[];\n  settings: StorageOption[];\n}\n\nconst initialState: State = {\n  localStores: [],\n  sessionStores: [],\n  settings: [],\n};\n\n@Injectable({ providedIn: 'root' })\nexport class LocalStorageSignalsManagerService {\n\n  private state: WritableSignal<State> = signal(initialState);\n\n  storageName = 'storage';\n  storageSettingsName = 'global-storage';\n  defaultOptions = SettingOptions.adapt();\n\n  stateRetrieved = false;\n  encrypted = false;\n\n  app = inject(AppService);\n  utils = inject(UtilsService);\n  objectMergerService = inject(ObjectMergerService);\n  encryption = inject(SymmetricalEncryptionService);\n  encryptionTest = inject(EncryptionTestService);\n\n  // --- SELECTORS ---\n\n  readonly stores = computed(() => this.state().settings);\n\n  readonly storeExists = (store: string) =>\n    computed(() => !!this.state().settings.find(item => item.name === store));\n\n  readonly store = (store: string) =>\n    computed(() => {\n      const data = this.state();\n      const foundStore = data.settings.find(item => item.name === store);\n      if (!foundStore) return null;\n\n      const options = SettingOptions.adapt(foundStore.options);\n      const found =\n        options.storage === StorageType.GLOBAL\n          ? data.localStores.find(item => item.id === foundStore.id)\n          : data.sessionStores.find(item => item.id === foundStore.id);\n\n      if (!found) {\n        this.deleteStore({ name: store });\n        return null;\n      }\n\n      if (!this.app?.appID) {\n        console.warn('No App ID found - AppId not Provided');\n        return null;\n      }\n\n      const storageData = options.encrypted\n        ? this.encryption.decrypt(found.data, this.app.appID)\n        : found.data;\n\n      return this.isString(storageData) ? JSON.parse(storageData) : storageData;\n    });\n\n  readonly settings = computed(() => this.state().settings);\n\n  readonly setting = (store: string) =>\n    computed(() => this.state().settings.find(item => item.name === store) ?? null);\n\n  constructor(@Optional() @Inject(CONFIG_SETTINGS_TOKEN) private configOptions?: ConfigOptions) {\n    this.storageName = configOptions?.LocalStorageOptions?.storageName || this.storageName;\n    this.storageSettingsName = configOptions?.LocalStorageOptions?.storageSettingsName || this.storageSettingsName;\n    this.defaultOptions = configOptions?.LocalStorageOptions?.options || this.defaultOptions;\n\n    this.retrieveState();\n    // Auto-persist when state changes\n    effect(() => {\n      if (this.stateRetrieved) {\n        this.persistState(this.state());\n      }\n    });\n\n    // Expiration timer every 3s\n    setInterval(() => {\n      const state = this.state();\n      const expired = this.expired(state);\n      if (expired.length > 0) {\n        const ids = expired.map(i => i.id);\n        const updated: State = {\n          ...state,\n          localStores: state.localStores.filter(i => !ids.includes(i.id)),\n          sessionStores: state.sessionStores.filter(i => !ids.includes(i.id)),\n          settings: state.settings.filter(i => !ids.includes(i.id)),\n        };\n        this.state.set(updated);\n        this.persistState(updated);\n      }\n    }, 3000);\n  }\n\n  // --- STATE MUTATORS ---\n\n  setStore(store: { id: string; name: string; data: any; options: SettingOptions }) {\n    this.state.update(state => {\n      const settings = StorageOption.adapt(store);\n      settings.options = this.objectMergerService.mergeStorageOptions(settings.options);\n      store.name = this.validStoreName(store.name);\n\n      const str = this.encryptionTest.isEncrypted(store.data) ? store.data : JSON.stringify(store.data);\n      const dataStr =\n        this.isObjectOrArray(str) && store.options.encrypted\n          ? this.encryption.encrypt(str, this.app.appID)\n          : store.data;\n\n      const localData =\n        dataStr && settings.options?.storage === StorageType.GLOBAL\n          ? [{ data: dataStr, id: settings.id }]\n          : [];\n      const sessionData =\n        dataStr && settings.options?.storage === StorageType.SESSION\n          ? [{ data: dataStr, id: settings.id }]\n          : [];\n\n      return {\n        ...state,\n        localStores: [...state.localStores, ...localData],\n        sessionStores: [...state.sessionStores, ...sessionData],\n        settings: [...state.settings, settings],\n      };\n    });\n  }\n\n  createStore(store: { id?: string; name: string; data: any; options: SettingOptions }) {\n    this.state.update(state => {\n      const settings = StorageOption.adapt(store);\n      settings.options = this.objectMergerService.mergeStorageOptions(settings.options);\n\n      if (state.settings.some(item => item.name === store.name)) {\n        return state;\n      }\n\n      if (!this.isObjectOrArray(store.data)) {\n        console.warn('Data must be an Object or Array');\n        return state;\n      }\n\n      const dataStr =\n        store.options.encrypted ? this.encryption.encrypt(store.data, this.app.appID) : store.data;\n\n      const localData =\n        settings.options?.storage === StorageType.GLOBAL ? [{ data: dataStr, id: settings.id }] : [];\n      const sessionData =\n        settings.options?.storage === StorageType.SESSION ? [{ data: dataStr, id: settings.id }] : [];\n\n      return {\n        ...state,\n        localStores: [...state.localStores, ...localData],\n        sessionStores: [...state.sessionStores, ...sessionData],\n        settings: [...state.settings, settings],\n      };\n    });\n  }\n\n  updateStore(store: { name: string; data: any }) {\n    this.state.update(state => {\n      const settings = state.settings.find(item => item.name === store.name);\n      if (!settings) return state;\n\n      const dataStr =\n        settings.options?.encrypted\n          ? this.encryption.encrypt(store.data, this.app.appID)\n          : store.data;\n\n      const localData =\n        settings.options?.storage === StorageType.GLOBAL ? [{ data: dataStr, id: settings.id }] : [];\n      const sessionData =\n        settings.options?.storage === StorageType.SESSION ? [{ data: dataStr, id: settings.id }] : [];\n\n      return {\n        ...state,\n        localStores: [...state.localStores.filter(i => i.id !== settings.id), ...localData],\n        sessionStores: [...state.sessionStores.filter(i => i.id !== settings.id), ...sessionData],\n      };\n    });\n  }\n\n  deleteStore(store: { name: string }) {\n    this.state.update(state => {\n      const id = state.settings.find(item => item.name === store.name)?.id;\n      if (!id) return state;\n      return {\n        ...state,\n        localStores: state.localStores.filter(i => i.id !== id),\n        sessionStores: state.sessionStores.filter(i => i.id !== id),\n        settings: state.settings.filter(i => i.id !== id),\n      };\n    });\n  }\n\n  resetStore() {\n    const cleared: State = { localStores: [], sessionStores: [], settings: [] };\n    this.state.set(cleared);\n    this.persistState(cleared);\n  }\n\n  // --- HELPERS ---\n\n  private persistState(state: State) {\n    localStorage.setItem(this.storageName, JSON.stringify(state.localStores));\n    sessionStorage.setItem(this.storageName, JSON.stringify(state.sessionStores));\n    const settingsStr = this.encryption.encrypt(state.settings, this.app.appID);\n    localStorage.setItem(this.storageSettingsName, settingsStr || '');\n  }\n\n  private expired(state: State) {\n    return state.settings.filter(\n      s => (s.options?.expires || 0) > 0 && this.utils.hasExpired(s.options?.expires!)\n    );\n  }\n\n  retrieveState() {\n\n    const str = localStorage.getItem(this.storageSettingsName);\n\n    const localStr = localStorage.getItem(this.storageName);\n    const sessionStr = sessionStorage.getItem(this.storageName);\n\n    const localData: StorageData[] = localStr ? JSON.parse(localStr) : [];\n    const sessionData: StorageData[] = sessionStr ? JSON.parse(sessionStr) : [];\n\n    const decryptedStr = str ? this.encryption.decrypt(str, this.app.appID) : null;\n    const settings: StorageOption[] = decryptedStr ? JSON.parse(decryptedStr) : [];\n\n    settings.forEach(store => {\n\n\n      // normalize options so we compare numbers and compute expires correctly\n      const options = SettingOptions.adapt(store.options);\n\n      // if persisted data included expiresIn but not numeric expires, compute it now\n      if ((!options.expires || options.expires === 0) && options.expiresIn) {\n        try {\n          const computed = this.utils.expires(options.expiresIn as string);\n          options.expires = computed || 0;\n        } catch {\n          options.expires = 0;\n        }\n      }\n\n      const expired = (options.expires || 0) > 0 && this.utils.hasExpired(options.expires || 0);\n\n      if (!expired) {\n\n        const hasStorage = this.hasGlobalStorage(options.storage, store.id || '');\n\n        if (!hasStorage) {\n          this.createStore({ id: store.id, name: store.name, data: [], options });\n        } else {\n          const storeData = (options.storage === StorageType.GLOBAL)\n            ? localData.find(item => item.id === store.id)\n            : sessionData.find(item => item.id === store.id);\n          this.setStore({ id: store.id || '', name: store.name, data: storeData?.data, options });\n        }\n\n      }\n\n    });\n\n    this.stateRetrieved = true;\n\n    // Ensure all stored settings have numeric expires computed and persisted\n    try {\n      const current = this.state();\n      let changed = false;\n      const normalizedSettings = current.settings.map(s => {\n        const opts = SettingOptions.adapt(s.options);\n        if ((!opts.expires || opts.expires === 0) && opts.expiresIn) {\n          const computed = this.utils.expires(opts.expiresIn as string) || 0;\n          if (computed && computed !== opts.expires) {\n            opts.expires = computed;\n            changed = true;\n          }\n        }\n        return { ...s, options: opts } as StorageOption;\n      });\n\n      if (changed) {\n        const updated: State = { ...current, settings: normalizedSettings };\n        this.state.set(updated);\n        this.persistState(updated);\n      }\n    } catch (e) {\n      // swallow normalization errors to avoid breaking init\n    }\n\n  }\n\n  private hasGlobalStorage(type: StorageType = StorageType.GLOBAL, id: string) {\n    const strData: StorageData[] = [];\n\n    if (type === StorageType.GLOBAL) {\n      const str = localStorage.getItem(this.storageName);\n      strData.push(...(str ? JSON.parse(str) : []));\n    } else {\n      const str = sessionStorage.getItem(this.storageName);\n      strData.push(...(str ? JSON.parse(str) : []));\n    }\n\n    const found = strData.find(store => store.id === id);\n    return !!found;\n  }\n\n  private isObjectOrArray(obj: any) {\n    try {\n      const parsed = typeof obj === 'object' ? obj : JSON.parse(obj);\n      return typeof parsed === 'object' && parsed !== null;\n    } catch {\n      return false;\n    }\n  }\n\n  private isString(obj: any) {\n    return Object.prototype.toString.call(obj) === '[object String]';\n  }\n\n  private validStoreName(str: string) {\n    return str.toLowerCase().replace(/\\s+/g, '_').replace(/[^ -~]/g, '');\n  }\n}\n"]}

package/esm2022/lib/services/local-storage-manager-service/models/setting-options.model.mjs

@@ -7,7 +7,11 @@ export class SettingOptions {
         this.encrypted = encrypted;
     }
     static adapt(item) {
-        return new SettingOptions((item?.storage) ? item.storage : StorageType.GLOBAL, (item?.expires) ? item.expires : 0, (item?.expiresIn) ? item.expiresIn : '', (item?.encrypted) ? item?.encrypted : false);
+        const storage = (typeof item?.storage !== 'undefined' && item?.storage !== null) ? Number(item.storage) : StorageType.GLOBAL;
+        const expires = (typeof item?.expires !== 'undefined' && item?.expires !== null) ? Number(item.expires) : 0;
+        const expiresIn = (typeof item?.expiresIn !== 'undefined' && item?.expiresIn !== null) ? item.expiresIn : '';
+        const encrypted = (typeof item?.encrypted !== 'undefined' && item?.encrypted !== null) ? Boolean(item.encrypted) : false;
+        return new SettingOptions(storage, expires, expiresIn, encrypted);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/request-manager-services/rxjs-operators/request-polling.mjs

@@ -1,14 +1,33 @@
 import { interval } from 'rxjs';
 import { mergeMap, startWith, takeUntil, tap } from 'rxjs/operators';
-/**
- * @param pollInterval
- * @param stopCondition$
- * @param isPending$
- */
 export function requestPolling(pollInterval, stopCondition$, isPending$) {
     return (source) => {
         return interval(pollInterval * 1000)
-            .pipe(startWith(0), tap(() => isPending$.next(true)), mergeMap(() => source), tap(() => isPending$.next(false)), takeUntil(stopCondition$));
+            .pipe(startWith(0), tap(() => {
+            try {
+                if (isPending$ && typeof isPending$.next === 'function') {
+                    isPending$.next(true);
+                }
+                else if (isPending$ && typeof isPending$.set === 'function') {
+                    isPending$.set(true);
+                }
+            }
+            catch (e) {
+                // no-op if setting fails
+            }
+        }), mergeMap(() => source), tap(() => {
+            try {
+                if (isPending$ && typeof isPending$.next === 'function') {
+                    isPending$.next(false);
+                }
+                else if (isPending$ && typeof isPending$.set === 'function') {
+                    isPending$.set(false);
+                }
+            }
+            catch (e) {
+                // no-op if setting fails
+            }
+        }), takeUntil(stopCondition$));
     };
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVxdWVzdC1wb2xsaW5nLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvaHR0cC1yZXF1ZXN0LW1hbmFnZXIvc3JjL2xpYi9zZXJ2aWNlcy9yZXF1ZXN0LW1hbmFnZXItc2VydmljZXMvcnhqcy1vcGVyYXRvcnMvcmVxdWVzdC1wb2xsaW5nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBK0IsUUFBUSxFQUFFLE1BQU0sTUFBTSxDQUFDO0FBQzdELE9BQU8sRUFBRSxRQUFRLEVBQUUsU0FBUyxFQUFFLFNBQVMsRUFBRSxHQUFHLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUVyRTs7OztHQUlHO0FBRUgsTUFBTSxVQUFVLGNBQWMsQ0FBSSxZQUFvQixFQUFFLGNBQStCLEVBQUUsVUFBb0M7SUFDM0gsT0FBTyxDQUFDLE1BQXFCLEVBQWlCLEVBQUU7UUFDOUMsT0FBTyxRQUFRLENBQUMsWUFBWSxHQUFHLElBQUksQ0FBQzthQUNuQyxJQUFJLENBQ0gsU0FBUyxDQUFDLENBQUMsQ0FBQyxFQUNaLEdBQUcsQ0FBQyxHQUFHLEVBQUUsQ0FBQyxVQUFVLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDLEVBQ2hDLFFBQVEsQ0FBQyxHQUFHLEVBQUUsQ0FBQyxNQUFNLENBQUMsRUFDdEIsR0FBRyxDQUFDLEdBQUcsRUFBRSxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsRUFDakMsU0FBUyxDQUFDLGNBQWMsQ0FBQyxDQUMxQixDQUFDO0lBQ0osQ0FBQyxDQUFDO0FBQ0osQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEJlaGF2aW9yU3ViamVjdCwgT2JzZXJ2YWJsZSwgaW50ZXJ2YWwgfSBmcm9tICdyeGpzJztcbmltcG9ydCB7IG1lcmdlTWFwLCBzdGFydFdpdGgsIHRha2VVbnRpbCwgdGFwIH0gZnJvbSAncnhqcy9vcGVyYXRvcnMnO1xuXG4vKipcbiAqIEBwYXJhbSBwb2xsSW50ZXJ2YWxcbiAqIEBwYXJhbSBzdG9wQ29uZGl0aW9uJFxuICogQHBhcmFtIGlzUGVuZGluZyRcbiAqL1xuXG5leHBvcnQgZnVuY3Rpb24gcmVxdWVzdFBvbGxpbmc8VD4ocG9sbEludGVydmFsOiBudW1iZXIsIHN0b3BDb25kaXRpb24kOiBPYnNlcnZhYmxlPGFueT4sIGlzUGVuZGluZyQ6IEJlaGF2aW9yU3ViamVjdDxib29sZWFuPikge1xuICByZXR1cm4gKHNvdXJjZTogT2JzZXJ2YWJsZTxUPik6IE9ic2VydmFibGU8VD4gPT4ge1xuICAgIHJldHVybiBpbnRlcnZhbChwb2xsSW50ZXJ2YWwgKiAxMDAwKVxuICAgIC5waXBlKFxuICAgICAgc3RhcnRXaXRoKDApLCBcbiAgICAgIHRhcCgoKSA9PiBpc1BlbmRpbmckLm5leHQodHJ1ZSkpLFxuICAgICAgbWVyZ2VNYXAoKCkgPT4gc291cmNlKSxcbiAgICAgIHRhcCgoKSA9PiBpc1BlbmRpbmckLm5leHQoZmFsc2UpKSxcbiAgICAgIHRha2VVbnRpbChzdG9wQ29uZGl0aW9uJCksXG4gICAgKTtcbiAgfTtcbn0iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/utils/object-merger.service.mjs

@@ -1,6 +1,7 @@
-import { Inject, Injectable, Optional } from '@angular/core';
+import { Inject, Injectable, Optional, inject } from '@angular/core';
 import { ApiRequest } from '../request-manager-state-service/models';
 import { SettingOptions } from '../local-storage-manager-service';
+import { UtilsService } from '../utils/utils.service';
 import { CONFIG_SETTINGS_TOKEN } from '../../models/config-token.model';
 import { ConfigHTTPOptions, ConfigOptions, LocalStorageOptions } from '../request-manager-services';
 import * as i0 from "@angular/core";
@@ -8,6 +9,7 @@ import * as i1 from "../request-manager-services";
 export class ObjectMergerService {
     constructor(configOptions) {
         this.configOptions = configOptions;
+        this.utils = inject(UtilsService);
         if (!this.configOptions)
             this.configOptions = ConfigOptions.adapt();
     }
@@ -27,10 +29,28 @@ export class ObjectMergerService {
         const configForRoot = (this.configOptions?.LocalStorageOptions) ? this.configOptions.LocalStorageOptions : LocalStorageOptions.adapt();
         const configForRootOptions = configForRoot.options || LocalStorageOptions.adapt().options;
         const mergedOptions = SettingOptions.adapt(options);
-        mergedOptions.storage = (options && options.storage === 0) ? configForRootOptions?.storage || 0 : options.storage;
-        mergedOptions.expires = (options && options.expires === 0) ? configForRootOptions?.expires || 0 : options.expires;
-        mergedOptions.expiresIn = (options && options.expiresIn === '') ? configForRootOptions?.expiresIn || '' : options.expiresIn;
-        mergedOptions.encrypted = (options && !options.encrypted) ? configForRootOptions?.encrypted || false : options.encrypted;
+        // storage type
+        mergedOptions.storage = (options && (typeof options.storage !== 'undefined')) ? options.storage : (configForRootOptions?.storage ?? 0);
+        // expires: prefer explicit numeric expires; if not provided, compute from expiresIn string; otherwise use config default
+        // if an explicit, non-zero numeric expires is provided, use it
+        if (options && (typeof options.expires !== 'undefined') && options.expires !== null && Number(options.expires) > 0) {
+            mergedOptions.expires = Number(options.expires);
+        }
+        else if (options && options.expiresIn) {
+            // compute numeric epoch from expiresIn string using UtilsService if available
+            try {
+                mergedOptions.expires = this.utils ? this.utils.expires(options.expiresIn) : 0;
+            }
+            catch {
+                mergedOptions.expires = 0;
+            }
+        }
+        else {
+            mergedOptions.expires = configForRootOptions?.expires ?? 0;
+        }
+        // keep expiresIn string if explicitly provided, otherwise use config default
+        mergedOptions.expiresIn = (options && (typeof options.expiresIn !== 'undefined')) ? options.expiresIn : (configForRootOptions?.expiresIn || '');
+        mergedOptions.encrypted = (options && (typeof options.encrypted !== 'undefined')) ? options.encrypted : (configForRootOptions?.encrypted || false);
         return mergedOptions;
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ObjectMergerService, deps: [{ token: CONFIG_SETTINGS_TOKEN, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
@@ -47,4 +67,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
                 }, {
                     type: Optional
                 }] }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"object-merger.service.js","sourceRoot":"","sources":["../../../../../../projects/http-request-manager/src/lib/services/utils/object-merger.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAErE,OAAO,EAAE,UAAU,EAAE,MAAM,yCAAyC,CAAC;AACrE,OAAO,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAClE,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAEtD,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AACxE,OAAO,EAAE,iBAAiB,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;;;AAKpG,MAAM,OAAO,mBAAmB;IAI9B,YAA+D,aAA6B;QAA7B,kBAAa,GAAb,aAAa,CAAgB;QAF5F,UAAK,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC;QAGzB,IAAI,CAAC,IAAI,CAAC,aAAa;YAAE,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC,KAAK,EAAE,CAAA;IACtE,CAAC;IAEF,YAAY,CAAC,OAAO,GAAG,UAAU,CAAC,KAAK,EAAE;QAEvC,MAAM,aAAa,GAAG,CAAC,IAAI,CAAC,aAAa,EAAE,kBAAkB,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,kBAAkB,CAAC,CAAC,CAAC,iBAAiB,CAAC,KAAK,EAAE,CAAA;QAClI,MAAM,aAAa,GAAG,UAAU,CAAC,KAAK,CAAC,OAAO,CAAC,CAAA;QAE/C,aAAa,CAAC,MAAM,GAAG,CAAC,OAAO,IAAI,OAAO,CAAC,MAAM,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,aAAa,EAAE,MAAM,IAAI,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAA;QAExG,aAAa,CAAC,IAAI,GAAG,CAAE,GAAG,OAAO,CAAC,IAAI,IAAI,EAAE,EAAE,GAAG,aAAa,EAAE,IAAI,IAAI,EAAE,CAAE,CAAA;QAE5E,aAAa,CAAC,OAAO,GAAG,EAAE,GAAG,OAAO,CAAC,OAAO,IAAI,EAAE,EAAE,GAAG,aAAa,EAAE,OAAO,IAAI,EAAE,EAAE,CAAA;QAErF,aAAa,CAAC,KAAK,GAAG,CAAC,OAAO,IAAI,CAAC,OAAO,EAAE,KAAK,EAAE,KAAK,KAAK,CAAC,IAAI,OAAO,EAAE,KAAK,EAAE,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,aAAa,EAAE,KAAK,IAAI,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC;QAEjK,aAAa,CAAC,OAAO,GAAG,CAAC,OAAO,IAAI,OAAO,EAAE,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,aAAa,EAAE,OAAO,IAAI,CAAC,CAAC;QAE5G,aAAa,CAAC,YAAY,GAAG,CAAC,OAAO,IAAI,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,aAAa,EAAE,YAAY,IAAI,KAAK,CAAC;QAE9H,aAAa,CAAC,MAAM,GAAG,CAAC,OAAO,IAAI,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,aAAa,EAAE,MAAM,IAAI,KAAK,CAAC;QAEtG,OAAO,aAAa,CAAC;IAEvB,CAAC;IAED,mBAAmB,CAAC,OAAO,GAAG,cAAc,CAAC,KAAK,EAAE;QAElD,MAAM,aAAa,GAAG,CAAC,IAAI,CAAC,aAAa,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,mBAAmB,CAAC,CAAC,CAAC,mBAAmB,CAAC,KAAK,EAAE,CAAA;QACtI,MAAM,oBAAoB,GAAG,aAAa,CAAC,OAAO,IAAI,mBAAmB,CAAC,KAAK,EAAE,CAAC,OAAO,CAAA;QAEzF,MAAM,aAAa,GAAG,cAAc,CAAC,KAAK,CAAC,OAAO,CAAC,CAAA;QAEnD,eAAe;QACf,aAAa,CAAC,OAAO,GAAG,CAAC,OAAO,IAAI,CAAC,OAAO,OAAO,CAAC,OAAO,KAAK,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,oBAAoB,EAAE,OAAO,IAAI,CAAC,CAAC,CAAA;QAEtI,yHAAyH;QACzH,+DAA+D;QAC/D,IAAI,OAAO,IAAI,CAAC,OAAO,OAAO,CAAC,OAAO,KAAK,WAAW,CAAC,IAAI,OAAO,CAAC,OAAO,KAAK,IAAI,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;YACnH,aAAa,CAAC,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;QAClD,CAAC;aAAM,IAAI,OAAO,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;YACxC,8EAA8E;YAC9E,IAAI,CAAC;gBACH,aAAa,CAAC,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YACjF,CAAC;YAAC,MAAM,CAAC;gBACP,aAAa,CAAC,OAAO,GAAG,CAAC,CAAC;YAC5B,CAAC;QACH,CAAC;aAAM,CAAC;YACN,aAAa,CAAC,OAAO,GAAG,oBAAoB,EAAE,OAAO,IAAI,CAAC,CAAC;QAC7D,CAAC;QAED,6EAA6E;QAC7E,aAAa,CAAC,SAAS,GAAG,CAAC,OAAO,IAAI,CAAC,OAAO,OAAO,CAAC,SAAS,KAAK,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,oBAAoB,EAAE,SAAS,IAAI,EAAE,CAAC,CAAA;QAE/I,aAAa,CAAC,SAAS,GAAG,CAAC,OAAO,IAAI,CAAC,OAAO,OAAO,CAAC,SAAS,KAAK,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,oBAAoB,EAAE,SAAS,IAAI,KAAK,CAAC,CAAA;QAElJ,OAAO,aAAa,CAAC;IAEvB,CAAC;+GA/DU,mBAAmB,kBAIV,qBAAqB;mHAJ9B,mBAAmB,cAFlB,MAAM;;4FAEP,mBAAmB;kBAH/B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB;;0BAKc,MAAM;2BAAC,qBAAqB;;0BAAG,QAAQ","sourcesContent":["import { Inject, Injectable, Optional, inject } from '@angular/core';\n\nimport { ApiRequest } from '../request-manager-state-service/models';\nimport { SettingOptions } from '../local-storage-manager-service';\nimport { UtilsService } from '../utils/utils.service';\n\nimport { CONFIG_SETTINGS_TOKEN } from '../../models/config-token.model';\nimport { ConfigHTTPOptions, ConfigOptions, LocalStorageOptions } from '../request-manager-services';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class ObjectMergerService {\n\n  utils = inject(UtilsService);\n\n  constructor(@Inject(CONFIG_SETTINGS_TOKEN) @Optional() private configOptions?: ConfigOptions) {\n      if (!this.configOptions) this.configOptions = ConfigOptions.adapt()\n   }\n\n  mergeOptions(options = ApiRequest.adapt()) {\n\n    const configForRoot = (this.configOptions?.httpRequestOptions) ? this.configOptions.httpRequestOptions : ConfigHTTPOptions.adapt()\n    const mergedOptions = ApiRequest.adapt(options)\n\n    mergedOptions.server = (options && options.server === '') ? configForRoot?.server || '' : options.server\n\n    mergedOptions.path = [ ...options.path || [], ...configForRoot?.path || [] ]\n\n    mergedOptions.headers = { ...options.headers || {}, ...configForRoot?.headers || {} }\n\n    mergedOptions.retry = (options && (options?.retry?.times !== 0 || options?.retry?.delay !== 3)) ? options.retry : configForRoot?.retry || { times: 0, delay: 3 };\n\n    mergedOptions.polling = (options && options?.polling !== 0) ? options.polling : configForRoot?.polling || 0;\n\n    mergedOptions.displayError = (options && options?.displayError) ? options.displayError : configForRoot?.displayError || false;\n\n    mergedOptions.stream = (options && options?.stream) ? options.stream : configForRoot?.stream || false;\n\n    return mergedOptions;\n\n  }\n\n  mergeStorageOptions(options = SettingOptions.adapt()) {\n\n    const configForRoot = (this.configOptions?.LocalStorageOptions) ? this.configOptions.LocalStorageOptions : LocalStorageOptions.adapt()\n    const configForRootOptions = configForRoot.options || LocalStorageOptions.adapt().options\n\n    const mergedOptions = SettingOptions.adapt(options)\n\n    // storage type\n    mergedOptions.storage = (options && (typeof options.storage !== 'undefined')) ? options.storage : (configForRootOptions?.storage ?? 0)\n\n    // expires: prefer explicit numeric expires; if not provided, compute from expiresIn string; otherwise use config default\n    // if an explicit, non-zero numeric expires is provided, use it\n    if (options && (typeof options.expires !== 'undefined') && options.expires !== null && Number(options.expires) > 0) {\n      mergedOptions.expires = Number(options.expires);\n    } else if (options && options.expiresIn) {\n      // compute numeric epoch from expiresIn string using UtilsService if available\n      try {\n        mergedOptions.expires = this.utils ? this.utils.expires(options.expiresIn) : 0;\n      } catch {\n        mergedOptions.expires = 0;\n      }\n    } else {\n      mergedOptions.expires = configForRootOptions?.expires ?? 0;\n    }\n\n    // keep expiresIn string if explicitly provided, otherwise use config default\n    mergedOptions.expiresIn = (options && (typeof options.expiresIn !== 'undefined')) ? options.expiresIn : (configForRootOptions?.expiresIn || '')\n\n    mergedOptions.encrypted = (options && (typeof options.encrypted !== 'undefined')) ? options.encrypted : (configForRootOptions?.encrypted || false)\n\n    return mergedOptions;\n\n  }\n\n}\n"]}