@nu-art/thunderstorm-frontend 0.400.5

package/modules/ModuleFE_ForceUpgrade.js

@@ -0,0 +1,54 @@
+/*
+ * Thunderstorm is a full web app framework!
+ *
+ * Typescript & Express backend infrastructure that natively runs on firebase function
+ * Typescript & React frontend infrastructure
+ *
+ * Copyright (C) 2020 Adam van der Kruk aka TacB0sS
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Dispatcher, Module } from '@nu-art/ts-common';
+import { ModuleFE_XHR } from './http/ModuleFE_XHR.js';
+import { ApiDef_ForceUpgrade, HeaderKey_AppVersion, HeaderKey_BrowserType, HttpMethod } from '@nu-art/thunderstorm-shared';
+import { browserType } from '../utils/tools.js';
+import { apiWithQuery } from '../core/typed-api.js';
+const dispatch_onUpgradeRequired = new Dispatcher('__onUpgradeRequired');
+class ModuleFE_ForceUpgrade_Class extends Module {
+    v1;
+    constructor() {
+        super();
+        this.v1 = {
+            assertAppVersion: apiWithQuery(ApiDef_ForceUpgrade.v1.assertAppVersion)
+        };
+    }
+    init() {
+        ModuleFE_XHR.addDefaultHeader(HeaderKey_AppVersion, `${process.env.appVersion}`);
+        ModuleFE_XHR.addDefaultHeader(HeaderKey_BrowserType, `${browserType()}`);
+    }
+    compareVersion = () => {
+        const def = { method: HttpMethod.GET, path: this.config.assertVersionUrl };
+        // this.v1.assertAppVersion({}).execute((response) => {
+        // 	dispatch_onUpgradeRequired.dispatchModule(response);
+        // });
+        ModuleFE_XHR
+            .createRequest(def)
+            .setRelativeUrl(this.config.assertVersionUrl)
+            .execute((response) => {
+            dispatch_onUpgradeRequired.dispatchModule(response);
+        });
+    };
+    async __postInit() {
+    }
+}
+export const ModuleFE_ForceUpgrade = new ModuleFE_ForceUpgrade_Class();

package/modules/ModuleFE_LocalStorage.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Created by tacb0ss on 27/07/2018.
+ */
+import { Module, ResolvableContent, TS_Object } from '@nu-art/ts-common';
+import { OnClearWebsiteData } from './clearWebsiteDataDispatcher.js';
+export interface OnStorageKeyChangedListener {
+    __onStorageKeyEvent(event: StorageEvent): Promise<void>;
+}
+type GetType = string | number | object;
+export declare class StorageModule_Class extends Module implements OnClearWebsiteData {
+    private readonly cache;
+    private readonly withstandDeletionKeys;
+    private readonly allKeys;
+    protected init(): void;
+    __onClearWebsiteData(): Promise<void>;
+    private handleStorageEvent;
+    getStorage: (persist: boolean) => Storage;
+    set(key: string, value: string | number | object, persist?: boolean): void;
+    delete(key: string, persist?: boolean): void;
+    clearCache(key: string): void;
+    get(key: string, fallbackValue?: ResolvableContent<GetType>, persist?: boolean): string | number | object | undefined;
+    query<T>(query: RegExp): T[];
+    deleteAll(query: RegExp): void;
+    private withstandDeletion;
+    private registerKey;
+}
+export declare const ModuleFE_LocalStorage: StorageModule_Class;
+export declare class StorageKey<ValueType = string | number | object> {
+    readonly key: string;
+    private readonly persist;
+    private _onChange?;
+    constructor(key: string, persist?: boolean);
+    /**
+     * Will not delete this storage key if the delete operation is performed from __onClearWebsiteData
+     */
+    withstandDeletion(): this;
+    get(): ValueType | undefined;
+    get(fallbackValue: ResolvableContent<ValueType>): ValueType;
+    patch(value: ValueType extends TS_Object ? Partial<ValueType> : ValueType): any;
+    set(value: ValueType): ValueType;
+    delete(): void;
+    clearCache(): void;
+    onChange(onChangeListener: (after?: ValueType, before?: ValueType) => Promise<void>): this;
+    getPersistence: () => boolean;
+}
+export {};

package/modules/ModuleFE_LocalStorage.js

@@ -0,0 +1,179 @@
+/*
+ * Thunderstorm is a full web app framework!
+ *
+ * Typescript & Express backend infrastructure that natively runs on firebase function
+ * Typescript & React frontend infrastructure
+ *
+ * Copyright (C) 2020 Adam van der Kruk aka TacB0sS
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Created by tacb0ss on 27/07/2018.
+ */
+import { _keys, exists, merge, Module, resolveContent } from '@nu-art/ts-common';
+import { ThunderDispatcher } from '../core/thunder-dispatcher.js';
+export class StorageModule_Class extends Module {
+    cache = {};
+    withstandDeletionKeys = [];
+    allKeys = {};
+    init() {
+        window.addEventListener('storage', this.handleStorageEvent);
+    }
+    async __onClearWebsiteData() {
+        const items = this.withstandDeletionKeys.map(key => key.get());
+        localStorage.clear();
+        sessionStorage.clear();
+        _keys(this.cache).forEach(key => delete this.cache[key]);
+        this.withstandDeletionKeys.forEach((key, index) => {
+            if (items[index])
+                key.set(items[index]);
+        });
+    }
+    handleStorageEvent = async (e) => {
+        const key = e.key;
+        if (!key)
+            return this.logVerbose('storage event without any key');
+        const storageKey = this.allKeys[key];
+        if (!storageKey)
+            return this.logVerbose(`no StorageKey for '${key}'`);
+        this.logDebug(`Storage key '${key}' was updated`, e.oldValue, e.newValue);
+        try {
+            // @ts-ignore
+            await storageKey._onChange?.();
+        }
+        catch (e) {
+            this.logError(`Error while handling change event for storage key: ${storageKey.key}`);
+            this.logError(e);
+            throw e;
+        }
+        const dispatcher = new ThunderDispatcher('__onStorageKeyEvent');
+        await dispatcher.dispatchModuleAsync(e);
+        await dispatcher.dispatchUIAsync(e);
+    };
+    getStorage = (persist) => persist ? localStorage : sessionStorage;
+    set(key, value, persist = true) {
+        if (value === undefined)
+            return this.delete(key);
+        this.cache[key] = value;
+        this.getStorage(persist).setItem(key, JSON.stringify(value));
+        // @ts-ignore
+        this.allKeys[key]._onChange?.();
+    }
+    delete(key, persist = true) {
+        this.clearCache(key);
+        this.getStorage(persist).removeItem(key);
+        // @ts-ignore
+        this.allKeys[key]._onChange?.();
+    }
+    clearCache(key) {
+        delete this.cache[key];
+    }
+    get(key, fallbackValue, persist = true) {
+        let value = this.cache[key];
+        if (value)
+            return value;
+        value = this.getStorage(persist).getItem(key);
+        // this.logDebug(`get: ${key} = ${value}`)
+        if (!exists(value) || value === 'null' || value === 'undefined')
+            return resolveContent(fallbackValue);
+        // if (!this.isIncognito)
+        return this.cache[key] = JSON.parse(value);
+    }
+    query(query) {
+        const toRet = [];
+        for (let i = 0; i < localStorage.length; i++) {
+            const key = localStorage.key(i);
+            if (key?.match(query)) {
+                const item = localStorage.getItem(key);
+                if (item) {
+                    try {
+                        const exp = JSON.parse(item);
+                        toRet.push(exp);
+                    }
+                    catch (e) {
+                        this.logError(e);
+                    }
+                }
+            }
+        }
+        return toRet;
+    }
+    deleteAll(query) {
+        for (let i = 0; i < localStorage.length; i++) {
+            const key = localStorage.key(i);
+            if (key?.match(query)) {
+                localStorage.removeItem(key);
+            }
+        }
+    }
+    withstandDeletion(storageKey) {
+        this.withstandDeletionKeys.push(storageKey);
+    }
+    registerKey(storageKey) {
+        this.allKeys[storageKey.key] = storageKey;
+    }
+}
+export const ModuleFE_LocalStorage = new StorageModule_Class();
+//TODO Generic Keys like in the tests contexts
+export class StorageKey {
+    key;
+    persist;
+    _onChange;
+    constructor(key, persist = true) {
+        this.key = key;
+        this.persist = persist;
+        // @ts-ignore
+        ModuleFE_LocalStorage.registerKey(this);
+    }
+    /**
+     * Will not delete this storage key if the delete operation is performed from __onClearWebsiteData
+     */
+    withstandDeletion() {
+        // @ts-ignore
+        ModuleFE_LocalStorage.withstandDeletion(this);
+        return this;
+    }
+    get(fallbackValue) {
+        // @ts-ignore
+        return ModuleFE_LocalStorage.get(this.key, fallbackValue, this.persist);
+    }
+    patch(value) {
+        const previousValue = this.get();
+        const mergedValue = merge(previousValue, value);
+        this.set(mergedValue);
+        return mergedValue;
+    }
+    set(value) {
+        // @ts-ignore
+        ModuleFE_LocalStorage.set(this.key, value, this.persist);
+        // console.log('StorageKey', this.key);
+        return value;
+    }
+    delete() {
+        ModuleFE_LocalStorage.delete(this.key, this.persist);
+    }
+    clearCache() {
+        ModuleFE_LocalStorage.clearCache(this.key);
+    }
+    onChange(onChangeListener) {
+        this._onChange = () => {
+            const before = this.get();
+            this.clearCache();
+            const after = this.get();
+            return onChangeListener(after, before);
+        };
+        return this;
+    }
+    getPersistence = () => this.persist;
+}

package/modules/ModuleFE_Locale.d.ts

@@ -0,0 +1,44 @@
+import { Module, TypedMap } from '@nu-art/ts-common';
+export type Language = {
+    longName?: string;
+    shortName: string;
+    shortLocale: string;
+    longLocale?: string;
+    rtl?: boolean;
+};
+type Config<O extends TypedMap<string | undefined> = TypedMap<string | undefined>, T extends {
+    [K in keyof O]-?: O[K];
+} = {
+    [K in keyof O]-?: O[K];
+}> = {
+    languages: {
+        [k: string]: {
+            language: Language;
+            texts: T;
+        };
+    };
+    defaultLocal: string;
+};
+export declare class ModuleFE_Locale_Class<O extends TypedMap<string | undefined> = TypedMap<string | undefined>, T extends {
+    [K in keyof O]-?: O[K];
+} = {
+    [K in keyof O]-?: O[K];
+}> extends Module<Config<O, T>> {
+    private defaultLocale;
+    private activeLocaleTexts;
+    private activeLocale;
+    constructor();
+    protected init(): void;
+    setActiveLocale(locale: string): void;
+    getActiveLocale(): string;
+    private setActiveLocaleImpl;
+    stringify(key: keyof T, previousKeys?: (keyof T)[]): (...params: (string | number)[]) => string | keyof T;
+    getLanguage(locale: string): (Language | undefined);
+    getActiveLanguage(): Language;
+    getAllLanguages(): Language[];
+    convertNumber(param: any, locale: string): undefined;
+}
+export declare const ModuleFE_Locale: ModuleFE_Locale_Class<TypedMap<string | undefined>, {
+    [x: string]: string | undefined;
+}>;
+export {};

package/modules/ModuleFE_Locale.js

@@ -0,0 +1,83 @@
+/*
+ * Thunderstorm is a full web app framework!
+ *
+ * Typescript & Express backend infrastructure that natively runs on firebase function
+ * Typescript & React frontend infrastructure
+ *
+ * Copyright (C) 2020 Adam van der Kruk aka TacB0sS
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { _keys, Module } from '@nu-art/ts-common';
+export class ModuleFE_Locale_Class extends Module {
+    defaultLocale;
+    activeLocaleTexts;
+    activeLocale;
+    constructor() {
+        super();
+    }
+    init() {
+        this.defaultLocale = this.config.languages[this.config.defaultLocal].texts;
+        this.activeLocaleTexts = this.defaultLocale;
+        this.setActiveLocale(this.config.defaultLocal);
+    }
+    setActiveLocale(locale) {
+        const localeTexts = this.config.languages[locale].texts;
+        if (!localeTexts)
+            return;
+        this.activeLocale = locale;
+        this.setActiveLocaleImpl(localeTexts);
+    }
+    getActiveLocale() {
+        return this.activeLocale;
+    }
+    setActiveLocaleImpl(localeStrings) {
+        this.activeLocaleTexts = localeStrings;
+    }
+    stringify(key, previousKeys = []) {
+        return (...params) => {
+            let text = this.activeLocaleTexts[key];
+            if (!text)
+                text = this.defaultLocale[key];
+            if (!text)
+                return key;
+            return params.reduce((_toRet, param, index) => {
+                let toRet = _toRet;
+                const refs = toRet.match(/@\{(.*?)\}/g);
+                if (refs) {
+                    toRet = refs.reduce((previousValue, stringKeyRef) => {
+                        const stringKey = stringKeyRef.match(/@\{(.*?)\}/)?.[1];
+                        const nested = this.stringify(stringKey, [...previousKeys, key])();
+                        return previousValue.replace(stringKeyRef, nested);
+                    }, _toRet);
+                }
+                return toRet.replace(`\${${index}}`, `${param}`);
+            }, text);
+        };
+    }
+    getLanguage(locale) {
+        return this.config.languages[locale]?.language;
+    }
+    getActiveLanguage() {
+        return this.config.languages[this.activeLocale]?.language;
+    }
+    getAllLanguages() {
+        return _keys(this.config.languages)
+            .filter(key => Object.keys(this.config.languages[key].texts).length > 0)
+            .map(key => this.config.languages[key].language);
+    }
+    convertNumber(param, locale) {
+        return undefined;
+    }
+}
+export const ModuleFE_Locale = new ModuleFE_Locale_Class();

package/modules/ModuleFE_Print.d.ts

@@ -0,0 +1,16 @@
+import { Module, TypedKeyValue } from '@nu-art/ts-common';
+import * as React from 'react';
+declare class ModuleFE_Print_Class extends Module {
+    printNode(node: React.ReactNode, bodyAttributes?: TypedKeyValue<string, string>[]): Promise<void>;
+    printElement(div: HTMLElement, bodyAttributes?: TypedKeyValue<string, string>[]): Promise<void>;
+    private generatePrintFrame;
+    private insertElement;
+    private insertNode;
+    private openPrint;
+    private defaultBodyAttributes;
+    private frameGeneration_GetFrame;
+    private frameGeneration_CloneHead;
+    private frameGeneration_SetBodyAttributes;
+}
+export declare const ModuleFE_Print: ModuleFE_Print_Class;
+export {};

package/modules/ModuleFE_Print.js

@@ -0,0 +1,116 @@
+import { Module, Second, ThisShouldNotHappenException } from '@nu-art/ts-common';
+import ReactDOMServer from 'react-dom/server';
+class ModuleFE_Print_Class extends Module {
+    //######################### Public #########################
+    async printNode(node, bodyAttributes = this.defaultBodyAttributes()) {
+        return new Promise((resolve, reject) => {
+            try {
+                const printFrame = this.generatePrintFrame(resolve, bodyAttributes);
+                this.insertNode(printFrame, node);
+                this.openPrint(printFrame);
+            }
+            catch (err) {
+                this.logError('Failed printing node', err);
+                reject();
+            }
+        });
+    }
+    async printElement(div, bodyAttributes = this.defaultBodyAttributes()) {
+        return new Promise((resolve, reject) => {
+            const themeValue = document.body.getAttribute('theme');
+            if (themeValue)
+                (bodyAttributes || (bodyAttributes = [])).push({ key: 'theme', value: themeValue });
+            try {
+                const printFrame = this.generatePrintFrame(resolve, bodyAttributes);
+                this.insertElement(printFrame, div);
+                this.openPrint(printFrame);
+            }
+            catch (err) {
+                this.logError('Failed printing element', err);
+                reject();
+            }
+        });
+    }
+    //######################### Internal Logic #########################
+    generatePrintFrame = (resolve, bodyAttributes) => {
+        const body = document.getElementsByTagName('body')[0];
+        const printFrame = this.frameGeneration_GetFrame(body);
+        const printWindow = printFrame.contentWindow;
+        if (!printWindow)
+            throw new ThisShouldNotHappenException('Printing frame has no content window');
+        //clone frame head
+        this.frameGeneration_CloneHead(printWindow);
+        //Set body attributes
+        this.frameGeneration_SetBodyAttributes(printWindow, bodyAttributes);
+        //Set listener for print frame to resolve the promise after closing
+        printWindow.addEventListener('afterprint', () => {
+            body.removeChild(printFrame);
+            resolve();
+        }, { once: true });
+        return printFrame;
+    };
+    insertElement = (printFrame, element) => {
+        const printWindow = printFrame.contentWindow;
+        if (!printWindow)
+            throw new ThisShouldNotHappenException('Printing frame has no content window');
+        //Insert cloned element in body
+        const toAppend = element.cloneNode(true);
+        const body = printWindow.document.body;
+        body.appendChild(toAppend);
+        //Close document to editing
+        printWindow.document.close();
+    };
+    insertNode = (printFrame, node) => {
+        const printWindow = printFrame.contentWindow;
+        if (!printWindow)
+            throw new ThisShouldNotHappenException('Printing frame has no content window');
+        const markup = ReactDOMServer.renderToStaticMarkup(node);
+        const body = printWindow.document.body;
+        body.innerHTML = markup;
+        //Close document to editing
+        printWindow.document.close();
+    };
+    openPrint = (printFrame) => {
+        const printWindow = printFrame.contentWindow;
+        if (!printWindow)
+            throw new ThisShouldNotHappenException('Printing frame has no content window');
+        printWindow.focus();
+        setTimeout(async () => printWindow.print(), 1.5 * Second);
+    };
+    defaultBodyAttributes = () => {
+        const _attributes = document.body.attributes;
+        const attributes = [];
+        for (let i = 0; i < _attributes.length; i++) {
+            const att = _attributes[i];
+            attributes.push({ key: att.name, value: att.value });
+        }
+        return attributes;
+    };
+    //######################### Frame Generation Logic #########################
+    frameGeneration_GetFrame = (body) => {
+        const printFrame = document.createElement('iframe');
+        //Set print frame dimensions
+        printFrame.style.width = '0';
+        printFrame.style.height = '0';
+        printFrame.style.position = 'absolute';
+        //Append print frame to the body
+        body.appendChild(printFrame);
+        return printFrame;
+    };
+    frameGeneration_CloneHead = (printWindow) => {
+        const newHead = window.document.head.cloneNode(true);
+        const currentHead = printWindow.document.head;
+        const printHtml = printWindow.document.getElementsByTagName('html')[0];
+        printHtml.replaceChild(newHead, currentHead);
+    };
+    frameGeneration_SetBodyAttributes = (printWindow, bodyAttributes) => {
+        if (!bodyAttributes?.length)
+            return;
+        const body = printWindow.document.body;
+        //Add body attributes
+        bodyAttributes.forEach(att => {
+            body.setAttribute(att.key, att.value);
+        });
+    };
+}
+export const ModuleFE_Print = new ModuleFE_Print_Class();

package/modules/ModuleFE_StorageCleaner.d.ts

@@ -0,0 +1,17 @@
+import { Module } from '@nu-art/ts-common';
+import { StorageKey } from './ModuleFE_LocalStorage.js';
+declare class ModuleFE_StorageCleaner_Class extends Module {
+    cleanLocalStorage: (storageKeys?: StorageKey[]) => void;
+    cleanSessionStorage: (storageKeys?: StorageKey[]) => void;
+    cleanIDBStorage: () => Promise<void>;
+    cleanCache: () => Promise<void>;
+    cleanCookies: () => void;
+    /**
+     *
+     * @param callback - Any interaction with storage must be through this callback
+     */
+    cleanAll: (callback?: VoidFunction) => Promise<void>;
+    private cleanIDBImpl;
+}
+export declare const ModuleFE_StorageCleaner: ModuleFE_StorageCleaner_Class;
+export {};

package/modules/ModuleFE_StorageCleaner.js

@@ -0,0 +1,90 @@
+import { Module } from '@nu-art/ts-common';
+//@ts-ignore - set IDBAPI as indexedDB regardless of browser
+const IDBAPI = window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
+class ModuleFE_StorageCleaner_Class extends Module {
+    // ######################## Public Functions ########################
+    cleanLocalStorage = (storageKeys) => {
+        if (!storageKeys?.length) {
+            this.logInfo('Clearing all local-storage');
+            return localStorage.clear();
+        }
+        storageKeys.forEach(storageKey => {
+            //Delete only local storage keys
+            if (!storageKey.getPersistence())
+                return;
+            localStorage.removeItem(storageKey.key);
+            this.logDebug(`Cleared local-storage for key ${storageKey.key}`);
+        });
+    };
+    cleanSessionStorage = (storageKeys) => {
+        if (!storageKeys?.length) {
+            this.logInfo('Clearing all session-storage');
+            return sessionStorage.clear();
+        }
+        storageKeys.forEach(storageKey => {
+            //Delete only session storage keys
+            if (storageKey.getPersistence())
+                return;
+            sessionStorage.removeItem(storageKey.key);
+            this.logDebug(`Cleared session-storage for key ${storageKey.key}`);
+        });
+    };
+    cleanIDBStorage = async () => {
+        this.logInfo('Clearing all IDBs');
+        const databases = await IDBAPI.databases();
+        await Promise.all(databases.map(this.cleanIDBImpl));
+        this.logInfo('Cleared all IDBs');
+    };
+    cleanCache = async () => {
+        const cacheNames = await caches.keys();
+        this.logInfo('Clearing cache');
+        await Promise.all(cacheNames.map(async (cacheName) => await caches.delete(cacheName)));
+        this.logInfo('Cleared cache');
+    };
+    cleanCookies = () => {
+        const cookies = document.cookie.split(';');
+        cookies.forEach(cookie => {
+            const name = cookie.split('=')[0];
+            //expires= tells the browser to expire the cookie and discard it.
+            //path=/ sets the cookie to expire across the domain, not a specific path.
+            document.cookie = `${name}=;expires=Thu, 01 Jan 1970 00:00:00 GMT;path=/`;
+        });
+        this.logInfo('Cleaned all cookies');
+    };
+    /**
+     *
+     * @param callback - Any interaction with storage must be through this callback
+     */
+    cleanAll = async (callback) => {
+        this.cleanLocalStorage();
+        this.cleanSessionStorage();
+        this.cleanCookies();
+        await this.cleanCache();
+        await this.cleanIDBStorage();
+        if (callback) {
+            await new Promise(resolve => {
+                setTimeout(() => {
+                    callback();
+                    resolve();
+                });
+            });
+        }
+    };
+    // ######################## Internal Logic ########################
+    cleanIDBImpl = async (info) => {
+        return new Promise((resolve, reject) => {
+            if (!info.name) {
+                return resolve();
+            }
+            const request = IDBAPI.deleteDatabase(info.name);
+            request.onerror = e => {
+                return reject(request.error);
+            };
+            request.onsuccess = e => {
+                this.logInfo(`IDB ${info.name} cleared`);
+                resolve();
+            };
+        });
+    };
+}
+export const ModuleFE_StorageCleaner = new ModuleFE_StorageCleaner_Class();

package/modules/ModuleFE_Thunderstorm.d.ts

@@ -0,0 +1,31 @@
+import { Module, TypedMap } from '@nu-art/ts-common';
+type Config = {
+    appName: string;
+    themeColor: string;
+};
+export type UrlTarget = '_blank' | '_self' | '_parent' | '_top' | string;
+export type FileDownloadProps = {
+    url?: string;
+    content?: Blob | string;
+    fileName: string;
+    mimeType?: string;
+    charset?: string;
+};
+declare class ModuleFE_Thunderstorm_Class extends Module<Config> {
+    constructor();
+    init(): void;
+    setAppName(appName: string): void;
+    setChromeThemeColor(themeColor: string): void;
+    clearWebsiteData(): Promise<void[]>;
+    copyToClipboard(toCopy: string, customSuccessMessage?: string): Promise<void>;
+    readFileContent(file: File): Promise<string>;
+    writeToClipboard(imageAsBase64: string, contentType?: string): Promise<void>;
+    getAppName(): string;
+    openUrl(url: string | {
+        url: string;
+        params?: TypedMap<(() => string) | string | undefined>;
+    }, target?: UrlTarget): void;
+    downloadFile(props: FileDownloadProps): void;
+}
+export declare const ModuleFE_Thunderstorm: ModuleFE_Thunderstorm_Class;
+export {};