@spartacus/core
Version:
Spartacus - the core framework
74 lines • 12.3 kB
JavaScript
import { Injectable } from '@angular/core';
import { of, Subscription } from 'rxjs';
import { map, tap, withLatestFrom } from 'rxjs/operators';
import { StorageSyncType } from '../../state/config/state-config';
import { getStorage, persistToStorage, readFromStorage, } from '../utils/browser-storage';
import * as i0 from "@angular/core";
import * as i1 from "../../window/window-ref";
export class StatePersistenceService {
constructor(winRef) {
this.winRef = winRef;
}
/**
* Helper to synchronize state to more persistent storage (localStorage, sessionStorage).
* It is context aware, so you can keep different state for te same feature based on specified context.
*
* Eg. cart is valid only under the same base site. So you want to synchronize cart only with the same base site.
* Usage for that case: `syncWithStorage({ key: 'cart', state$: activeCartSelector$, context$: this.siteContextParamsService.getValues([BASE_SITE_CONTEXT_ID]), onRead: (state) => setCorrectStateInStore(state) })`.
* Active cart for the `electronics` base site will be stored under `spartacus⚿electronics⚿cart` and for apparel under `spartacus⚿apparel⚿cart`.
*
* On each context change onRead function will be executed with state from storage provided as a parameter.
*
* Omitting context$ will trigger onRead only once at initialization.
*
* @param key Key to use in storage for the synchronized state. Should be unique for each feature.
* @param state$ State to be saved and later restored.
* @param context$ Context for state
* @param storageType Storage type to be used to persist state
* @param onRead Function to be executed on each storage read after context change
*
* @returns Subscriptions for reading/writing in storage on context/state change
*/
syncWithStorage({ key, state$, context$ = of(''), storageType = StorageSyncType.LOCAL_STORAGE, onRead = () => { }, }) {
const storage = getStorage(storageType, this.winRef);
const subscriptions = new Subscription();
// Do not change order of subscription! Read should happen before write on context change.
subscriptions.add(context$
.pipe(map((context) => {
return readFromStorage(storage, this.generateKeyWithContext(context, key));
}), tap((state) => onRead(state)))
.subscribe());
subscriptions.add(state$.pipe(withLatestFrom(context$)).subscribe(([state, context]) => {
persistToStorage(this.generateKeyWithContext(context, key), state, storage);
}));
return subscriptions;
}
/**
* Helper to read state from persistent storage (localStorage, sessionStorage).
* It is useful if you need synchronously access state saved with `syncWithStorage`.
*
* @param key Key to use in storage for state. Should be unique for each feature.
* @param context Context value for state
* @param storageType Storage type from to read state
*
* @returns State from the storage
*/
readStateFromStorage({ key, context = '', storageType = StorageSyncType.LOCAL_STORAGE, }) {
const storage = getStorage(storageType, this.winRef);
return readFromStorage(storage, this.generateKeyWithContext(context, key));
}
generateKeyWithContext(context, key) {
return `spartacus⚿${[]
.concat(context)
.join('⚿')}⚿${key}`;
}
}
StatePersistenceService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.0.5", ngImport: i0, type: StatePersistenceService, deps: [{ token: i1.WindowRef }], target: i0.ɵɵFactoryTarget.Injectable });
StatePersistenceService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.0.5", ngImport: i0, type: StatePersistenceService, providedIn: 'root' });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.0.5", ngImport: i0, type: StatePersistenceService, decorators: [{
type: Injectable,
args: [{
providedIn: 'root',
}]
}], ctorParameters: function () { return [{ type: i1.WindowRef }]; } });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"state-persistence.service.js","sourceRoot":"","sources":["../../../../../../projects/core/src/state/services/state-persistence.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAc,EAAE,EAAE,YAAY,EAAE,MAAM,MAAM,CAAC;AACpD,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAC1D,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAElE,OAAO,EACL,UAAU,EACV,gBAAgB,EAChB,eAAe,GAChB,MAAM,0BAA0B,CAAC;;;AAKlC,MAAM,OAAO,uBAAuB;IAClC,YAAsB,MAAiB;QAAjB,WAAM,GAAN,MAAM,CAAW;IAAG,CAAC;IAE3C;;;;;;;;;;;;;;;;;;;OAmBG;IACH,eAAe,CAAI,EACjB,GAAG,EACH,MAAM,EACN,QAAQ,GAAG,EAAE,CAAC,EAAE,CAAC,EACjB,WAAW,GAAG,eAAe,CAAC,aAAa,EAC3C,MAAM,GAAG,GAAG,EAAE,GAAE,CAAC,GAOlB;QACC,MAAM,OAAO,GAAG,UAAU,CAAC,WAAW,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;QAErD,MAAM,aAAa,GAAG,IAAI,YAAY,EAAE,CAAC;QAEzC,0FAA0F;QAC1F,aAAa,CAAC,GAAG,CACf,QAAQ;aACL,IAAI,CACH,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE;YACd,OAAO,eAAe,CACpB,OAAO,EACP,IAAI,CAAC,sBAAsB,CAAC,OAAO,EAAE,GAAG,CAAC,CACzB,CAAC;QACrB,CAAC,CAAC,EACF,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAC9B;aACA,SAAS,EAAE,CACf,CAAC;QAEF,aAAa,CAAC,GAAG,CACf,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,EAAE,OAAO,CAAC,EAAE,EAAE;YACnE,gBAAgB,CACd,IAAI,CAAC,sBAAsB,CAAC,OAAO,EAAE,GAAG,CAAC,EACzC,KAAK,EACL,OAAO,CACR,CAAC;QACJ,CAAC,CAAC,CACH,CAAC;QAEF,OAAO,aAAa,CAAC;IACvB,CAAC;IAED;;;;;;;;;OASG;IACH,oBAAoB,CAAI,EACtB,GAAG,EACH,OAAO,GAAG,EAAE,EACZ,WAAW,GAAG,eAAe,CAAC,aAAa,GAK5C;QACC,MAAM,OAAO,GAAG,UAAU,CAAC,WAAW,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;QAErD,OAAO,eAAe,CACpB,OAAO,EACP,IAAI,CAAC,sBAAsB,CAAC,OAAO,EAAE,GAAG,CAAC,CACzB,CAAC;IACrB,CAAC;IAES,sBAAsB,CAC9B,OAA+B,EAC/B,GAAW;QAEX,OAAO,aAAc,EAAoB;aACtC,MAAM,CAAC,OAAO,CAAC;aACf,IAAI,CAAC,GAAG,CAAC,IAAI,GAAG,EAAE,CAAC;IACxB,CAAC;;oHAtGU,uBAAuB;wHAAvB,uBAAuB,cAFtB,MAAM;2FAEP,uBAAuB;kBAHnC,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Observable, of, Subscription } from 'rxjs';\nimport { map, tap, withLatestFrom } from 'rxjs/operators';\nimport { StorageSyncType } from '../../state/config/state-config';\nimport { WindowRef } from '../../window/window-ref';\nimport {\n  getStorage,\n  persistToStorage,\n  readFromStorage,\n} from '../utils/browser-storage';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class StatePersistenceService {\n  constructor(protected winRef: WindowRef) {}\n\n  /**\n   * Helper to synchronize state to more persistent storage (localStorage, sessionStorage).\n   * It is context aware, so you can keep different state for te same feature based on specified context.\n   *\n   * Eg. cart is valid only under the same base site. So you want to synchronize cart only with the same base site.\n   * Usage for that case: `syncWithStorage({ key: 'cart', state$: activeCartSelector$, context$: this.siteContextParamsService.getValues([BASE_SITE_CONTEXT_ID]), onRead: (state) => setCorrectStateInStore(state) })`.\n   * Active cart for the `electronics` base site will be stored under `spartacus⚿electronics⚿cart` and for apparel under `spartacus⚿apparel⚿cart`.\n   *\n   * On each context change onRead function will be executed with state from storage provided as a parameter.\n   *\n   * Omitting context$ will trigger onRead only once at initialization.\n   *\n   * @param key Key to use in storage for the synchronized state. Should be unique for each feature.\n   * @param state$ State to be saved and later restored.\n   * @param context$ Context for state\n   * @param storageType Storage type to be used to persist state\n   * @param onRead Function to be executed on each storage read after context change\n   *\n   * @returns Subscriptions for reading/writing in storage on context/state change\n   */\n  syncWithStorage<T>({\n    key,\n    state$,\n    context$ = of(''),\n    storageType = StorageSyncType.LOCAL_STORAGE,\n    onRead = () => {},\n  }: {\n    key: string;\n    state$: Observable<T>;\n    context$?: Observable<string | Array<string>>;\n    storageType?: StorageSyncType;\n    onRead?: (stateFromStorage: T | undefined) => void;\n  }): Subscription {\n    const storage = getStorage(storageType, this.winRef);\n\n    const subscriptions = new Subscription();\n\n    // Do not change order of subscription! Read should happen before write on context change.\n    subscriptions.add(\n      context$\n        .pipe(\n          map((context) => {\n            return readFromStorage(\n              storage,\n              this.generateKeyWithContext(context, key)\n            ) as T | undefined;\n          }),\n          tap((state) => onRead(state))\n        )\n        .subscribe()\n    );\n\n    subscriptions.add(\n      state$.pipe(withLatestFrom(context$)).subscribe(([state, context]) => {\n        persistToStorage(\n          this.generateKeyWithContext(context, key),\n          state,\n          storage\n        );\n      })\n    );\n\n    return subscriptions;\n  }\n\n  /**\n   * Helper to read state from persistent storage (localStorage, sessionStorage).\n   * It is useful if you need synchronously access state saved with `syncWithStorage`.\n   *\n   * @param key Key to use in storage for state. Should be unique for each feature.\n   * @param context Context value for state\n   * @param storageType Storage type from to read state\n   *\n   * @returns State from the storage\n   */\n  readStateFromStorage<T>({\n    key,\n    context = '',\n    storageType = StorageSyncType.LOCAL_STORAGE,\n  }: {\n    key: string;\n    context?: string | Array<string>;\n    storageType?: StorageSyncType;\n  }): T | undefined {\n    const storage = getStorage(storageType, this.winRef);\n\n    return readFromStorage(\n      storage,\n      this.generateKeyWithContext(context, key)\n    ) as T | undefined;\n  }\n\n  protected generateKeyWithContext(\n    context: string | Array<string>,\n    key: string\n  ): string {\n    return `spartacus⚿${([] as Array<string>)\n      .concat(context)\n      .join('⚿')}⚿${key}`;\n  }\n}\n"]}