@kwiz/common 1.0.1

package/src/utils/knownscript.ts

@@ -0,0 +1,280 @@
+import { ICS, IDataJs, IKnownScript, IMSAL, assign, isNullOrUndefined, ksGlobal } from "./_dependencies";
+import script from "./script";
+
+/** /products/common/scripts/ */
+export const commonScriptsPrefix = "/products/common/scripts/";
+/** /products/modern/scripts/ */
+export const modernScriptsPrefix = "/products/modern/scripts/";
+
+export class KnownScriptLoader<TypeOfGlobal> implements IKnownScript {
+    public url: string;
+    public dependencies?: IKnownScript[];
+    public global: ksGlobal;
+    public sodName?: string;
+    public css?: string[];
+    public rtlCss?: string[];
+    public forceMin?: boolean;
+
+    public _hash?: string;
+
+    private _globalInstance?: TypeOfGlobal;
+    public get globalInstance() { return this._globalInstance; }
+
+    public constructor(definition: IKnownScript) {
+        assign(this, definition);
+    }
+    public async load(): Promise<TypeOfGlobal> {
+        if (isNullOrUndefined(this.globalInstance))
+            this._globalInstance = await script.Instance.loadKnownScript(this) as TypeOfGlobal;
+        return this.globalInstance;
+    }
+    public loadSync(): TypeOfGlobal {
+        if (isNullOrUndefined(this.globalInstance))
+            this._globalInstance = script.Instance.loadKnownScript_Sync(this) as TypeOfGlobal;
+        return this.globalInstance;
+    }
+}
+
+/** loads into $kw */
+export var jQueryKnownScript = new KnownScriptLoader<any>({
+    url: commonScriptsPrefix + "jquery-1.8.2.min.js",
+    global: "$kw",
+    sodName: "kwizcom.common.jquery-1.8.2.js"
+});
+
+/** loads into moment */
+export var MomentJSKnownScript = new KnownScriptLoader<typeof momentJS>({
+    url: "/libs/moment/moment.min.js",
+    global: "moment"
+});
+
+/** loads into moment.tz */
+export var MomentTimezoneJSKnownScript = new KnownScriptLoader<typeof monentJSTimeZone>({
+    url: "/libs/moment/moment-timezone.min.js",
+    global: "moment.tz",
+    dependencies: [MomentJSKnownScript]
+});
+/** loads into kLocales or kwizcom.kLocales */
+export var LocaleKnownScript = new KnownScriptLoader<IKLocales>({
+    url: commonScriptsPrefix + "locale.min.js",
+    global: "kwizcom.kLocales",
+    sodName: "kwizcom.common.locale.js",
+    dependencies: [MomentTimezoneJSKnownScript]
+});
+/** Loads jQuery and Select2 with the CSS file for Select2 */
+export var Select2KnownScript = new KnownScriptLoader<any>({
+    url: commonScriptsPrefix + "select2.min.js",
+    global: "Select2.class",
+    sodName: "kwizcom.common.select2.js",
+    css: ["/products/common/css/select2.min.css"],
+    dependencies: [jQueryKnownScript]
+});
+/** Loads fabric and its CSS */
+export var FabricKnownScript = new KnownScriptLoader<any>({
+    url: "/libs/office-ui-fabric-js/1.4.0/js/fabric.min.js?prefix=kw",
+    global: "kwfabric",
+    //Issue 6494 rename fabric.css since SP modern page will remove any css that ends with fabric.css or fabric.min.css
+    css: ["/libs/office-ui-fabric-js/1.4.0/css/fabric.kwizcom.min.css?prefix=kw",
+        "/libs/office-ui-fabric-js/1.4.0/css/fabric.kwizcom.components.min.css?prefix=kw"],
+    rtlCss: ["/libs/office-ui-fabric-js/1.4.0/css/fabric.kwizcom.rtl.min.css?prefix=kw",
+        "/libs/office-ui-fabric-js/1.4.0/css/fabric.kwizcom.components.rtl.min.css?prefix=kw"]
+});
+/** loads into kwizcom.aplfe.api */
+export var APLFEApiKnownScript = new KnownScriptLoader<any>({
+    url: "/products/aplfe/scripts/kwizcom.aplfe.api.min.js",
+    global: "kwizcom.aplfe.api",
+    sodName: "kwizcom.aplfe.api.js"
+});
+
+/** loads into KWizComRepeatingRowsControlBuilder */
+export var RRWControlBuilderKnownScript = new KnownScriptLoader<any>({
+    url: "/products/aprrw/scripts/controlbuilder.min.js",
+    global: "KWizComRepeatingRowsControlBuilder",
+    dependencies: [jQueryKnownScript]
+});
+
+/** loads into kwOfficeUiFabricReact */
+export var OfficeUiFabricReactKnownScript = new KnownScriptLoader<any>({
+    url: "/libs/office-ui-fabric-react/office-ui-fabric-react.js",
+    global: "kwizcom.OfficeUiFabricReact"
+});
+
+/** loads into $kw.ui */
+export var jQueryUIKnownScript = new KnownScriptLoader<any>({
+    url: commonScriptsPrefix + "jquery-ui-1.9.2.custom.min.js",
+    global: "$kw.ui",
+    sodName: "kwizcom.common.jquery-ui-1.9.2.custom.js",
+    dependencies: [jQueryKnownScript],
+    css: ["/products/common/css/jquery-ui.min.css"]
+});
+/** loads into $kw.ui.touchLoded */
+export var jQueryTouchPunchKnownScript = new KnownScriptLoader<any>({
+    url: commonScriptsPrefix + "jquery.ui.touch-punch.min.js",
+    global: "$kw.ui.touchLoded",
+    dependencies: [jQueryUIKnownScript]
+});
+/** loads into $kw.fn.camera */
+export var CameraKnownScript = new KnownScriptLoader<any>({
+    url: "/libs/camera/js/camera.min.js",
+    global: "$kw.fn.camera",
+    dependencies: [jQueryUIKnownScript],
+    css: ["/libs/camera/css/camera.min.css"]
+});
+/** loads into flatpickr */
+export var FlatPickerKnownScript = new KnownScriptLoader<any>({
+    url: "/libs/flatpickr/flatpickr.min.js",
+    global: "flatpickr",
+    css: ["/libs/flatpickr/flatpickr.min.css"]
+});
+/** loads into noUiSlider */
+export var NoUiSliderKnownScript = new KnownScriptLoader<any>({
+    url: "/libs/nouislider/nouislider.min.js",
+    global: "noUiSlider",
+    css: ["/libs/nouislider/nouislider.min.css"]
+});
+/** loads into blueimp */
+export var BlueImpGalleryKnownScript = new KnownScriptLoader<any>({
+    url: "/libs/blueimp-gallery/js/blueimp-gallery.min.js",
+    global: "blueimp",
+    css: ["/libs/blueimp-gallery/css/blueimp-gallery.min.css"]
+});
+/** loads into dhx */
+export var dhxDiagramKnownScript = new KnownScriptLoader<any>({
+    url: "/libs/dhtmlx/diagram.min.js",
+    global: "dhx",
+    css: ["/libs/dhtmlx/diagram.min.css"]
+});
+/** loads into dragscroll */
+export var dragScrollKnownScript = new KnownScriptLoader<any>({
+    url: "/libs/dragscroll/dragscroll.min.js",
+    global: "dragscroll"
+});
+/** loads into getOrgChart */
+export var getOrgChartKnownScript = new KnownScriptLoader<any>({
+    url: "/libs/getorgchart/getorgchart.min.js",
+    global: "getOrgChart",
+    css: ["/libs/getorgchart/getorgchart.min.css"]
+});
+/** loads into OrgChart */
+export var OrgChartJsKnownScript = new KnownScriptLoader<any>({
+    url: "/libs/orgchartjs/orgchart.min.js",
+    global: "OrgChart"
+});
+/** loads into photopile */
+export var PhotopileKnownScript = new KnownScriptLoader<any>({
+    url: "/libs/photopile/js/photopile.min.js",
+    global: "photopile",
+    dependencies: [jQueryTouchPunchKnownScript],
+    css: ["/libs/photopile/css/photopile.min.css"]
+});
+
+/** loads into $kw.fn.fullCalendar */
+export var fullCalendarKnownScript = new KnownScriptLoader<any>({
+    url: "/libs/fullcalendar/fullcalendar.min.js",
+    global: "$kw.fn.fullCalendar",
+    dependencies: [jQueryKnownScript, MomentTimezoneJSKnownScript],
+    css: ["/libs/fullcalendar/fullcalendar.min.css"]
+});
+
+/** loads into spEventsParser */
+export var SpEventsParserKnownScript = new KnownScriptLoader<{
+    parseEvent(item: any, startDate: Date, endDate: Date): any[];
+}>({
+    url: commonScriptsPrefix + "sp-events-parser/sp-events-parser.min.js",
+    global: "spEventsParser"
+});
+
+/** loads into kwizcom.controls.Conditions */
+export var ConditionsKnownScript = new KnownScriptLoader<any>({
+    url: commonScriptsPrefix + "controls/conditions.min.js",
+    global: "kwizcom.controls.Conditions",
+    dependencies: [LocaleKnownScript]
+});
+/** loads into KWizComCountdownControlBuilder */
+export var CountdownControlBuilderKnownScript = new KnownScriptLoader<any>({
+    url: "/products/apcnt/scripts/controlbuilder.min.js",
+    global: "KWizComCountdownControlBuilder",
+    dependencies: [LocaleKnownScript]
+});
+/** loads into SP.UI.ModalDialog.showErrorDialog */
+export var OnPremPolyfillKnownScript = new KnownScriptLoader<any>({
+    url: commonScriptsPrefix + "onprem.polyfill.min.js",
+    sodName: "kwizcom.common.onprem.polyfill.js",
+    global: "SP.UI.ModalDialog.showErrorDialog"
+});
+/** loads into kwizcom.datajs */
+export var DataJSKnownScript = new KnownScriptLoader<IDataJs>({
+    url: "/libs/datajs/datajs.min.js",
+    global: "kwizcom.OData"
+});
+/** loads into tinymce */
+export var TinyMCEKnownScript = new KnownScriptLoader<any>({
+    url: "/libs/tinymce/tinymce.min.js",
+    forceMin: true,
+    global: "tinymce"
+});
+/** loads into kwizcom.monaco */
+export var monacoKnownScript = new KnownScriptLoader<any>({
+    url: "/libs/monaco/monaco.js",
+    global: "kwizcom.monaco"
+});
+/** loads into kwizcom.ModernUILibrary.FormPage */
+export var ModernUIListFormKnownScript = new KnownScriptLoader<any>({
+    url: modernScriptsPrefix + "forms/formpage.min.js",
+    global: "kwizcom.ModernUILibrary.FormPage",
+    //dependencies: [OfficeUiFabricReact]
+});
+/** loads into jsonPath */
+export var jsonPathKnownScript = new KnownScriptLoader<any>({
+    url: commonScriptsPrefix + "JSONPath.min.js",
+    global: "jsonPath"
+});
+
+/** loads into _global_kwizcom_appas_modern_core */
+export var PasteModernCoreKnownScript = new KnownScriptLoader<any>({
+    url: "/products/appas/scripts/kwizcom.pasteplus.modern.core.min.js",
+    global: "$_global_kwizcom_appas_modern_core",
+    //dependencies: [OfficeUiFabricReact]
+});
+/** loads into kwizcom.libs.msal */
+export var msalKnownScript = new KnownScriptLoader<IMSAL>({
+    url: commonScriptsPrefix + "msal/msal.min.js",
+    global: "kwizcom.libs.msal"
+});
+/** loads into kwizcom.libs.ics */
+export var icsKnownScript = new KnownScriptLoader<ICS>({
+    url: "/libs/ics/ics.min.js",
+    global: "kwizcom.libs.ics"
+});
+
+var _jQueryTmplKnownScript = new KnownScriptLoader<any>({
+    url: "/libs/jquery/js/jquery.tmpl.min.js",
+    global: "$kw.fn.tmpl", forceMin: true,
+    dependencies: [jQueryKnownScript]
+});
+var _jQueryEasingKnownScript = new KnownScriptLoader<any>({
+    url: "/libs/jquery/js/jquery.easing.1.3.js",
+    global: "$kw.easing",
+    dependencies: [jQueryKnownScript]
+});
+var _jQueryElastislideKnownScript = new KnownScriptLoader<any>({
+    url: "/libs/jquery/js/jquery.elastislide.js",
+    global: "$kw.fn.elastislide",
+    css: ["/libs/jquery/css/elastislide.css"],
+    dependencies: [jQueryKnownScript]
+});
+/** Responsive Image Gallery */
+export var rigKnownScript = new KnownScriptLoader<(containerSelector: string, options?: {
+    mode?: "carousel" | "fullview";
+    anim?: boolean;
+    template?: string;
+    /** allow html in image description */
+    allowHTML?: boolean;
+    hideViewModes?: boolean;
+
+}) => { addItems: (elm) => void; }>({
+    url: "/libs/rig/js/gallery.js",
+    global: "kwizcom.libs.rig",
+    css: ["/libs/rig/css/style.css"],
+    dependencies: [jQueryKnownScript, _jQueryTmplKnownScript, _jQueryEasingKnownScript, _jQueryElastislideKnownScript]
+});

package/src/utils/localstoragecache.ts

@@ -0,0 +1,419 @@
+import { $w, BuildNumber, ILocalStorageCacheLifetime, flatted, getGlobal, isDate, isDebug, isNullOrEmptyString, isNullOrUndefined, isNumber, jsonParse, sizeOf } from "./_dependencies";
+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;
+/** key (no prefix) is kept in lower case. not case sensitive */
+var _cache = getGlobal<{
+    purgeCalled: boolean;
+    expirations: IExpirationsDictionary;
+    [keyNoPrefixToLower: string]: any;
+}>("common_utils_localstoragecache_module_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 {
+    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 !== BuildNumber.toString()) {
+            logger.log(`Purging cache because of build number change`)
+            purgeCache(true);
+            _cache.expirations = null;
+        }
+
+        if (isNullOrUndefined(_cache.expirations)) {
+            _cache.expirations = {
+                build: BuildNumber.toString()
+            };
+        }
+    }
+
+    return _cache.expirations;
+}
+
+function _saveCacheExpirations() {
+    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.toString();
+    _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 $w;
+
+    keys.forEach((key) => {
+        let v = _getItem(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;
+
+    if (typeof (_cache[key]) !== "undefined"
+        && _cache[key] !== null) {
+        return _cache[key] as T;
+    }
+
+    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);
+        }
+
+        _cache[key] = value;
+    }
+}
+
+export function removeCacheItem(key: string) {
+    key = key.toLowerCase();
+    delete _cache[key];
+    let keyWithPrefix = keyPrefix + key;
+
+    if (isLocalStorageSupported()) {
+        _removeItem(key);//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);
+}
+
+if (!_cache.purgeCalled) {
+    //issue 7081 - purge all orphans/expired items
+    _cache.purgeCalled = true;
+    //clear expired cache items.
+    $w.setTimeout(() => {
+        purgeCache();
+        if (isDebug()) {
+            let size = _getStoredSize();
+            logger.debug(`Size of items in local storage: ${size}KB`);
+        }
+    }, 3000);
+}
+//#endregion