@o3r/store-sync 12.1.0-prerelease.10 → 12.1.0-prerelease.12

package/esm2022/core/index.mjs

@@ -0,0 +1,4 @@
+export * from './interfaces';
+export * from './storage-sync';
+export * from './storage-sync.helpers';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY29yZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsd0JBQXdCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2ludGVyZmFjZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9zdG9yYWdlLXN5bmMnO1xuZXhwb3J0ICogZnJvbSAnLi9zdG9yYWdlLXN5bmMuaGVscGVycyc7XG4iXX0=

package/esm2022/core/interfaces.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/storage-sync.helpers.mjs

@@ -0,0 +1,22 @@
+import { createAction, props, } from '@ngrx/store';
+/**
+ * Defines if an object is a Serializer
+ * @param obj Object to test
+ * @returns True if the object is a Serializer
+ */
+export const isSerializer = (obj) => !!(obj.serialize || obj.deserialize || obj.reviver || obj.replacer || obj.initialState);
+/**
+ * Label of the action to rehydrate the store
+ */
+export const REHYDRATE_ACTION_LABEL = '[storeSync] rehydrate';
+/**
+ * Action to rehydrate the store
+ */
+export const rehydrateAction = createAction(REHYDRATE_ACTION_LABEL, props());
+/**
+ * Defines if the storage is a non-async storage
+ * @param options The storage config
+ * @returns in case the storage used is a non-async storage
+ */
+export const isLocalStorageConfig = (options) => !options.storage || options.storage instanceof Storage;
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/storage-sync.mjs

@@ -0,0 +1,103 @@
+import { INIT, UPDATE, } from '@ngrx/store';
+import equal from 'fast-deep-equal';
+import { deepFillWithDate, } from '../deep-fill/deep-fill';
+import { syncStorage, } from '../sync-storage';
+import { isLocalStorageConfig, isSerializer, rehydrateAction, } from './storage-sync.helpers';
+/**
+ * Storage synchronizer
+ */
+export class StorageSync {
+    constructor(options, extraOptions) {
+        this.alreadyHydratedStoreSlices = new Set();
+        this.hasHydrated = false;
+        this.storeImage = {};
+        /**
+         * Handle state manipulation in case of store storage sync
+         * Merge strategy is a full merge at init; When a new `store slice` is registered, its initial state is merged with its corresponding storage content
+         * Pass it as mergeReducer callback when calling localStorageSync function from 'ngrx-store-localstorage', in the app
+         * @param state actual state
+         * @param rehydratedState state from storage
+         * @param action Triggered action
+         */
+        this.mergeReducer = (state, rehydratedState, action) => {
+            if (rehydratedState) {
+                if (action.type === INIT) {
+                    state = deepFillWithDate(state, rehydratedState);
+                }
+                if (action.type === UPDATE && Array.isArray(action.features)) {
+                    const notHandledFeatures = action.features.filter((featName) => !this.alreadyHydratedStoreSlices.has(featName));
+                    notHandledFeatures.filter((featName) => !!rehydratedState[featName]).forEach((fName) => {
+                        state[fName] = state[fName] ? deepFillWithDate(state[fName], rehydratedState[fName]) : rehydratedState[fName];
+                        this.alreadyHydratedStoreSlices.add(fName);
+                    });
+                }
+            }
+            return state;
+        };
+        /**
+         * Returns a meta reducer that handles storage sync
+         */
+        this.localStorageSync = () => {
+            const base = (reducer) => syncStorage({
+                ...this.options,
+                rehydrate: false,
+                storage: this.options.storage,
+                syncCondition: () => this.hasHydrated
+            })(reducer);
+            return (reducer) => {
+                if (isLocalStorageConfig(this.options)) {
+                    return syncStorage(this.options)(reducer);
+                }
+                return (state, action) => {
+                    let hydratedState = state;
+                    if (action.type === rehydrateAction.type) {
+                        const hasAlreadyHydrated = this.hasHydrated;
+                        this.hasHydrated = true;
+                        const initialStates = this.options.keys.reduce((acc, key) => {
+                            const storeName = Object.keys(key)[0];
+                            const storeSynchronizer = key[storeName];
+                            if (isSerializer(storeSynchronizer)) {
+                                acc[storeName] = storeSynchronizer.initialState;
+                            }
+                            return acc;
+                        }, {});
+                        let overrides = {};
+                        if (!hasAlreadyHydrated) {
+                            overrides = Object.entries(action.payload).reduce((acc, [storeName, value]) => {
+                                if (!initialStates[storeName] || initialStates[storeName] === state[storeName]) {
+                                    acc[storeName] = value;
+                                }
+                                else if (initialStates[storeName] !== state[storeName]) {
+                                    (this.options.logger || console).error(`Unable to rehydrate store "${storeName}", it has been modified before being hydrated`);
+                                }
+                                return acc;
+                            }, {});
+                        }
+                        if (Object.keys(overrides).length > 0) {
+                            hydratedState = { ...state, ...overrides };
+                        }
+                    }
+                    return base(reducer)(hydratedState, action);
+                };
+            };
+        };
+        this.options = {
+            keys: [],
+            ...(extraOptions?.disableSmartSync
+                ? {}
+                : {
+                    syncKeyCondition: (key, state) => !equal(this.storeImage[key], state[key]),
+                    postProcess: (state) => {
+                        this.options.keys.forEach((key) => {
+                            const keyName = typeof key === 'object' ? Object.keys(key)[0] : key;
+                            this.storeImage[keyName] = state[keyName];
+                        });
+                    }
+                }),
+            ...options,
+            storage: options?.storage,
+            mergeReducer: typeof options?.mergeReducer === 'function' ? options.mergeReducer : this.mergeReducer
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"storage-sync.js","sourceRoot":"","sources":["../../../src/core/storage-sync.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  INIT,\n  UPDATE,\n} from '@ngrx/store';\nimport equal from 'fast-deep-equal';\nimport {\n  deepFillWithDate,\n} from '../deep-fill/deep-fill';\nimport {\n  syncStorage,\n} from '../sync-storage';\nimport type {\n  StorageSyncOptions,\n} from './interfaces';\nimport {\n  StorageSyncConstructorOptions,\n} from './interfaces';\nimport {\n  isLocalStorageConfig,\n  isSerializer,\n  rehydrateAction,\n} from './storage-sync.helpers';\n\n/**\n * Storage synchronizer\n */\nexport class StorageSync {\n  private readonly alreadyHydratedStoreSlices: Set<string> = new Set();\n  private hasHydrated = false;\n  private readonly storeImage: { [key: string]: any } = {};\n\n  public options: StorageSyncOptions;\n\n  constructor(options?: StorageSyncConstructorOptions, extraOptions?: { disableSmartSync: boolean }) {\n    this.options = {\n      keys: [],\n      ...(extraOptions?.disableSmartSync\n        ? {}\n        : {\n          syncKeyCondition: (key, state) => !equal(this.storeImage[key], state[key]),\n          postProcess: (state) => {\n            this.options.keys.forEach((key) => {\n              const keyName: string = typeof key === 'object' ? Object.keys(key)[0] : key;\n              this.storeImage[keyName] = state[keyName];\n            });\n          }\n        }),\n      ...options,\n      storage: options?.storage as unknown as Storage,\n      mergeReducer: typeof options?.mergeReducer === 'function' ? options.mergeReducer : this.mergeReducer\n    };\n  }\n\n  /**\n   * Handle state manipulation in case of store storage sync\n   * Merge strategy is a full merge at init; When a new `store slice` is registered, its initial state is merged with its corresponding storage content\n   * Pass it as mergeReducer callback when calling localStorageSync function from 'ngrx-store-localstorage', in the app\n   * @param state actual state\n   * @param rehydratedState state from storage\n   * @param action Triggered action\n   */\n  public readonly mergeReducer = (state: any, rehydratedState: any, action: any) => {\n    if (rehydratedState) {\n      if (action.type === INIT) {\n        state = deepFillWithDate(state, rehydratedState);\n      }\n      if (action.type === UPDATE && Array.isArray(action.features)) {\n        const notHandledFeatures = action.features.filter((featName: string) => !this.alreadyHydratedStoreSlices.has(featName));\n\n        notHandledFeatures.filter((featName: string) => !!rehydratedState[featName]).forEach((fName: string) => {\n          state[fName] = state[fName] ? deepFillWithDate(state[fName], rehydratedState[fName]) : rehydratedState[fName];\n          this.alreadyHydratedStoreSlices.add(fName);\n        });\n      }\n    }\n    return state;\n  };\n\n  /**\n   * Returns a meta reducer that handles storage sync\n   */\n  public localStorageSync = () => {\n    const base = (reducer: any) => syncStorage({\n      ...this.options,\n      rehydrate: false,\n      storage: this.options.storage as unknown as Storage,\n      syncCondition: () => this.hasHydrated\n    })(reducer);\n\n    return (reducer: any) => {\n      if (isLocalStorageConfig(this.options)) {\n        return syncStorage(this.options)(reducer);\n      }\n\n      return (state: any, action: any) => {\n        let hydratedState = state;\n        if (action.type === rehydrateAction.type) {\n          const hasAlreadyHydrated = this.hasHydrated;\n          this.hasHydrated = true;\n          const initialStates = this.options.keys.reduce((acc: Record<string, any>, key) => {\n            const storeName = Object.keys(key)[0];\n            const storeSynchronizer = (key as any)[storeName];\n            if (isSerializer(storeSynchronizer)) {\n              acc[storeName] = storeSynchronizer.initialState;\n            }\n            return acc;\n          }, {});\n          let overrides = {};\n          if (!hasAlreadyHydrated) {\n            overrides = Object.entries(action.payload).reduce<Record<string, any>>((acc, [storeName, value]) => {\n              if (!initialStates[storeName] || initialStates[storeName] === state[storeName]) {\n                acc[storeName] = value;\n              } else if (initialStates[storeName] !== state[storeName]) {\n                (this.options.logger || console).error(`Unable to rehydrate store \"${storeName}\", it has been modified before being hydrated`);\n              }\n              return acc;\n            }, {});\n          }\n          if (Object.keys(overrides).length > 0) {\n            hydratedState = { ...state, ...overrides };\n          }\n        }\n        return base(reducer)(hydratedState, action);\n      };\n    };\n  };\n}\n"]}

package/esm2022/deep-fill/deep-fill.mjs

@@ -0,0 +1,23 @@
+import { utils, } from '@ama-sdk/core';
+import { deepFill, } from '@o3r/core';
+const mapper = [
+    {
+        condition: (data) => data instanceof utils.DateTime,
+        construct: (data) => new utils.DateTime(data)
+    },
+    {
+        condition: (data) => data instanceof utils.Date,
+        construct: (data) => new utils.Date(data)
+    }
+];
+/**
+ * Deep fill of base object using source
+ * It will do a deep merge of the objects, overriding arrays
+ * All properties not present in source, but present in base, will remain
+ * @param base
+ * @param source
+ */
+export function deepFillWithDate(base, source) {
+    return deepFill(base, source, mapper);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVlcC1maWxsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2RlZXAtZmlsbC9kZWVwLWZpbGwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUNMLEtBQUssR0FDTixNQUFNLGVBQWUsQ0FBQztBQUN2QixPQUFPLEVBQ0wsUUFBUSxHQUVULE1BQU0sV0FBVyxDQUFDO0FBRW5CLE1BQU0sTUFBTSxHQUE2QjtJQUN2QztRQUNFLFNBQVMsRUFBRSxDQUFDLElBQUksRUFBRSxFQUFFLENBQUMsSUFBSSxZQUFZLEtBQUssQ0FBQyxRQUFRO1FBQ25ELFNBQVMsRUFBRSxDQUFDLElBQUksRUFBRSxFQUFFLENBQUMsSUFBSSxLQUFLLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQztLQUM5QztJQUNEO1FBQ0UsU0FBUyxFQUFFLENBQUMsSUFBSSxFQUFFLEVBQUUsQ0FBQyxJQUFJLFlBQVksS0FBSyxDQUFDLElBQUk7UUFDL0MsU0FBUyxFQUFFLENBQUMsSUFBSSxFQUFFLEVBQUUsQ0FBQyxJQUFJLEtBQUssQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDO0tBQzFDO0NBQ0YsQ0FBQztBQUVGOzs7Ozs7R0FNRztBQUNILE1BQU0sVUFBVSxnQkFBZ0IsQ0FBaUMsSUFBTyxFQUFFLE1BQTZCO0lBQ3JHLE9BQU8sUUFBUSxDQUFDLElBQUksRUFBRSxNQUFNLEVBQUUsTUFBTSxDQUFDLENBQUM7QUFDeEMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7XG4gIHV0aWxzLFxufSBmcm9tICdAYW1hLXNkay9jb3JlJztcbmltcG9ydCB7XG4gIGRlZXBGaWxsLFxuICB0eXBlIFByaW1pdGl2ZVJldml2ZXJNYXBwZXIsXG59IGZyb20gJ0BvM3IvY29yZSc7XG5cbmNvbnN0IG1hcHBlcjogUHJpbWl0aXZlUmV2aXZlck1hcHBlcltdID0gW1xuICB7XG4gICAgY29uZGl0aW9uOiAoZGF0YSkgPT4gZGF0YSBpbnN0YW5jZW9mIHV0aWxzLkRhdGVUaW1lLFxuICAgIGNvbnN0cnVjdDogKGRhdGEpID0+IG5ldyB1dGlscy5EYXRlVGltZShkYXRhKVxuICB9LFxuICB7XG4gICAgY29uZGl0aW9uOiAoZGF0YSkgPT4gZGF0YSBpbnN0YW5jZW9mIHV0aWxzLkRhdGUsXG4gICAgY29uc3RydWN0OiAoZGF0YSkgPT4gbmV3IHV0aWxzLkRhdGUoZGF0YSlcbiAgfVxuXTtcblxuLyoqXG4gKiBEZWVwIGZpbGwgb2YgYmFzZSBvYmplY3QgdXNpbmcgc291cmNlXG4gKiBJdCB3aWxsIGRvIGEgZGVlcCBtZXJnZSBvZiB0aGUgb2JqZWN0cywgb3ZlcnJpZGluZyBhcnJheXNcbiAqIEFsbCBwcm9wZXJ0aWVzIG5vdCBwcmVzZW50IGluIHNvdXJjZSwgYnV0IHByZXNlbnQgaW4gYmFzZSwgd2lsbCByZW1haW5cbiAqIEBwYXJhbSBiYXNlXG4gKiBAcGFyYW0gc291cmNlXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBkZWVwRmlsbFdpdGhEYXRlPFQgZXh0ZW5kcyB7IFt4OiBzdHJpbmddOiBhbnkgfT4oYmFzZTogVCwgc291cmNlPzogeyBbeDogc3RyaW5nXTogYW55IH0pOiBUIHtcbiAgcmV0dXJuIGRlZXBGaWxsKGJhc2UsIHNvdXJjZSwgbWFwcGVyKTtcbn1cbiJdfQ==

package/esm2022/o3r-store-sync.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public_api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibzNyLXN0b3JlLXN5bmMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbzNyLXN0b3JlLXN5bmMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWNfYXBpJztcbiJdfQ==

package/esm2022/public_api.mjs

@@ -0,0 +1,3 @@
+export * from './core/index';
+export * from './sync-storage/index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wdWJsaWNfYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsc0JBQXNCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2NvcmUvaW5kZXgnO1xuZXhwb3J0ICogZnJvbSAnLi9zeW5jLXN0b3JhZ2UvaW5kZXgnO1xuIl19

package/esm2022/sync-storage/index.mjs

@@ -0,0 +1,15 @@
+/*
+ * This file is a fork of the package ngrx-store-localstorage (https://github.com/btroncone/ngrx-store-localstorage) - MIT
+ * The following update as been added:
+ *   - properly export dateReviver function
+ *   - add missing comments
+ *   - explicit dependency to @ngrx/store for action names
+ *   - change interface names to prefix with "sync"
+ *   - add logger support
+ *   - fix lint according to eslint rules
+ *   - split code in several files
+ *   - migrate tests to Jest
+ */
+export * from './interfaces';
+export * from './storage-sync';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc3luYy1zdG9yYWdlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7OztHQVdHO0FBRUgsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxnQkFBZ0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBUaGlzIGZpbGUgaXMgYSBmb3JrIG9mIHRoZSBwYWNrYWdlIG5ncngtc3RvcmUtbG9jYWxzdG9yYWdlIChodHRwczovL2dpdGh1Yi5jb20vYnRyb25jb25lL25ncngtc3RvcmUtbG9jYWxzdG9yYWdlKSAtIE1JVFxuICogVGhlIGZvbGxvd2luZyB1cGRhdGUgYXMgYmVlbiBhZGRlZDpcbiAqICAgLSBwcm9wZXJseSBleHBvcnQgZGF0ZVJldml2ZXIgZnVuY3Rpb25cbiAqICAgLSBhZGQgbWlzc2luZyBjb21tZW50c1xuICogICAtIGV4cGxpY2l0IGRlcGVuZGVuY3kgdG8gQG5ncngvc3RvcmUgZm9yIGFjdGlvbiBuYW1lc1xuICogICAtIGNoYW5nZSBpbnRlcmZhY2UgbmFtZXMgdG8gcHJlZml4IHdpdGggXCJzeW5jXCJcbiAqICAgLSBhZGQgbG9nZ2VyIHN1cHBvcnRcbiAqICAgLSBmaXggbGludCBhY2NvcmRpbmcgdG8gZXNsaW50IHJ1bGVzXG4gKiAgIC0gc3BsaXQgY29kZSBpbiBzZXZlcmFsIGZpbGVzXG4gKiAgIC0gbWlncmF0ZSB0ZXN0cyB0byBKZXN0XG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9pbnRlcmZhY2VzJztcbmV4cG9ydCAqIGZyb20gJy4vc3RvcmFnZS1zeW5jJztcbiJdfQ==

package/esm2022/sync-storage/interfaces.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zeW5jLXN0b3JhZ2UvaW50ZXJmYWNlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUge1xuICBMb2dnZXIsXG59IGZyb20gJ0BvM3IvY29yZSc7XG5cbi8qKlxuICogT3B0aW9ucyB0byBwcm92aWRlIHRvIHRoZSBzeW5jaHJvbm91cyBzdG9yZSBzeW5jaHJvbml6YXRpb24gbWVjaGFuaXNtXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgU3luY1N0b3JhZ2VTeW5jT3B0aW9ucyB7XG4gIC8qKiBDYWxsYmFjayB0byBkZWZpbmUgdGhlIHNlcmlhbGl6YXRpb24gc3RyYXRlZ3kgb2YgdGhlIHN0b3JlICovXG4gIHNlcmlhbGl6ZT86IChzdGF0ZTogYW55KSA9PiBhbnk7XG4gIC8qKiBDYWxsYmFjayB0byBkZWZpbmUgdGhlIGRlc2VyaWFsaXphdGlvbiBzdHJhdGVneSBvZiB0aGUgc3RvcmUgKi9cbiAgZGVzZXJpYWxpemU/OiAoc3RhdGU6IGFueSkgPT4gYW55O1xuICAvKiogQ2FsbGJhY2sgdG8gZGVmaW5lIHRoZSByZXZpdmluZyBzdHJhdGVneSBvZiB0aGUgc3RvcmUgKi9cbiAgcmV2aXZlcj86IChrZXk6IHN0cmluZywgdmFsdWU6IGFueSkgPT4gYW55O1xuICAvKiogcmVwbGFjZXIgY2FsbGJhY2sgZnVuY3Rpb24gcHJvdmlkZWQgdG8gdGhlIHBhcnNlciAqL1xuICByZXBsYWNlcj86ICgoa2V5OiBzdHJpbmcsIHZhbHVlOiBhbnkpID0+IGFueSkgfCBzdHJpbmdbXTtcbiAgLyoqIEZpbHRlciB0byBhcHBseSB0byB0aGUgc3RvcmUgZmllbGRzICovXG4gIGZpbHRlcj86IHN0cmluZ1tdO1xuICAvKiogU3BhY2luZyBmb3Igc2VyaWFsaXplciAqL1xuICBzcGFjZT86IHN0cmluZyB8IG51bWJlcjtcbiAgLyoqIERlZmluZXMgd2hldGhlciB0aGUgc3RvcmUgaXMgbG9hZGVkIGFzIGZvckZlYXR1cmUgKi9cbiAgc3luY0ZvckZlYXR1cmU/OiBib29sZWFuO1xufVxuXG4vKipcbiAqIEludGVyZmFjZSBvZiB0aGUgY29uZmlndXJhdGlvbnMgZm9yIGEgc3RvcmVcbiAqL1xuZXhwb3J0IGludGVyZmFjZSBTdG9yYWdlS2V5Q29uZmlndXJhdGlvbiB7XG4gIFtrZXk6IHN0cmluZ106IHN0cmluZ1tdIHwgbnVtYmVyW10gfCBTdG9yYWdlS2V5Q29uZmlndXJhdGlvbltdIHwgU3luY1N0b3JhZ2VTeW5jT3B0aW9ucyB8ICgoa2V5OiBzdHJpbmcsIHZhbHVlOiBhbnkpID0+IGFueSk7XG59XG5cbi8qKlxuICogRGVmaW5pdGlvbiBvZiBhIHN0b3JlIHRvIHRvIHN5bmNocm9uaXplXG4gKi9cbmV4cG9ydCB0eXBlIFN0b3JhZ2VLZXlzID0gKFN0b3JhZ2VLZXlDb25maWd1cmF0aW9uIHwgU3luY1N0b3JhZ2VTeW5jT3B0aW9ucyB8IHN0cmluZylbXTtcblxuLyoqXG4gKiBDb25maWd1cmF0aW9uIHRvIGRlZmluZSB0aGUgd2F5IHRoZSBzdG9yZXMgc2hvdWxkIGJlIHN5bmNocm9uaXplIHRvIHRoZSBzdG9yYWdlXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgU3luY1N0b3JhZ2VDb25maWcge1xuICAvKiogTWFwIG9mIHRoZSBzdG9yZSB0byBzeW5jaHJvbml6ZSAqL1xuICBrZXlzOiBTdG9yYWdlS2V5cztcbiAgLyoqIFNob3VsZCB0aGUgc3RvcmVzIGJlIGluaXRpYWxseSByZWh5ZHJhdGVkICovXG4gIHJlaHlkcmF0ZT86IGJvb2xlYW47XG4gIC8qKiBTdG9yYWdlIHJlZmVyZW5jZSAqL1xuICBzdG9yYWdlPzogU3RvcmFnZTtcbiAgLyoqIFNob3VsZCBiZSByZW1vdmVkIGZyb20gc3RvcmFnZSBpZiB1bmRlZmluZWQgKi9cbiAgcmVtb3ZlT25VbmRlZmluZWQ/OiBib29sZWFuO1xuICAvKiogU2hvdWxkIGFwcGx5IHJlc3RvcmUgZGF0ZSB0byB0aGUgcmVzdG9yZWQgc3RvcmVzICovXG4gIHJlc3RvcmVEYXRlcz86IGJvb2xlYW47XG4gIC8qKiBDYWxsYmFjayB0byBkZWZpbmUgdGhlIHNlcmlhbGl6YXRpb24gc3RyYXRlZ3kgZm9yIHRoZSBzdG9yZSBrZXlzICovXG4gIHN0b3JhZ2VLZXlTZXJpYWxpemVyPzogKGtleTogc3RyaW5nKSA9PiBzdHJpbmc7XG4gIC8qKiBDYWxsYmFjayB0byBkZWZpbmUgdGhlIGNvbmRpdGlvbiB0byB0aGUgc3luY2hyb25pemF0aW9uICovXG4gIHN5bmNDb25kaXRpb24/OiAoc3RhdGU6IGFueSkgPT4gYW55O1xuICAvKiogQ2FsbGJhY2sgdG8gZGVmaW5lIHRoZSBjb25kaXRpb24gdG8gdGhlIGtleSBzeW5jaHJvbml6YXRpb24gKi9cbiAgc3luY0tleUNvbmRpdGlvbj86IChrZXk6IHN0cmluZywgc3RhdGU6IGFueSkgPT4gYm9vbGVhbjtcbiAgLyoqIGNoZWNrIHRoZSBhdmFpbGFiaWxpdHkgb2YgdGhlIHN0b3JhZ2UgKi9cbiAgY2hlY2tTdG9yYWdlQXZhaWxhYmlsaXR5PzogYm9vbGVhbjtcbiAgLyoqIE1lcmdlIHJlZHVjZXIgdG8gdXNlIHRvIGRlc2VyaWFsaXplIHRoZSBzdG9yZSAqL1xuICBtZXJnZVJlZHVjZXI/OiAoc3RhdGU6IGFueSwgcmVoeWRyYXRlZFN0YXRlOiBhbnksIGFjdGlvbjogYW55KSA9PiBhbnk7XG4gIC8qKiBMb2dnZXIgdG8gcmVwb3J0IG1lc3NhZ2VzICovXG4gIGxvZ2dlcj86IExvZ2dlcjtcbiAgLyoqIFBvc3QgcHJvY2VzcyBhZnRlciBzeW5jIHN0b3JhZ2UgZXhlY3V0aW9uICovXG4gIHBvc3RQcm9jZXNzPzogKHN0YXRlOiBhbnkpID0+IHZvaWQ7XG59XG4iXX0=

package/esm2022/sync-storage/storage-sync.mjs

@@ -0,0 +1,296 @@
+import { INIT, UPDATE, } from '@ngrx/store';
+import { deepFill, } from '@o3r/core';
+/**
+ * Reviver the date from a JSON field if the string is matching iso format. Return the same value otherwise
+ * @param _key JSON item key name
+ * @param value JSON item value
+ */
+export const dateReviver = (_key, value) => {
+    if (typeof value === 'string' && /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z/.test(value)) {
+        return new Date(value);
+    }
+    return value;
+};
+/**
+ * Dummy reviver returning the value of the field as it is
+ * @param _key JSON item key name
+ * @param value JSON item value
+ */
+const dummyReviver = (_key, value) => value;
+/**
+ * Determine if the code is run in a browser
+ */
+const checkIsBrowserEnv = () => {
+    return typeof window !== 'undefined';
+};
+/**
+ * Validate the keys structure of the registered stores
+ * @param keys map of store to synchronize
+ */
+const validateStateKeys = (keys) => {
+    return keys.map((key) => {
+        let attr = key;
+        if (typeof key === 'object') {
+            attr = Object.keys(key)[0];
+        }
+        if (typeof attr !== 'string') {
+            throw new TypeError('localStorageSync Unknown Parameter Type: ' + `Expected type of string, got ${typeof attr}`);
+        }
+        return key;
+    });
+};
+/**
+ * Rehydrate the state of the whole application store
+ * @param keys Keys of the store to rehydrate
+ * @param storage storage when getting the data from
+ * @param storageKeySerializer storage key transform function
+ * @param restoreDates determine if the date need to be restored
+ * @param logger
+ */
+export const rehydrateApplicationState = (keys, storage, storageKeySerializer, restoreDates, logger = console) => {
+    return keys.reduce((acc, curr) => {
+        let key = curr;
+        let reviver = restoreDates ? dateReviver : dummyReviver;
+        let deserialize;
+        let decrypt;
+        let syncForFeature = false;
+        if (typeof key === 'object') {
+            key = Object.keys(key)[0];
+            syncForFeature = !!curr?.[key]?.syncForFeature;
+            // use the custom reviver function
+            if (typeof curr[key] === 'function') {
+                reviver = curr[key];
+            }
+            else {
+                // use custom reviver function if available
+                if (curr[key].reviver) {
+                    reviver = curr[key].reviver;
+                }
+                // use custom serialize function if available
+                if (curr[key].deserialize) {
+                    deserialize = curr[key].deserialize;
+                }
+            }
+            // Ensure that encrypt and decrypt functions are both present
+            if (curr[key].encrypt && curr[key].decrypt) {
+                if (typeof curr[key].encrypt === 'function' && typeof curr[key].decrypt === 'function') {
+                    decrypt = curr[key].decrypt;
+                }
+                else {
+                    logger.error(`Either encrypt or decrypt is not a function on '${curr[key]}' key object.`);
+                }
+            }
+            else if (curr[key].encrypt || curr[key].decrypt) {
+                // Let know that one of the encryption functions is not provided
+                logger.error(`Either encrypt or decrypt function is not present on '${curr[key]}' key object.`);
+            }
+        }
+        if (storage !== undefined) {
+            let stateSlice = storage.getItem(storageKeySerializer(key));
+            if (stateSlice) {
+                // Use provided decrypt function
+                if (decrypt) {
+                    stateSlice = decrypt(stateSlice);
+                }
+                const isObjectRegex = new RegExp('{|\\[');
+                let raw = stateSlice;
+                if (stateSlice === 'null' || stateSlice === 'true' || stateSlice === 'false' || isObjectRegex.test(stateSlice.charAt(0))) {
+                    raw = JSON.parse(stateSlice, reviver);
+                }
+                const rehydratedState = deserialize ? deserialize(raw) : raw;
+                return syncForFeature
+                    ? rehydratedState
+                    : Object.assign({}, acc, {
+                        [key]: rehydratedState
+                    });
+            }
+        }
+        return acc;
+    }, {});
+};
+// Recursively traverse all properties of the existing slice as defined by the `filter` argument,
+// and output the new object with extraneous properties removed.
+function createStateSlice(existingSlice, filter) {
+    return filter.reduce((memo, attr) => {
+        if (typeof attr === 'string' || typeof attr === 'number') {
+            const value = existingSlice?.[attr];
+            if (value !== undefined) {
+                memo[attr] = value;
+            }
+        }
+        else {
+            for (const key in attr) {
+                if (Object.prototype.hasOwnProperty.call(attr, key)) {
+                    const element = attr[key];
+                    memo[key] = createStateSlice(existingSlice[key], element);
+                }
+            }
+        }
+        return memo;
+    }, {});
+}
+/**
+ * Update the state of the store after reviving from storage
+ * Note: this function is mainly use for internal process of store synchronization
+ * @param state store state
+ * @param keys key of the store
+ * @param storage storage to use for the synchronization
+ * @param storageKeySerializer callback to serialize the store key
+ * @param removeOnUndefined Define if the store should be clean in the storage if undefined
+ * @param syncCondition callback to define if the synchronization should be process
+ * @param logger Logger to report messages
+ */
+export const syncStateUpdate = (state, keys, storage, storageKeySerializer, removeOnUndefined = false, syncCondition, logger = console) => {
+    if (syncCondition) {
+        try {
+            if (syncCondition(state) !== true) {
+                return;
+            }
+        }
+        catch (e) {
+            // Treat TypeError as do not sync
+            if (e instanceof TypeError) {
+                return;
+            }
+            throw e;
+        }
+    }
+    keys.forEach((key) => {
+        let stateSlice = state?.[key];
+        let replacer;
+        let space;
+        let encrypt;
+        let syncForFeature = false;
+        if (typeof key === 'object') {
+            const name = Object.keys(key)[0];
+            syncForFeature = !!key?.[name]?.syncForFeature;
+            stateSlice = syncForFeature ? state : state?.[name];
+            if (typeof stateSlice !== 'undefined' && key[name]) {
+                // use serialize function if specified.
+                if (key[name].serialize) {
+                    stateSlice = key[name].serialize(stateSlice);
+                }
+                else {
+                    // if serialize function is not specified filter on fields if an array has been provided.
+                    let filter;
+                    if (key[name].reduce) {
+                        filter = key[name];
+                    }
+                    else if (key[name].filter) {
+                        filter = key[name].filter;
+                    }
+                    if (filter) {
+                        stateSlice = createStateSlice(stateSlice, filter);
+                    }
+                    // Check if encrypt and decrypt are present, also checked at this#rehydrateApplicationState()
+                    if (key[name].encrypt && key[name].decrypt) {
+                        if (typeof key[name].encrypt === 'function') {
+                            encrypt = key[name].encrypt;
+                        }
+                    }
+                    else if (key[name].encrypt || key[name].decrypt) {
+                        // If one of those is not present, then let know that one is missing
+                        logger.error(`Either encrypt or decrypt function is not present on '${key[name]}' key object.`);
+                    }
+                }
+                /*
+                  Replacer and space arguments to pass to JSON.stringify.
+                  If these fields don't exist, undefined will be passed.
+                */
+                replacer = key[name].replacer;
+                space = key[name].space;
+            }
+            key = name;
+        }
+        else if (typeof key === 'string') {
+            stateSlice = syncForFeature ? state : state?.[key];
+        }
+        if (typeof stateSlice !== 'undefined' && storage !== undefined) {
+            try {
+                if (encrypt) {
+                    // ensure that a string message is passed
+                    stateSlice = encrypt(typeof stateSlice === 'string' ? stateSlice : JSON.stringify(stateSlice, replacer, space));
+                }
+                storage.setItem(storageKeySerializer(key), typeof stateSlice === 'string' ? stateSlice : JSON.stringify(stateSlice, replacer, space));
+            }
+            catch (e) {
+                logger.warn('Unable to save state to localStorage:', e);
+            }
+        }
+        else if (typeof stateSlice === 'undefined' && removeOnUndefined && storage !== undefined) {
+            try {
+                storage.removeItem(storageKeySerializer(key));
+            }
+            catch (e) {
+                logger.warn(`Exception on removing/cleaning undefined '${key}' state`, e);
+            }
+        }
+    });
+};
+const defaultMergeReducer = (state, rehydratedState, action) => {
+    if ((action.type === INIT || action.type === UPDATE) && rehydratedState) {
+        const allKeys = Array.from(new Set([...Object.keys(state), ...Object.keys(rehydratedState)]));
+        state = Object.fromEntries(allKeys.map((key) => {
+            // No need to create new object reference if no merge is actually needed
+            if (!rehydratedState[key]) {
+                return [key, state[key]];
+            }
+            else if (state[key]) {
+                return [key, deepFill(state[key], rehydratedState[key])];
+            }
+            else {
+                return [key, rehydratedState[key]];
+            }
+        }));
+    }
+    return state;
+};
+/**
+ * Local and Session storage synchronization helper
+ * @param config
+ */
+export const syncStorage = (config) => (reducer) => {
+    if ((config.storage === undefined && !config.checkStorageAvailability)
+        || (config.checkStorageAvailability && checkIsBrowserEnv())) {
+        config.storage = localStorage || window.localStorage;
+    }
+    if (config.storageKeySerializer === undefined) {
+        config.storageKeySerializer = (key) => key;
+    }
+    if (config.restoreDates === undefined) {
+        config.restoreDates = true;
+    }
+    // Use default merge reducer.
+    let mergeReducer = config.mergeReducer;
+    if (mergeReducer === undefined || typeof mergeReducer !== 'function') {
+        mergeReducer = defaultMergeReducer;
+    }
+    const logger = config.logger || console;
+    const stateKeys = validateStateKeys(config.keys);
+    const rehydratedState = config.rehydrate
+        ? rehydrateApplicationState(stateKeys, config.storage, config.storageKeySerializer, config.restoreDates, logger)
+        : undefined;
+    return (state, action) => {
+        let nextState;
+        // If state arrives undefined, we need to let it through the supplied reducer
+        // in order to get a complete state as defined by user
+        nextState = action.type === INIT && !state ? reducer(state, action) : { ...state };
+        // Merge the store state with the rehydrated state using
+        // either a user-defined reducer or the default.
+        nextState = mergeReducer(nextState, rehydratedState, action);
+        nextState = reducer(nextState, action);
+        if (action.type !== INIT) {
+            syncStateUpdate(nextState, (typeof config.syncKeyCondition === 'function')
+                ? stateKeys.filter((key) => {
+                    const keyName = typeof key === 'object' ? Object.keys(key)[0] : key;
+                    return config.syncKeyCondition(keyName, nextState);
+                })
+                : stateKeys, config.storage, config.storageKeySerializer, config.removeOnUndefined, config.syncCondition, logger);
+        }
+        if (config.postProcess) {
+            config.postProcess(nextState);
+        }
+        return nextState;
+    };
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"storage-sync.js","sourceRoot":"","sources":["../../../src/sync-storage/storage-sync.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  INIT,\n  UPDATE,\n} from '@ngrx/store';\nimport {\n  deepFill,\n} from '@o3r/core';\nimport type {\n  Logger,\n} from '@o3r/core';\nimport type {\n  StorageKeyConfiguration,\n  StorageKeys,\n  SyncStorageConfig,\n  SyncStorageSyncOptions,\n} from './interfaces';\n\n/**\n * Reviver the date from a JSON field if the string is matching iso format. Return the same value otherwise\n * @param _key JSON item key name\n * @param value JSON item value\n */\nexport const dateReviver = (_key: string, value: any) => {\n  if (typeof value === 'string' && /\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}.\\d{3}Z/.test(value)) {\n    return new Date(value);\n  }\n  return value;\n};\n\n/**\n * Dummy reviver returning the value of the field as it is\n * @param _key JSON item key name\n * @param value JSON item value\n */\nconst dummyReviver = (_key: string, value: any) => value;\n\n/**\n * Determine if the code is run in a browser\n */\nconst checkIsBrowserEnv = () => {\n  return typeof window !== 'undefined';\n};\n\n/**\n * Validate the keys structure of the registered stores\n * @param keys map of store to synchronize\n */\nconst validateStateKeys = (keys: StorageKeys) => {\n  return (keys as any[]).map((key) => {\n    let attr = key;\n\n    if (typeof key === 'object') {\n      attr = Object.keys(key)[0];\n    }\n\n    if (typeof attr !== 'string') {\n      throw new TypeError(\n        'localStorageSync Unknown Parameter Type: ' + `Expected type of string, got ${typeof attr}`\n      );\n    }\n    return key;\n  });\n};\n\n/**\n * Rehydrate the state of the whole application store\n * @param keys Keys of the store to rehydrate\n * @param storage storage when getting the data from\n * @param storageKeySerializer storage key transform function\n * @param restoreDates determine if the date need to be restored\n * @param logger\n */\nexport const rehydrateApplicationState = (\n  keys: StorageKeys,\n  storage: Storage | undefined,\n  storageKeySerializer: (key: string) => string,\n  restoreDates: boolean,\n  logger: Logger = console\n) => {\n  return (keys as any[]).reduce((acc, curr) => {\n    let key = curr;\n    let reviver = restoreDates ? dateReviver : dummyReviver;\n    let deserialize: ((arg0: string) => any) | undefined;\n    let decrypt: ((arg0: string) => string) | undefined;\n    let syncForFeature = false;\n\n    if (typeof key === 'object') {\n      key = Object.keys(key)[0];\n      syncForFeature = !!(curr?.[key] as SyncStorageSyncOptions)?.syncForFeature;\n\n      // use the custom reviver function\n      if (typeof curr[key] === 'function') {\n        reviver = curr[key];\n      } else {\n        // use custom reviver function if available\n        if (curr[key].reviver) {\n          reviver = curr[key].reviver;\n        }\n        // use custom serialize function if available\n        if (curr[key].deserialize) {\n          deserialize = curr[key].deserialize;\n        }\n      }\n\n      // Ensure that encrypt and decrypt functions are both present\n      if (curr[key].encrypt && curr[key].decrypt) {\n        if (typeof curr[key].encrypt === 'function' && typeof curr[key].decrypt === 'function') {\n          decrypt = curr[key].decrypt;\n        } else {\n          logger.error(`Either encrypt or decrypt is not a function on '${curr[key] as string}' key object.`);\n        }\n      } else if (curr[key].encrypt || curr[key].decrypt) {\n        // Let know that one of the encryption functions is not provided\n        logger.error(`Either encrypt or decrypt function is not present on '${curr[key] as string}' key object.`);\n      }\n    }\n    if (storage !== undefined) {\n      let stateSlice = storage.getItem(storageKeySerializer(key));\n      if (stateSlice) {\n        // Use provided decrypt function\n        if (decrypt) {\n          stateSlice = decrypt(stateSlice);\n        }\n\n        const isObjectRegex = new RegExp('{|\\\\[');\n        let raw = stateSlice;\n\n        if (stateSlice === 'null' || stateSlice === 'true' || stateSlice === 'false' || isObjectRegex.test(stateSlice.charAt(0))) {\n          raw = JSON.parse(stateSlice, reviver);\n        }\n\n        const rehydratedState = deserialize ? deserialize(raw) : raw;\n\n        return syncForFeature\n          ? rehydratedState\n          : Object.assign({}, acc, {\n            [key]: rehydratedState\n          });\n      }\n    }\n    return acc;\n  }, {});\n};\n\n// Recursively traverse all properties of the existing slice as defined by the `filter` argument,\n// and output the new object with extraneous properties removed.\nfunction createStateSlice(existingSlice: any, filter: (string | number | StorageKeyConfiguration | SyncStorageSyncOptions)[]) {\n  return filter.reduce(\n    (memo: { [x: string]: any;[x: number]: any }, attr: string | number | StorageKeyConfiguration | SyncStorageSyncOptions) => {\n      if (typeof attr === 'string' || typeof attr === 'number') {\n        const value = existingSlice?.[attr];\n        if (value !== undefined) {\n          memo[attr] = value;\n        }\n      } else {\n        for (const key in attr) {\n          if (Object.prototype.hasOwnProperty.call(attr, key)) {\n            const element: any = attr[key as keyof typeof attr];\n            memo[key] = createStateSlice(existingSlice[key], element);\n          }\n        }\n      }\n      return memo;\n    },\n    {}\n  );\n}\n\n/**\n * Update the state of the store after reviving from storage\n * Note: this function is mainly use for internal process of store synchronization\n * @param state store state\n * @param keys key of the store\n * @param storage storage to use for the synchronization\n * @param storageKeySerializer callback to serialize the store key\n * @param removeOnUndefined Define if the store should be clean in the storage if undefined\n * @param syncCondition callback to define if the synchronization should be process\n * @param logger Logger to report messages\n */\nexport const syncStateUpdate = (\n  state: any,\n  keys: StorageKeys,\n  storage: Storage | undefined,\n  storageKeySerializer: (key: string | number) => string,\n  removeOnUndefined = false,\n  syncCondition?: (state: any) => any,\n  logger: Logger = console\n) => {\n  if (syncCondition) {\n    try {\n      if (syncCondition(state) !== true) {\n        return;\n      }\n    } catch (e) {\n      // Treat TypeError as do not sync\n      if (e instanceof TypeError) {\n        return;\n      }\n      throw e;\n    }\n  }\n\n  keys.forEach((key: string | StorageKeyConfiguration | SyncStorageSyncOptions | ((key: string, value: any) => any)): void => {\n    let stateSlice = state?.[key as string];\n    let replacer;\n    let space: string | number | undefined;\n    let encrypt;\n    let syncForFeature = false;\n\n    if (typeof key === 'object') {\n      const name = (Object.keys(key) as (keyof typeof key)[])[0];\n      syncForFeature = !!(key?.[name] as SyncStorageSyncOptions)?.syncForFeature;\n      stateSlice = syncForFeature ? state : state?.[name];\n\n      if (typeof stateSlice !== 'undefined' && key[name]) {\n        // use serialize function if specified.\n        if ((key[name] as any).serialize) {\n          stateSlice = (key[name] as SyncStorageSyncOptions).serialize!(stateSlice);\n        } else {\n          // if serialize function is not specified filter on fields if an array has been provided.\n          let filter: StorageKeyConfiguration[] | undefined;\n          if ((key[name] as any).reduce) {\n            filter = key[name] as StorageKeyConfiguration[];\n          } else if ((key[name] as any).filter) {\n            filter = (key[name] as any).filter as StorageKeyConfiguration[];\n          }\n          if (filter) {\n            stateSlice = createStateSlice(stateSlice, filter);\n          }\n\n          // Check if encrypt and decrypt are present, also checked at this#rehydrateApplicationState()\n          if ((key[name] as any).encrypt && (key[name] as any).decrypt) {\n            if (typeof (key[name] as any).encrypt === 'function') {\n              encrypt = (key[name] as any).encrypt;\n            }\n          } else if ((key[name] as any).encrypt || (key[name] as any).decrypt) {\n            // If one of those is not present, then let know that one is missing\n            logger.error(\n              `Either encrypt or decrypt function is not present on '${key[name] as string}' key object.`\n            );\n          }\n        }\n\n        /*\n          Replacer and space arguments to pass to JSON.stringify.\n          If these fields don't exist, undefined will be passed.\n        */\n        replacer = (key[name] as any).replacer;\n        space = (key[name] as any).space;\n      }\n\n      key = name;\n    } else if (typeof key === 'string') {\n      stateSlice = syncForFeature ? state : state?.[key];\n    }\n\n    if (typeof stateSlice !== 'undefined' && storage !== undefined) {\n      try {\n        if (encrypt) {\n          // ensure that a string message is passed\n          stateSlice = encrypt(\n            typeof stateSlice === 'string' ? stateSlice : JSON.stringify(stateSlice, replacer, space)\n          );\n        }\n        storage.setItem(\n          storageKeySerializer(key as string),\n          typeof stateSlice === 'string' ? stateSlice : JSON.stringify(stateSlice, replacer, space)\n        );\n      } catch (e) {\n        logger.warn('Unable to save state to localStorage:', e);\n      }\n    } else if (typeof stateSlice === 'undefined' && removeOnUndefined && storage !== undefined) {\n      try {\n        storage.removeItem(storageKeySerializer(key as string));\n      } catch (e) {\n        logger.warn(`Exception on removing/cleaning undefined '${key as string}' state`, e);\n      }\n    }\n  });\n};\n\nconst defaultMergeReducer = (state: any, rehydratedState: any, action: any) => {\n  if ((action.type === INIT || action.type === UPDATE) && rehydratedState) {\n    const allKeys = Array.from(new Set([...Object.keys(state), ...Object.keys(rehydratedState)]));\n    state = Object.fromEntries(allKeys.map((key) => {\n      // No need to create new object reference if no merge is actually needed\n      if (!rehydratedState[key]) {\n        return [key, state[key]];\n      } else if (state[key]) {\n        return [key, deepFill(state[key], rehydratedState[key])];\n      } else {\n        return [key, rehydratedState[key]];\n      }\n    }));\n  }\n\n  return state;\n};\n\n/**\n * Local and Session storage synchronization helper\n * @param config\n */\nexport const syncStorage = (config: SyncStorageConfig) => (reducer: any) => {\n  if (\n    (config.storage === undefined && !config.checkStorageAvailability)\n    || (config.checkStorageAvailability && checkIsBrowserEnv())\n  ) {\n    config.storage = localStorage || window.localStorage;\n  }\n\n  if (config.storageKeySerializer === undefined) {\n    config.storageKeySerializer = (key) => key;\n  }\n\n  if (config.restoreDates === undefined) {\n    config.restoreDates = true;\n  }\n\n  // Use default merge reducer.\n  let mergeReducer = config.mergeReducer;\n\n  if (mergeReducer === undefined || typeof mergeReducer !== 'function') {\n    mergeReducer = defaultMergeReducer;\n  }\n\n  const logger = config.logger || console;\n\n  const stateKeys = validateStateKeys(config.keys);\n  const rehydratedState = config.rehydrate\n    ? rehydrateApplicationState(stateKeys, config.storage, config.storageKeySerializer, config.restoreDates, logger)\n    : undefined;\n\n  return (state: any, action: any) => {\n    let nextState: any;\n\n    // If state arrives undefined, we need to let it through the supplied reducer\n    // in order to get a complete state as defined by user\n    nextState = action.type === INIT && !state ? reducer(state, action) : { ...state };\n\n    // Merge the store state with the rehydrated state using\n    // either a user-defined reducer or the default.\n    nextState = mergeReducer(nextState, rehydratedState, action);\n\n    nextState = reducer(nextState, action);\n\n    if (action.type !== INIT) {\n      syncStateUpdate(\n        nextState,\n        (typeof config.syncKeyCondition === 'function')\n          ? stateKeys.filter((key) => {\n            const keyName = typeof key === 'object' ? Object.keys(key)[0] : key;\n            return config.syncKeyCondition!(keyName, nextState);\n          })\n          : stateKeys,\n        config.storage,\n        config.storageKeySerializer as (key: string | number) => string,\n        config.removeOnUndefined,\n        config.syncCondition,\n        logger\n      );\n    }\n    if (config.postProcess) {\n      config.postProcess(nextState);\n    }\n    return nextState;\n  };\n};\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@o3r/store-sync",
-  "version": "12.1.0-prerelease.10",
+  "version": "12.1.0-prerelease.12",
   "publishConfig": {
     "access": "public"
   },
@@ -13,14 +13,14 @@
     "otter-module"
   ],
   "peerDependencies": {
-    "@ama-sdk/core": "^12.1.0-prerelease.10",
+    "@ama-sdk/core": "^12.1.0-prerelease.12",
     "@angular-devkit/core": "^19.0.0",
     "@angular-devkit/schematics": "^19.0.0",
     "@ngrx/entity": "^19.0.0",
     "@ngrx/store": "^19.0.0",
-    "@o3r/core": "^12.1.0-prerelease.10",
-    "@o3r/logger": "^12.1.0-prerelease.10",
-    "@o3r/schematics": "^12.1.0-prerelease.10",
+    "@o3r/core": "^12.1.0-prerelease.12",
+    "@o3r/logger": "^12.1.0-prerelease.12",
+    "@o3r/schematics": "^12.1.0-prerelease.12",
     "@schematics/angular": "^19.0.0",
     "fast-deep-equal": "^3.1.3",
     "rxjs": "^7.8.1",

package/schematics/ng-add/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../schematics/ng-add/index.ts"],"names":[],"mappings":"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"}

package/schematics/ng-add/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../../schematics/ng-add/schema.ts"],"names":[],"mappings":""}