angular-persistence

import { Observable } from 'rxjs'; import { StorageType } from '../constants/persistence.storage_type'; import { PersistenceConfig } from '../types/persistence.config'; import { ItemDefinition } from '../types/persistence.item_definition'; import { CacheConfig } from '../types/persistence.cache_config'; import { IPersistenceContainer } from '../abstracts/persistence.container'; import { ICache } from '../abstracts/persistence.cache'; /** * Service used to persist application wide storage. Iterms may be obtained from the Service * itself or used through proxies. This framework also supports an immutable flag which will * instruct the service that the objects stored within should not have any side-effects when * objects on the outside are changed. * * Note on immutability: Only clonable objects will be saved when the immutable flag is * set. This framework will do a deep clone of the objects in question, but items such * as functions will not be preserved. Also, immutability is slower. If you have objects * that are well controlled with a single component, it is suggested that you don't save your * item as immutable. * * @export * @class PersistenceService * * @author Scott O'Bryan * @since 1.0 */ export declare class PersistenceService { private _emitter; private _storage; /** * Returns a hot observable that can be used to monitor changes to this framework over * time. Subscribing to this observable has the potential of causing memory leaks, * so each subscriber is expected to unsubscribe when notifications are no longer * needed. * * @param {ItemDefinition} [config] the config object that can be used to filter the * results. If not provided, all changes will be * returned. * * @returns {Observable<ItemDefinition>} a hot observable that can monitor changes * to this framework over time. */ changes(config?: ItemDefinition): Observable<ItemDefinition>; /** * Returns an object from storage. If the object was stored with the immutable flag * set, then the object returned will not have any side-effects into the stored model * until it is set again. * * @param {string} key a string represnting the stored value * @param {StorageType} [type=StorageType.MEMORY] the storage type * @returns {*} the value or undefined if the object is not set */ get(key: string, type?: StorageType): any; /** * Puts an object into storage, replacing any item that may be in there. By default, * the object is stored as-is, which means that when other areas of code get the * object, they can mutate it. * * As immutable storage is slower, and the reconstituted logic may be * missing functions or metadata, it is recommended to use this only * if you need to ensure the integrity of the stored object on each set * as might be the case if you make use of the "change" emitter. * * @param {string} key the key that will represent the value * @param {*} value the value to store * @param {PersistenceConfig} [config={}] any additional configuration * @returns {boolean} which is <code>true</code> if the value was stored successfully */ set(key: string, value: any, config?: PersistenceConfig): boolean; /** * Clears a value stored in the service for the given type. * * @param {string} key the key of the stored value * @param {StorageType} [type=StorageType.MEMORY] the type of storage used * @returns {*} the item that was removed (if any) */ remove(key: string, type?: StorageType): any; /** * Clears all stored items for a particular storage type. * * @param {StorageType} [type=StorageType.MEMORY] the type of storage to clear */ removeAll(type?: StorageType): void; /** * Cleans up any expired objects in the cache. * * @param {StorageType} [type=StorageType.MEMORY] the type of storage to clean */ clean(type?: StorageType): void; /** * Create a property on the object that is bound to this stored value. This method * requires ES5 compatibility and the property will have special rules associated * with it. The name of the property will be "key", and the value stored in the * configured storage will be prefix + key. * * @template T the type of property * @param {*} obj the object where the property will be bound to * @param {string} propName the name of the property to be bound * @param {string} key the key used for the storage of the item * @param {PersistenceConfig} [config={}] any additional configuration */ defineProperty<T>(obj: any, propName: string, key: string, config?: PersistenceConfig): void; /** * Returns a facade that makes things a bit easier when interacting with the service. * The facade will use the prefix in order to isolate they keystore. If no prefix is * defined, the keystore will be mapped as usual with the keys working as-is in the * storage. * * @param config the config for the facade * @param prefix the prefix to use for isolation of the storage * * @return a PersistenceFacade object representing this store */ createContainer(namespace: string, config?: PersistenceConfig): IPersistenceContainer; /** * Returns a cache proxy that makes interacting with this service a little bit easier. The * proxy returned will have a set key, a generic loader, and a consistent set of config * parameters. Please note that the "expires" property of the config might have unforseen * side-effects to the cache in that if the expires setting is already passed, the cache will * no longer cache values until a new proxy is created. * * @param key they key for the item in the persistence layer * @param loader the function to load the intiial value. Must return either a value or * an Observable of that value. If an observable is returned, it will be * converted into a single by this method and returned to the subscriber. * @param config optional config object used to "set" the value if it has not already * been loaded. If a "type" is not specified, memory storage will be * used. * * @returns a CacheProxy that can be used to interact with this cache. */ createCache<T>(key: string, loader: () => T | Observable<T>, config?: CacheConfig): ICache<T>; private _getStorage(type); private _calculateExpires(maxAge); }