@nu-art/thunderstorm-frontend 0.400.5

package/core/IndexedDBV4/IndexedDB_Database.js

@@ -0,0 +1,268 @@
+import { Logger, LogLevel, md5, sortArray } from '@nu-art/ts-common';
+import { StorageKey } from '../../modules/ModuleFE_LocalStorage.js';
+//@ts-ignore - set IDBAPI as indexedDB regardless of browser
+const IDBAPI = window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
+export class IndexedDB_Database extends Logger {
+    dbName;
+    db;
+    openPromise;
+    registeredStores = [];
+    // ######################## Init ########################
+    constructor(dbName) {
+        super(`IDB_Database-${dbName}`);
+        this.setMinLevel(LogLevel.Info);
+        this.dbName = dbName;
+    }
+    // ######################## DB Interaction ########################
+    clearDB = async () => {
+        const t0 = performance.now?.() ?? Date.now();
+        this.logInfo(`[CLEAR] Requested clear for DB="${this.dbName}"`);
+        return new Promise(async (resolve, reject) => {
+            try {
+                //db is closed & not awaiting opening
+                if (!this.db && !this.openPromise) {
+                    this.logDebug(`[CLEAR DB] DB not open and no openPromise pending — nothing to clear`);
+                    return resolve();
+                }
+                if (this.openPromise) {
+                    this.logDebug(`[CLEAR-DB] Awaiting ongoing openPromise before clearing`);
+                    await this.openPromise;
+                }
+                const storeNames = Array.from(this.db.objectStoreNames);
+                this.logInfo(`[CLEAR-DB] Deleting ${storeNames.length} stores: ${storeNames.join(', ') || '(none)'}`);
+                storeNames.forEach(storeName => {
+                    this.db.deleteObjectStore(storeName);
+                });
+                this.db.close();
+                const dt = (performance.now?.() ?? Date.now()) - t0;
+                this.logInfo(`[CLEAR-DB] Completed in ${Math.round(dt)}ms`);
+                resolve();
+            }
+            catch (err) {
+                this.logErrorBold(`[CLEAR-DB] Failed: ${err}`);
+                reject(err);
+            }
+        });
+    };
+    // ######################## Store Interaction ########################
+    registerStore = (dbConfig, onDBOpenCallback) => {
+        const registeredStore = { config: dbConfig, onDBOpenCallback };
+        (this.registeredStores || (this.registeredStores = [])).push(registeredStore);
+        this.logDebug('[REGISTER-STORE]', `Store: ${dbConfig.name}`, `Group: ${dbConfig.group}`, `Auto Increment: ${!!dbConfig.autoIncrement}`, `Indices: ${dbConfig.indices?.length ?? 0}`);
+    };
+    async getStore(config, write = false, _store) {
+        if (_store)
+            return _store;
+        try {
+            this.logDebug(`[GET-STORE] Request for "${config.name}"`, `write: ${write}`);
+            await this.open();
+            const tx = this.db.transaction(config.name, write ? 'readwrite' : 'readonly');
+            const store = tx.objectStore(config.name);
+            this.logVerboseBold(`[GET-STORE] OK "${config.name}"`, `(mode: ${write ? 'rw' : 'ro'})`);
+            return store;
+        }
+        catch (err) {
+            this.logError(`Failed to get store for collection '${config.group}/${config.name}'`);
+            throw err;
+        }
+    }
+    storeExists = async (storeName) => {
+        await this.open();
+        const exists = this.db.objectStoreNames.contains(storeName);
+        this.logDebug(`[STORE-EXISTS] store="${storeName}" => ${exists}`, '');
+        return exists;
+    };
+    async open() {
+        if (this.db) {
+            this.logDebug(`[OPEN] Already open: returning existing connection`, `DB Name: ${this.db.name}`);
+            return;
+        }
+        if (this.openPromise) {
+            this.logDebug(`[OPEN] Re-entrant call — awaiting existing openPromise`, `DB Name: ${this.dbName}`);
+            return this.openPromise;
+        }
+        try {
+            return await this.open_Impl();
+        }
+        catch (err) {
+            if (err instanceof DOMException && err.name === 'VersionError') {
+                return this.open_Impl(true);
+            }
+            else {
+                throw new Error(`Error opening IDB - ${this.dbName}`);
+            }
+        }
+    }
+    open_Impl = (ignoreCurrentVersion = false) => {
+        const start = performance.now?.() ?? Date.now();
+        const openId = Math.random().toString(36).slice(2, 8); // useful when correlating logs
+        this.logInfo(`[OPEN: ${openId}] - Starting open`, '');
+        return this.openPromise = new Promise((resolve, reject) => {
+            if (!IDBAPI) {
+                this.logErrorBold(`[OPEN:${openId}] Error — current browser does not support IndexedDB`);
+                delete this.openPromise;
+                return reject(new Error('Error - current browser does not support IndexedDB'));
+            }
+            let nextVersion;
+            if (!ignoreCurrentVersion) {
+                const nextVersion = this.getNextVersionData();
+                const currentVersionData = this.getCurrentVersionData();
+                this.logDebug(`[OPEN: ${openId}] Attempting open DB: "${this.dbName}"`, `currentVersion: ${currentVersionData?.version ?? 0}, nextVersion: ${nextVersion.version},`, `currentHash: ${currentVersionData?.hash ?? '-'}, nextHash: ${nextVersion.hash}`);
+            }
+            const request = IDBAPI.open(this.dbName, nextVersion?.version);
+            request.onblocked = (e) => {
+                this.logWarningBold(`[OPEN:${openId}] onblocked — Another tab/process holds the old version open`, e);
+            };
+            request.onupgradeneeded = async () => {
+                const upStart = performance.now?.() ?? Date.now();
+                this.logInfo(`[OPEN:${openId}] onupgradeneeded`, `Current Version: ${this.getCurrentVersionData()?.version ?? 0}`, `Next Version: ${nextVersion?.version ?? 'N/A'}`);
+                const db = request.result;
+                const duplicatedStores = new Set();
+                try {
+                    this.registeredStores.forEach(registeredStore => {
+                        //Don't create a store that already exists
+                        if (db.objectStoreNames.contains(registeredStore.config.name)) {
+                            this.logVerboseBold(`[OPEN:${openId}] Store already exists!`, `Store Name: ${registeredStore.config.name}`);
+                            return duplicatedStores.add(registeredStore.config.name);
+                        }
+                        const options = {
+                            autoIncrement: registeredStore.config.autoIncrement,
+                            keyPath: registeredStore.config.uniqueKeys
+                        };
+                        const store = db.createObjectStore(registeredStore.config.name, options);
+                        this.logDebug(`[OPEN:${openId}] Created store`, `Store Name: ${registeredStore.config.name}`, `KeyPath: ${JSON.stringify(options.keyPath)}`, `AutoIncrement: ${!!options.autoIncrement}`);
+                        registeredStore.config.indices?.forEach(index => {
+                            store.createIndex(index.id, index.keys, {
+                                multiEntry: index.params?.multiEntry,
+                                unique: index.params?.unique
+                            });
+                            this.logDebug(`[OPEN:${openId}] Index`, `IndexID: ${index.id}`, `Keys: ${JSON.stringify(index.keys)}`, `Unique: ${!!index.params?.unique}`, `Multi: ${!!index.params?.multiEntry}`);
+                        });
+                        try {
+                            registeredStore.config.upgradeProcessor?.(store);
+                            if (registeredStore.config.upgradeProcessor)
+                                this.logDebug(`[OPEN:${openId}] UpgradeProcessor Executed for`, `Store Name: ${registeredStore.config.name}`);
+                        }
+                        catch (upgradeErr) {
+                            this.logErrorBold(`[OPEN:${openId}] UpgradeProcessor Failed for`, `Store Name: ${registeredStore.config.name}`, `Error: ${JSON.stringify(upgradeErr)}`);
+                        }
+                    });
+                    this.setCurrentVersionData({ version: db.version, hash: this.generateVersionHash() });
+                    if (duplicatedStores.size)
+                        this.logWarningBold(`[OPEN:${openId}] Duplicate store registrations detected`, ...Array.from(duplicatedStores));
+                }
+                catch (e) {
+                    this.logErrorBold(`[OPEN:${openId}] onupgradeneeded failed`, e);
+                }
+                finally {
+                    const upDt = (performance.now?.() ?? Date.now()) - upStart;
+                    this.logInfo(`[OPEN:${openId}] onupgradeneeded completed in ${Math.round(upDt)}ms`);
+                }
+            };
+            request.onsuccess = async () => {
+                const tConn = (performance.now?.() ?? Date.now()) - start;
+                try {
+                    const storesLength = request.result.objectStoreNames.length;
+                    this.logInfo(`[OPEN:${openId}] OnSuccess — Opened`, `dbName: ${this.dbName}`, `Store Amount: ${storesLength}`, `Completion Time: ${Math.round(tConn)}ms`);
+                    this.db = request.result;
+                    // Defensive: log connection lifecycle events
+                    this.db.onversionchange = (ev) => {
+                        this.logWarningBold(`[OPEN:${openId}] db.onversionchange fired — closing connection`, ev);
+                        try {
+                            this.db.close();
+                        }
+                        catch {
+                        }
+                    };
+                    this.db.onclose = () => this.logInfo(`[OPEN:${openId}] db.onclose`);
+                    this.db.onerror = (ev) => this.logErrorBold(`[OPEN:${openId}] db.onerror`, ev);
+                    // Run open callbacks with full timing & error capture
+                    await this.onDBOpen(openId);
+                    resolve(this);
+                    delete this.openPromise;
+                    // Persist version (again) to ensure it’s set even if there was no upgrade
+                    this.setCurrentVersionData({ version: this.db.version, hash: this.generateVersionHash() });
+                    this.logDebug(`[OPEN:${openId}] Completed open()`, '');
+                }
+                catch (err) {
+                    this.logErrorBold(`[OPEN:${openId}] Failure during onDBOpen(): ${err}`);
+                    delete this.openPromise;
+                    reject(err);
+                }
+            };
+            request.onerror = (e) => {
+                this.logErrorBold(`[OPEN:${openId}] request.onerror — failed to open DB "${this.dbName}"`, e);
+                delete this.openPromise;
+                reject(request.error);
+            };
+        });
+    };
+    onDBOpen = async (openId) => {
+        const tag = openId ? `OPEN:${openId}` : `OPEN`;
+        const allStart = performance.now?.() ?? Date.now();
+        if (!this.registeredStores?.length) {
+            this.logDebug(`[${tag}] onDBOpen`, 'No registered stores — nothing to notify');
+            return;
+        }
+        this.logInfo(`[${tag}] onDBOpen`, `Invoking ${this.registeredStores.length} store callbacks`);
+        for (const store of this.registeredStores) {
+            const name = store.config?.name ?? '(unknown-store)';
+            if (!store.onDBOpenCallback) {
+                this.logDebug(`[${tag}] onDBOpen: Store "${name}" has no callback`, '');
+                continue;
+            }
+            const cbStart = performance.now?.() ?? Date.now();
+            let returned;
+            let isAsync = false;
+            try {
+                returned = store.onDBOpenCallback();
+                isAsync = !!returned && typeof returned.then === 'function';
+                this.logDebug(`[${tag}] onDBOpen: "${name}" Callback Invoked`, `Async: ${isAsync}`);
+                // Always await to preserve ordering
+                await returned;
+                const cbDt = (performance.now?.() ?? Date.now()) - cbStart;
+                this.logVerboseBold(`[${tag}] onDBOpen: "${name}" Callback Completed`, `Completion Time: ${Math.round(cbDt)}ms`);
+            }
+            catch (err) {
+                const cbDt = (performance.now?.() ?? Date.now()) - cbStart;
+                this.logErrorBold(`[${tag}] onDBOpen: "${name}" Callback FAILED`, `Elapsed Time: ${Math.round(cbDt)}ms`, err);
+                throw err;
+            }
+        }
+        const allDt = (performance.now?.() ?? Date.now()) - allStart;
+        this.logInfo(`[${tag}] onDBOpen: All callbacks completed`, `Completion Time: ${Math.round(allDt)}ms`);
+    };
+    // ######################## Version Control ########################
+    getCurrentVersionData = () => {
+        const storage = new StorageKey(`idb-version-data__${this.dbName}`);
+        const data = storage.get();
+        this.logDebug(`[VERSION] getCurrentVersionData => v=${data?.version ?? '-'}`, `Hash: ${data?.hash ?? '-'}`);
+        return data;
+    };
+    setCurrentVersionData = (versionData) => {
+        const storage = new StorageKey(`idb-version-data__${this.dbName}`);
+        storage.set(versionData);
+        this.logDebug(`[VERSION] setCurrentVersionData => v=${versionData.version}`, `Hash: ${versionData.hash}`);
+        return versionData;
+    };
+    generateVersionHash = () => {
+        const stores = sortArray(this.registeredStores, i => i.config.name);
+        const hash = md5(stores.map(i => i.config.name).join(','));
+        this.logDebug(`[VER] generateVersionHash => ${hash} from [${stores.map(s => s.config.name).join(', ')}]`, '');
+        return hash;
+    };
+    getNextVersionData = () => {
+        const currentVersionData = this.getCurrentVersionData();
+        const hash = this.generateVersionHash();
+        if (hash === currentVersionData?.hash) {
+            this.logDebug(`[VER] Hash unchanged — keeping version ${currentVersionData.version}`, '');
+            return currentVersionData;
+        }
+        const next = {
+            version: ((currentVersionData?.version ?? 0) + 1),
+            hash
+        };
+        this.logInfo(`[VER] Hash changed — bumping version to ${next.version}`, '');
+        return next;
+    };
+}

package/core/IndexedDBV4/IndexedDB_Store.d.ts

@@ -0,0 +1,34 @@
+import { DBProto, IndexKeys, Logger } from '@nu-art/ts-common';
+import { DBConfigV3, IndexDb_Query_V3, ReduceFunction_V3 } from './types.js';
+type StoreResolver<Proto extends DBProto<any>> = (dbConfig: DBConfigV3<Proto>, write?: boolean, store?: IDBObjectStore) => Promise<IDBObjectStore>;
+type StoreExistsResolver<Proto extends DBProto<any>> = (dbConfig: DBConfigV3<Proto>) => Promise<boolean>;
+export declare class IndexedDB_Store<Proto extends DBProto<any>> extends Logger {
+    private config;
+    private storeResolver;
+    private storeExistsResolver;
+    constructor(config: DBConfigV3<Proto>, storeResolver: StoreResolver<Proto>, storeExistsResolver: StoreExistsResolver<Proto>);
+    getStore: (write?: boolean, store?: IDBObjectStore) => Promise<IDBObjectStore>;
+    exists: () => Promise<boolean>;
+    count: () => Promise<number>;
+    private getCursor;
+    private cursorHandler;
+    insert(value: Proto['dbType'], _store?: IDBObjectStore): Promise<Proto['dbType']>;
+    insertAll(values: Proto['dbType'][], _store?: IDBObjectStore): Promise<void>;
+    upsert(value: Proto['dbType'], _store?: IDBObjectStore): Promise<Proto['dbType']>;
+    upsertAll(values: Proto['dbType'][], _store?: IDBObjectStore): Promise<void>;
+    get(key: IndexKeys<Proto['dbType'], keyof Proto['dbType']>): Promise<Proto['dbType'] | undefined>;
+    query(query: IndexDb_Query_V3): Promise<Proto['dbType'][] | undefined>;
+    queryFilter(filter: (item: Proto['dbType']) => boolean, query?: IndexDb_Query_V3): Promise<Proto['dbType'][]>;
+    WIP_queryMapNew<Type>(mapper: (item: Proto['dbType']) => Type, filter?: (item: Proto['dbType']) => boolean, query?: IndexDb_Query_V3): Promise<Type[]>;
+    WIP_queryMap<Type>(mapper: (item: Proto['dbType']) => Type, filter?: (item: Proto['dbType']) => boolean, query?: IndexDb_Query_V3): Promise<Type[]>;
+    queryFind(filter: (item: Proto['dbType']) => boolean): Promise<Proto['dbType'] | undefined>;
+    queryReduce<ReturnType>(reducer: ReduceFunction_V3<Proto['dbType'], ReturnType>, initialValue: ReturnType, filter?: (item: Proto['dbType']) => boolean, query?: IndexDb_Query_V3): Promise<ReturnType>;
+    clearStore(): Promise<void>;
+    deleteAll(keys: (IndexKeys<Proto['dbType'], keyof Proto['dbType']> | Proto['dbType'])[]): Promise<Proto['dbType'][]>;
+    /**
+     * Delete by the uniqueKey of this collection - usually _id.
+     * Pass the _id of the item to delete.
+     */
+    delete(key: (IndexKeys<Proto['dbType'], keyof Proto['dbType']> | Proto['dbType'])): Promise<Proto['dbType']>;
+}
+export {};

package/core/IndexedDBV4/IndexedDB_Store.js

@@ -0,0 +1,207 @@
+import { Logger, MUSTNeverHappenException } from '@nu-art/ts-common';
+export class IndexedDB_Store extends Logger {
+    config;
+    storeResolver;
+    storeExistsResolver;
+    // ######################## Init ########################
+    constructor(config, storeResolver, storeExistsResolver) {
+        super(`IDB_Store-${config.group}`);
+        this.storeResolver = storeResolver;
+        this.storeExistsResolver = storeExistsResolver;
+        this.config = {
+            ...config,
+            autoIncrement: config.autoIncrement || false,
+            version: config.version
+        };
+    }
+    // ######################## DB Interaction ########################
+    getStore = async (write = false, store) => this.storeResolver(this.config, write, store);
+    exists = async () => this.storeExistsResolver(this.config);
+    count = async () => {
+        const store = await this.getStore();
+        return await new Promise((resolve, reject) => {
+            const countRequest = store.count();
+            countRequest.onsuccess = () => {
+                resolve(countRequest.result);
+            };
+            countRequest.onerror = () => {
+                this.logError(`Failed getting count of idb store ${this.config.name}`);
+                resolve(-1);
+            };
+        });
+    };
+    // ######################## Cursor Interaction ########################
+    getCursor = async (query) => {
+        const store = await this.getStore();
+        let cursorRequest;
+        if (query?.indexKey) {
+            const idbIndex = store.index(query.indexKey);
+            if (!idbIndex)
+                throw new MUSTNeverHappenException('Could not find index for the given indexKey');
+            cursorRequest = idbIndex.openCursor();
+        }
+        else
+            cursorRequest = store.openCursor();
+        return cursorRequest;
+    };
+    cursorHandler = (cursorRequest, perValueCallback, endCallback, limiterCallback) => {
+        cursorRequest.onsuccess = (event) => {
+            const cursor = event.target.result;
+            //If reached the end or reached limit, call endCallback
+            if (!cursor || limiterCallback?.())
+                return endCallback();
+            //run value through the value callback
+            perValueCallback(cursor.value);
+            //Continue to next value
+            cursor.continue();
+        };
+    };
+    // ######################### Data insertion functions #########################
+    async insert(value, _store) {
+        const store = await this.getStore(true, _store);
+        return new Promise((resolve, reject) => {
+            const request = store.add(value);
+            request.onerror = () => reject(new Error(`Error inserting item in DB - ${this.config.name}`));
+            request.onsuccess = () => resolve(request.result);
+        });
+    }
+    async insertAll(values, _store) {
+        const store = await this.getStore(true, _store);
+        for (const value of values) {
+            await this.insert(value, store);
+        }
+    }
+    async upsert(value, _store) {
+        const store = await this.getStore(true, _store);
+        try {
+            const request = store.put(value);
+            return new Promise((resolve, reject) => {
+                request.onerror = () => reject(new Error(`Error upserting item in DB - ${this.config.name}`));
+                request.onsuccess = () => resolve(request.result);
+            });
+        }
+        catch (e) {
+            this.logError('trying to upsert: ', value);
+            throw e;
+        }
+    }
+    async upsertAll(values, _store) {
+        const store = await this.getStore(true, _store);
+        for (const value of values) {
+            await this.upsert(value, store);
+        }
+    }
+    // ######################### Data collection functions #########################
+    async get(key) {
+        const map = this.config.uniqueKeys.map(k => key[k]);
+        const request = (await this.getStore()).get(map);
+        return new Promise((resolve, reject) => {
+            request.onerror = () => reject(new Error(`Error getting item from DB - ${this.config.name}`));
+            request.onsuccess = () => resolve(request.result);
+        });
+    }
+    async query(query) {
+        const store = await this.getStore();
+        return new Promise((resolve, reject) => {
+            let request;
+            if (query.indexKey)
+                request = store.index(query.indexKey).getAll(query.query, query.limit);
+            else
+                request = store.getAll(query.query, query.limit);
+            request.onsuccess = () => {
+                resolve(request.result);
+            };
+            request.onerror = () => {
+                reject(new Error(`Error querying DB - ${this.config.name}`));
+            };
+        });
+    }
+    async queryFilter(filter, query) {
+        const limit = query?.limit || 0;
+        const cursorRequest = await this.getCursor(query);
+        const matches = [];
+        return new Promise((resolve, reject) => {
+            this.cursorHandler(cursorRequest, (value) => {
+                if (filter(value))
+                    matches.push(value);
+            }, () => resolve(matches), () => limit > 0 && matches.length >= limit);
+        });
+    }
+    async WIP_queryMapNew(mapper, filter, query) {
+        const limit = query?.limit || 0;
+        const cursorRequest = await this.getCursor(query);
+        const matches = [];
+        return new Promise((resolve, reject) => {
+            this.cursorHandler(cursorRequest, (item) => {
+                if (filter ? filter(item) : true)
+                    matches.push(mapper(item));
+            }, () => resolve(matches), () => limit > 0 && matches.length >= limit);
+        });
+    }
+    async WIP_queryMap(mapper, filter, query) {
+        const limit = query?.limit || 0;
+        const cursorRequest = await this.getCursor(query);
+        const matches = [];
+        return new Promise((resolve, reject) => {
+            this.cursorHandler(cursorRequest, (item) => {
+                if (filter ? filter(item) : true)
+                    matches.push(mapper(item));
+            }, () => resolve(matches), () => limit > 0 && matches.length >= limit);
+        });
+    }
+    async queryFind(filter) {
+        let match = undefined;
+        const cursorRequest = await this.getCursor();
+        return new Promise((resolve, reject) => {
+            this.cursorHandler(cursorRequest, (value) => {
+                if (filter(value))
+                    match = value;
+            }, () => resolve(match), () => !!match);
+        });
+    }
+    async queryReduce(reducer, initialValue, filter, query) {
+        let acc = initialValue;
+        const alwaysTrue = () => true;
+        const _filter = filter || alwaysTrue;
+        const matches = await this.queryFilter(_filter, query);
+        return new Promise((resolve, reject) => {
+            matches.forEach((item, index) => acc = reducer(acc, item, index, matches));
+            resolve(acc);
+        });
+    }
+    // ######################### Data deletion functions #########################
+    async clearStore() {
+        if (!(await this.exists()))
+            return;
+        const store = await this.getStore(true);
+        return new Promise((resolve, reject) => {
+            const request = store.clear();
+            request.onsuccess = () => resolve();
+            request.onerror = reject;
+        });
+    }
+    async deleteAll(keys) {
+        return await Promise.all(keys.map(key => this.delete(key)));
+    }
+    /**
+     * Delete by the uniqueKey of this collection - usually _id.
+     * Pass the _id of the item to delete.
+     */
+    async delete(key) {
+        const keys = this.config.uniqueKeys.map(k => key[k]);
+        const store = await this.getStore(true);
+        return new Promise((resolve, reject) => {
+            const itemRequest = store.get(keys);
+            itemRequest.onerror = () => reject(new Error(`Error getting item in DB - ${this.config.name}`));
+            itemRequest.onsuccess = () => {
+                // @ts-ignore
+                if (key.__updated !== undefined && itemRequest.result?.__updated > key.__updated) {
+                    return resolve(itemRequest.result);
+                }
+                const deleteRequest = store.delete(keys);
+                deleteRequest.onerror = () => reject(new Error(`Error deleting item in DB - ${this.config.name}`));
+                deleteRequest.onsuccess = () => resolve(itemRequest.result);
+            };
+        });
+    }
+}

package/core/IndexedDBV4/ModuleFE_IDBManager.d.ts

@@ -0,0 +1,11 @@
+import { AsyncVoidFunction, DBProto, TypedMap } from '@nu-art/ts-common';
+import { IndexedDB_Database } from './IndexedDB_Database.js';
+import { DBConfigV3 } from './types.js';
+import { IndexedDB_Store } from './IndexedDB_Store.js';
+export declare class ModuleFE_IDBManager_Class {
+    databases: TypedMap<IndexedDB_Database>;
+    register<Proto extends DBProto<any>>(dbConfig: DBConfigV3<Proto>, onDBOpenCallback: AsyncVoidFunction): IndexedDB_Store<Proto>;
+    private storeResolver;
+    private storeExistsResolver;
+}
+export declare const ModuleFE_IDBManager: ModuleFE_IDBManager_Class;

package/core/IndexedDBV4/ModuleFE_IDBManager.js

@@ -0,0 +1,19 @@
+import { IndexedDB_Database } from './IndexedDB_Database.js';
+import { IndexedDB_Store } from './IndexedDB_Store.js';
+export class ModuleFE_IDBManager_Class {
+    databases = {};
+    register(dbConfig, onDBOpenCallback) {
+        const indexDb = this.databases[dbConfig.group] || (this.databases[dbConfig.group] = new IndexedDB_Database(dbConfig.group));
+        indexDb.registerStore(dbConfig, onDBOpenCallback);
+        return new IndexedDB_Store(dbConfig, this.storeResolver, this.storeExistsResolver);
+    }
+    storeResolver = async (dbConfig, write = false, store) => {
+        const dbWrapper = this.databases[dbConfig.group];
+        return dbWrapper.getStore(dbConfig, write, store);
+    };
+    storeExistsResolver = async (dbConfig) => {
+        const dbWrapper = this.databases[dbConfig.group];
+        return await dbWrapper.storeExists(dbConfig.name);
+    };
+}
+export const ModuleFE_IDBManager = new ModuleFE_IDBManager_Class();

package/core/IndexedDBV4/types.d.ts

@@ -0,0 +1,16 @@
+import { DBIndex, DBProto } from '@nu-art/ts-common';
+export type ReduceFunction_V3<ItemType, ReturnType> = (accumulator: ReturnType, arrayItem: ItemType, index?: number, array?: ItemType[]) => ReturnType;
+export type DBConfigV3<Proto extends DBProto<any>> = {
+    name: string;
+    group: string;
+    version: string;
+    autoIncrement?: boolean;
+    uniqueKeys: (keyof Proto['dbType'])[];
+    indices?: DBIndex<Proto['dbType']>[];
+    upgradeProcessor?: (store: IDBObjectStore) => void;
+};
+export type IndexDb_Query_V3 = {
+    query?: string | number | string[] | number[];
+    indexKey?: string;
+    limit?: number;
+};

package/core/IndexedDBV4/types.js

@@ -0,0 +1 @@
+export {};

package/core/SimpleScriptInjector.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+type Props = {
+    src: string;
+    onLoaded: (src: string) => void;
+};
+export declare class SimpleScriptInjector extends React.Component<Props> {
+    static readonly injected: {
+        [src: string]: HTMLScriptElement;
+    };
+    componentDidMount(): void;
+    render(): string;
+}
+export {};

package/core/SimpleScriptInjector.js

@@ -0,0 +1,42 @@
+/*
+ * 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 * as React from 'react';
+import { _setTimeout } from '@nu-art/ts-common';
+export class SimpleScriptInjector extends React.Component {
+    static injected = {};
+    componentDidMount() {
+        if (SimpleScriptInjector.injected[this.props.src]) {
+            _setTimeout(() => this.props.onLoaded(this.props.src));
+            return;
+        }
+        const script = document.createElement('script');
+        script.type = 'text/javascript';
+        script.src = this.props.src;
+        script.async = true;
+        script.id = this.props.src;
+        script.onload = () => this.props.onLoaded(this.props.src);
+        document.body.appendChild(script);
+        SimpleScriptInjector.injected[this.props.src] = script;
+    }
+    render() {
+        return '';
+    }
+}

package/core/Thunder.d.ts

@@ -0,0 +1,37 @@
+import * as React from 'react';
+import { AsyncVoidFunction, ModuleManager } from '@nu-art/ts-common';
+import '../styles/impl/basic.scss';
+import '../styles/impl/icons.scss';
+import { ThunderAppWrapperProps } from './types.js';
+import { StorageKey } from '../modules/ModuleFE_LocalStorage.js';
+export declare const Storage_AppVersion: StorageKey<string>;
+export type ThunderConfig = {
+    defaultConfigUrl?: string;
+    configUrl: string;
+};
+export declare class Thunder extends ModuleManager {
+    private listeners;
+    private renderFunc;
+    private props;
+    private preBuildActions;
+    readonly innerConfig: Readonly<ThunderConfig>;
+    constructor(config: ThunderConfig);
+    static getInstance(): Thunder;
+    init(): this;
+    private fetchConfig;
+    protected addUIListener(listener: any): void;
+    protected removeUIListener(listener: any): void;
+    /**
+     * Set up the entry point for the app.
+     * @param mainApp - The entry point into the application, what will be rendered directly under root (usually App.tsx)
+     * @param props - The props to go with the supplied main app
+     * @param renderFunc - The app wrapper, which will usually provide a router. by default is "appWithJSX" which will just return the app
+     */
+    setMainApp<P extends {}>(mainApp: React.ElementType<P>, props?: P, renderFunc?: (props: ThunderAppWrapperProps) => React.ReactElement): Thunder;
+    build(onStarted?: () => void): void;
+    setVersion(version: string): this;
+    getConfig(): any;
+    addPreBuildAction: (func: AsyncVoidFunction) => this;
+    logStuff: () => void;
+    getEnvironment(): string;
+}