@kwiz/common 1.0.129 → 1.0.133

package/src/utils/localstoragecache.ts

@@ -1,447 +0,0 @@
-import { sizeOf } from "../helpers/collections.base";
-import { isDebug } from "../helpers/debug";
-import { flatted } from "../helpers/flatted";
-import { jsonParse } from "../helpers/json";
-import { getGlobal } from "../helpers/objects";
-import { isDate, isNullOrEmptyString, isNullOrUndefined, isNumber } from "../helpers/typecheckers";
-import { ILocalStorageCacheLifetime } from "../types/localstoragecache.types";
-import { ConsoleLogger } from "./consolelogger";
-
-/**key with prefix, value is a date string */
-interface IExpirationsDictionary {
-    [keyWithPRefix: string]: string;
-    build: string;
-}
-
-let logger = ConsoleLogger.get("localstoragecache");
-
-export const keyPrefix = "kw$_";
-export const LOCAL_STORAGE_PREFIX = "kwizcom-localstorage-cache";
-export const LOCAL_STORGAGE_EXPIRATIONS_KEY = LOCAL_STORAGE_PREFIX + "-expirations";
-export const DEFAULT_EXPIRATION = 20 * 60 * 1000; // 20 minutes;
-/** When caching logic changes (serialization methods, format, schema), the MODULE_REVISION should be incremented
- * and all client side apps will need to be rebuilt */
-export const MODULE_REVISION = "1";
-/** key (no prefix) is kept in lower case. not case sensitive */
-
-function _getCache() {
-    let _cache = getGlobal<{
-        purgeCalled: boolean;
-        expirations: IExpirationsDictionary;
-        [keyNoPrefixToLower: string]: any;
-    }>("common_utils_localstoragecache_module_cache");
-
-    if (!_cache.purgeCalled) {
-        //issue 7081 - purge all orphans/expired items
-        _cache.purgeCalled = true;
-        //clear expired cache items.
-        (globalThis || window).setTimeout(() => {
-            purgeCache();
-            if (isDebug()) {
-                let size = _getStoredSize();
-                logger.debug(`Size of items in local storage: ${size}KB`);
-            }
-        }, 5000);
-    }
-
-    return _cache;
-}
-
-var _supportsLocalStorage: boolean = null;
-
-function _parseExpiration(exp: number | ILocalStorageCacheLifetime | Date): Date {
-    var expirationDate: Date;
-
-    if (isNumber(exp) && exp > 0) {
-        expirationDate = new Date();
-        expirationDate.setMilliseconds(expirationDate.getMilliseconds() + exp);
-    } else if (exp instanceof Date) {
-        expirationDate = exp;
-    } else if (exp) {
-        var tempexp = exp as ILocalStorageCacheLifetime;
-        var seconds = typeof (tempexp.seconds) === "number" ? tempexp.seconds : undefined;
-        var minutes = typeof (tempexp.minutes) === "number" ? tempexp.minutes : undefined;
-        var hours = typeof (tempexp.hours) === "number" ? tempexp.hours : undefined;
-        var days = typeof (tempexp.days) === "number" ? tempexp.days : undefined;
-        var months = typeof (tempexp.months) === "number" ? tempexp.months : undefined;
-        var years = typeof (tempexp.years) === "number" ? tempexp.years : undefined;
-
-        if (seconds || minutes || hours || days || months || years) {
-            expirationDate = new Date();
-
-            if (seconds) {
-                expirationDate.setMilliseconds(expirationDate.getMilliseconds() + (seconds * 1000));
-            }
-
-            if (minutes) {
-                expirationDate.setMilliseconds(expirationDate.getMilliseconds() + (minutes * 60 * 1000));
-            }
-
-            if (hours) {
-                expirationDate.setMilliseconds(expirationDate.getMilliseconds() + (hours * 60 * 60 * 1000));
-            }
-
-            if (days) {
-                expirationDate.setMilliseconds(expirationDate.getMilliseconds() + (days * 24 * 60 * 60 * 1000));
-            }
-
-            if (months) {
-                expirationDate.setMonth(expirationDate.getMonth() + months);
-            }
-
-            if (years) {
-                expirationDate.setFullYear(expirationDate.getFullYear() + years);
-            }
-        }
-    }
-
-    if (!expirationDate) {
-        expirationDate = new Date();
-        expirationDate.setMilliseconds(expirationDate.getMilliseconds() + DEFAULT_EXPIRATION);
-    }
-
-    return expirationDate;
-}
-
-function _getCacheExpirations(): IExpirationsDictionary {
-    let _cache = _getCache();
-    if (isNullOrUndefined(_cache.expirations)) {
-        _cache.expirations = jsonParse<IExpirationsDictionary>(_getItem(LOCAL_STORGAGE_EXPIRATIONS_KEY));
-
-        //ISSUE: 1525 - expire the cache if it was built with a different version number so that the cache 
-        //is compatible with the current build
-        if (!isNullOrUndefined(_cache.expirations) && _cache.expirations.build !== MODULE_REVISION) {
-            logger.log(`Purging cache because of build number change`)
-            purgeCache(true);
-            _cache.expirations = null;
-        }
-
-        if (isNullOrUndefined(_cache.expirations)) {
-            _cache.expirations = {
-                build: MODULE_REVISION
-            };
-        }
-    }
-
-    return _cache.expirations;
-}
-
-function _saveCacheExpirations() {
-    let _cache = _getCache();
-    if (!isNullOrUndefined(_cache.expirations) && sizeOf(_cache.expirations) > 0) {
-        _setItem(LOCAL_STORGAGE_EXPIRATIONS_KEY, JSON.stringify(_cache.expirations));
-    }
-    else {
-        _removeItem(LOCAL_STORGAGE_EXPIRATIONS_KEY);
-    }
-}
-
-function _setCacheExpiration(keyWithPrefix: string, expireDate: Date) {
-    var expirations = _getCacheExpirations();
-    expirations[keyWithPrefix] = expireDate.toISOString();
-    _saveCacheExpirations();
-}
-
-function _isKeyExpired(keyWithPrefix: string) {
-    var expirations = _getCacheExpirations();
-    if (expirations && expirations[keyWithPrefix]) {
-        var now = new Date();
-        var eDate = new Date(expirations[keyWithPrefix]);
-        if (now > eDate) {
-            try {
-                delete expirations[keyWithPrefix];
-            } catch (ex) {
-                expirations[keyWithPrefix] = undefined; // undefined variables are removed when passed to JSON.stringify
-            }
-
-            _saveCacheExpirations();
-            //has a date, it is expired.
-            return true;
-        }
-        //has a date, it is not expired yet.
-        return false;
-    }
-    //has no date or not in expirations at all - say it is expired...
-    return true;
-}
-
-function _getItem(key: string) {
-    try {
-        return localStorage.getItem(key);
-    } catch {
-    }
-    return null;
-}
-
-function _setItem(key: string, value: string) {
-    try {
-        localStorage.setItem(key, value);
-        return true;
-    } catch {
-    }
-    return false;
-}
-
-function _removeItem(key: string) {
-    try {
-        localStorage.removeItem(key);
-        return true;
-    } catch {
-    }
-    return false;
-}
-
-/**Get the size (KB) of all entries in local storage. Only returns the size for entries with kwizcom key prefix. */
-function _getStoredSize() {
-    let keys = getCacheKeys();
-    let total = 0;
-    let length = 0;
-    let useBlob = 'Blob' in (globalThis || window);
-
-    keys.forEach((key) => {
-        let v = _getItem(`${keyPrefix}${key}`);
-        if (!isNullOrEmptyString(v)) {
-            if (useBlob) {
-                length = (new Blob([v + key])).size;
-            } else {
-                length = ((v.length + key.length) * 2);
-            }
-        }
-        total += length;
-    });
-
-    return Number((total / 1024).toFixed(2));
-}
-
-export function isLocalStorageSupported() {
-    if (_supportsLocalStorage !== null) {
-        return _supportsLocalStorage;
-    }
-
-    var result;
-    try {
-        _setItem(LOCAL_STORAGE_PREFIX, LOCAL_STORAGE_PREFIX);
-        result = _getItem(LOCAL_STORAGE_PREFIX) === LOCAL_STORAGE_PREFIX;
-        _removeItem(LOCAL_STORAGE_PREFIX);
-        _supportsLocalStorage = result;
-    } catch (ex) {
-        _supportsLocalStorage = false;
-    }
-
-    return _supportsLocalStorage;
-}
-
-//#region exported methods
-export function getCacheItem<T>(key: string, options?: {
-    /** Flatted allows serizlising circular dependency objects */
-    useFlatted?: boolean;
-}): T {
-    key = key.toLowerCase();
-    let keyWithPrefix = keyPrefix + key;
-
-    let _cache = _getCache();
-
-    if (typeof (_cache[key]) !== "undefined"
-        && _cache[key] !== null) {
-        let isExpired = _isKeyExpired(keyWithPrefix);
-        if (!isExpired) {
-            return _cache[key] as T;
-        } 
-        //else remove it from cache
-        removeCacheItem(key);        
-    }
-
-    if (isLocalStorageSupported()) {
-        var value: string = _getItem(keyWithPrefix);
-        if (isNullOrUndefined(value)) {
-            return null;
-        }
-
-        let isExpired = _isKeyExpired(keyWithPrefix);
-
-        if (!isExpired) {
-            let valueAsT: T = options && options.useFlatted ? flatted.parse(value) as T : jsonParse<T>(value);
-            if (valueAsT !== null) {
-                _cache[key] = valueAsT;
-                return valueAsT;
-            } else {
-                _cache[key] = value;
-                return value as any as T;
-            }
-        }
-        //else remove it from cache
-        removeCacheItem(key);
-    }
-
-    return null;
-}
-
-export function setCacheItem(key: string, value: any, expiration: number | ILocalStorageCacheLifetime | Date, options?: {
-    /** Flatted allows serizlising circular dependency objects */
-    useFlatted?: boolean;
-}): void {
-    if (isLocalStorageSupported()) {
-        key = key.toLowerCase();
-        removeCacheItem(key);
-
-        var val = null;
-        try {
-            if (options && options.useFlatted)
-                val = flatted.stringify(value);
-            else
-                val = JSON.stringify(value);
-        } catch (ex) {
-            logger.debug(`Object cannot be stored in local storage: ${ex && ex.message || ex} ${key}`);
-            return;//this put [object] in cache for me if object can't be stringified!
-        }
-
-        let keyWithPrefix = keyPrefix + key;
-
-        var expireDate = _parseExpiration(expiration);
-
-        let saved = _setItem(keyWithPrefix, val);
-        if (saved) {
-            _setCacheExpiration(keyWithPrefix, expireDate);
-        }
-
-        let _cache = _getCache();
-
-        _cache[key] = value;
-    }
-}
-
-export function removeCacheItem(keyNoPrefix: string) {
-    keyNoPrefix = keyNoPrefix.toLowerCase();
-    let _cache = _getCache();
-    delete _cache[keyNoPrefix];
-    let keyWithPrefix = keyPrefix + keyNoPrefix;
-
-    if (isLocalStorageSupported()) {
-        _removeItem(keyNoPrefix);//in case we have an old one
-        _removeItem(keyWithPrefix);
-    }
-}
-
-export function removeCacheItems(keys: string[]) {
-    keys.forEach((key) => {
-        removeCacheItem(key);
-    });
-}
-
-export function getCacheKeys() {
-    let keys: string[] = [];
-
-    if (isLocalStorageSupported()) {
-        keys = Object.keys(localStorage).filter((key) => {
-            return key.startsWith(keyPrefix);
-        }).map((key) => {
-            return key.substring(keyPrefix.length);
-        });
-    }
-
-    return keys;
-}
-
-/** remove expired cache keys created by this utility.
- * to remove all keys (non-expired too) send removeAll=true
- */
-function purgeCache(removeAll?: boolean) {
-    if (!isLocalStorageSupported()) return;
-
-    var cacheExpirationsKeys = [
-        LOCAL_STORGAGE_EXPIRATIONS_KEY,
-        "kwizcom-aplfe-caching-expirations", // old clean up
-        "localStorageExpirations" // old clean up
-    ];
-
-    let now = new Date();
-
-    let nonExpiredKeys: string[] = [];
-
-    //get all expiration keys (key/expiration date/time)
-    for (let j = 0; j < cacheExpirationsKeys.length; j++) {
-        try {
-            let expirations = null;
-            let cacheExpirationsKey = cacheExpirationsKeys[j];
-
-            let removeAllForKey = removeAll || cacheExpirationsKey !== LOCAL_STORGAGE_EXPIRATIONS_KEY;
-
-            if (cacheExpirationsKey === "localStorageExpirations") {
-                //old format - load expirations from this one as well
-                expirations = _getItem(cacheExpirationsKey); // "key1^11/18/2011 5pm|key2^3/10/2012 3pm"
-                if (expirations) {
-                    let arr = expirations.split("|"); // ["key1^11/18/2011 5pm","key2^3/10/2012 3pm"]
-                    for (let i = 0; i < arr.length; i++) {
-                        try {
-                            let key_expiration_format = arr[i]; // "key1^11/18/2011 5pm"
-                            let key = key_expiration_format.split("^")[0];
-                            //old keys - remove all, all the time
-                            _removeItem(key);//remove key from cache
-                        } catch (e) { }
-                    }
-                }
-            } else {
-                //new format
-                expirations = cacheExpirationsKey === LOCAL_STORGAGE_EXPIRATIONS_KEY ? _getCacheExpirations() : jsonParse(_getItem(cacheExpirationsKey));
-                if (expirations) {
-                    let expirationKeys = Object.keys(expirations);
-                    logger.group(() => {
-                        expirationKeys.forEach(keyWithPrefix => {
-                            try {
-                                let shouldRemoveKey = removeAllForKey || !keyWithPrefix.startsWith(keyPrefix);
-                                if (!shouldRemoveKey) {
-                                    //check specific key expiration
-                                    let expirationDate = new Date(expirations[keyWithPrefix]);
-                                    if (!isDate(expirationDate) || expirationDate < now) {
-                                        shouldRemoveKey = true;
-                                        delete expirations[keyWithPrefix];
-                                        logger.info(`purging key ${keyWithPrefix}`);
-                                    }
-                                    else {
-                                        nonExpiredKeys.push(keyWithPrefix);
-                                    }
-                                }
-                                if (shouldRemoveKey) _removeItem(keyWithPrefix);
-                            } catch (e) {
-                                logger.warn(`failed to remove key ${keyWithPrefix}`);
-                            }
-                        });
-                    }, "Checking expired items", true);
-                }
-            }
-
-            if (cacheExpirationsKey === LOCAL_STORGAGE_EXPIRATIONS_KEY)
-                _saveCacheExpirations();
-            else//older keys - just remove them.
-                _removeItem(cacheExpirationsKey);
-        } catch (e) {
-            logger.warn(`something went terribly wrong ${e}`);
-        }
-    }
-
-    logger.group(() => {
-        logger.table(nonExpiredKeys);
-        //cleanup orphans
-        //loop on all keys
-        //if stats with: jsr_, kwfs| or keyPrefix - and not in nonExpiredKeys, it is an orphan. Remove it.
-        let localStorageKeys = Object.keys(localStorage);
-        for (let keyIdx = 0; keyIdx < localStorageKeys.length; keyIdx++) {
-            let key = localStorageKeys[keyIdx];
-            if (key.startsWith("jsr_") || key.startsWith("kwfs|")) {
-                logger.log(`removing old key ${key}`);
-                _removeItem(key);//old key
-            }
-            else if (key.startsWith(keyPrefix) && !nonExpiredKeys.includes(key))//orphan!
-            {
-                logger.log(`removing orphan key ${key}`);
-                _removeItem(key);
-            }
-        }
-    }, "Expired keys", true);
-}
-
-/** cleanup - remove all local storage keys created by this utility */
-export function clearCache(): void {
-    return purgeCache(true);
-}
-//#endregion