taon-storage 21.0.8 → 21.0.11

package/browser/fesm2022/taon-storage-browser.mjs

@@ -1,8 +1,7 @@
 import * as i0 from '@angular/core';
 import { ChangeDetectionStrategy, Component } from '@angular/core';
 import { CommonModule } from '@angular/common';
-import * as localForge from 'localforage';
-import { Helpers, _ } from 'tnp-core/browser';
+import { _, UtilsOs } from 'tnp-core/browser';
 
 class SampleLogCmpComponent {
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: SampleLogCmpComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
@@ -13,284 +12,498 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImpor
             args: [{ selector: 'sample-log-cmp', changeDetection: ChangeDetectionStrategy.OnPush, imports: [CommonModule], standalone: true, template: "<p>\n  sample log component works!\n  <img\n    src=\"assets/assets-for/taon-storage/assets/shared/logo.png\"\n    alt=\"logo\" height=\"200\" />\n</p>", styles: [":host{display:block}\n"] }]
         }] });
 
-const keyValue = (classFun, memberName) => {
-    // console.log('classname',classFun.name)
-    const res = `taon.localstorage.class.${classFun.name}.prop.${memberName}`;
-    return res;
-};
-const keyDefaultValueAreadySet = (classFun, memberName) => {
-    const res = keyValue(classFun, memberName) + 'defaultvalueisset';
-    return res;
+/* taon-storage (native, SSR-safe) */
+const isBrowser = typeof window !== 'undefined' &&
+    typeof document !== 'undefined' &&
+    typeof navigator !== 'undefined';
+function getGlobalEnv() {
+    return globalThis?.ENV;
+}
+function safeLocationPort() {
+    try {
+        return globalThis?.location?.port || 'no-port';
+    }
+    catch {
+        return 'no-port';
+    }
+}
+/**
+ * Keeps the spirit of your old `storeName = taon-storage_<port>`
+ * plus project name namespacing (but without localForage).
+ */
+const storeName = `taon-storage_${safeLocationPort()}`;
+function defaultNamespace() {
+    const env = getGlobalEnv();
+    const project = _.kebabCase(env?.currentProjectGenericName ?? '');
+    return project ? `${storeName}_${project}` : storeName;
+}
+/**
+ * Central config (optional).
+ * You can set it once at app bootstrap if you want a stable namespace.
+ */
+const StorConfig = {
+    namespace: defaultNamespace(),
+    indexedDb: {
+        dbName: `${defaultNamespace()}_INDEXEDDB`,
+        storeName: 'keyvaluepairs',
+    },
 };
-
-//#region imports
-//#endregion
-//#region constants / store name
-let win;
-if (typeof window !== 'undefined') {
-    win = window;
+function normalizeScopeClass(cls) {
+    if (!cls)
+        return { name: '__GLOBAL_NAMESPACE__' };
+    // if it's a function/class
+    if (typeof cls === 'function')
+        return { name: cls.name || '__ANON__' };
+    // if it's already object with name
+    return { name: cls.name || '__ANON__' };
 }
-win = win || globalThis;
-const storeName = 'taon-storage_' + win?.location?.port;
-//#endregion
-let environment = globalThis['ENV'];
-//#region constant / stor local storage
-const websql = Helpers.isWebSQL ? 'websql' : '';
-//#region @browser
-const storLocalStorage = localForge.createInstance({
-    driver: localForge.LOCALSTORAGE,
-    storeName: [
-        storeName,
-        'LOCALSTORAGE',
-        _.kebabCase(environment?.currentProjectGenericName) + websql,
-    ].join('_'), // + _.kebabCase(window.location.origin),
-}); // TODO UNCOMMENT any
-//#endregion
-//#endregion
-//#region constant / stor idndexedb storage
-//#region @browser
-const storIndexdDb = localForge.createInstance({
-    driver: localForge.INDEXEDDB,
-    storeName: [
-        storeName,
-        'INDEXEDDB',
-        _.kebabCase(environment?.currentProjectGenericName) + websql,
-    ].join('_'),
-}); // TODO UNCOMMENT any
-//#endregion
-//#endregion
-
-//#endregion
-//#endregion
-//#region constants
-const AWAITING_INTERVAL_TIME = 200;
-//#endregion
-//#region public api / uncahce
-function uncache(onlyInThisComponentClass, propertyValueToDeleteFromCache) {
-    if (!onlyInThisComponentClass) { // @ts-ignore
-        onlyInThisComponentClass = { name: '__GLOBAL_NAMESPACE__' };
-    }
-    return Promise.all([
-        //#region @browser
-        storLocalStorage.removeItem(keyValue(onlyInThisComponentClass, propertyValueToDeleteFromCache)),
-        storLocalStorage.removeItem(keyDefaultValueAreadySet(onlyInThisComponentClass, propertyValueToDeleteFromCache)),
-        storIndexdDb.removeItem(keyValue(onlyInThisComponentClass, propertyValueToDeleteFromCache)),
-        storIndexdDb.removeItem(keyDefaultValueAreadySet(onlyInThisComponentClass, propertyValueToDeleteFromCache)),
-        //#endregion
-    ]);
+function keyValue(scopeClass, memberName) {
+    const c = normalizeScopeClass(scopeClass);
+    return `${StorConfig.namespace}::taon.storage.class.${c.name}.prop.${memberName}`;
 }
-//#endregion
-class TaonStorage {
-    constructor() {
-        //#endregion
-        //#region private methods / action
-        this.action = (defaultValue, storageEngine
-        //#endregion
-        , engine, transformFrom, transformTo) => {
-            if (!this.onlyInThisComponentClass) { // @ts-ignore
-                this.onlyInThisComponentClass = { name: '__GLOBAL_NAMESPACE__' };
+function keyDefaultValueAlreadySet(scopeClass, memberName) {
+    return `${keyValue(scopeClass, memberName)}::defaultvalueisset`;
+}
+/** Back-compat alias (your old typo) */
+const keyDefaultValueAreadySet = keyDefaultValueAlreadySet;
+class NoopStore {
+    async getItem(_key) {
+        return undefined;
+    }
+    async setItem(_key, _value) {
+        // noop
+    }
+    async removeItem(_key) {
+        // noop
+    }
+}
+class BrowserLocalStorageStore {
+    ls() {
+        if (!isBrowser)
+            return undefined;
+        try {
+            return window.localStorage;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async getItem(key) {
+        const ls = this.ls();
+        if (!ls)
+            return undefined;
+        const raw = ls.getItem(key);
+        if (raw === null)
+            return undefined;
+        try {
+            return JSON.parse(raw);
+        }
+        catch {
+            // if something stored plain string by older versions
+            return raw;
+        }
+    }
+    async setItem(key, value) {
+        const ls = this.ls();
+        if (!ls)
+            return;
+        try {
+            ls.setItem(key, JSON.stringify(value));
+        }
+        catch {
+            // last resort: try as string
+            try {
+                ls.setItem(key, String(value));
             }
-            return (target, memberName) => {
-                let currentValue = target[memberName];
-                const setItemDefaultValue = async () => {
-                    //#region settin default value
-                    const observe = {
-                        engine,
-                        id: 'setting default value'
-                    };
-                    TaonStorage.pendingOperatins.push(observe);
-                    await new Promise((resolve, reject) => {
-                        storageEngine.getItem(keyValue(this.onlyInThisComponentClass, memberName), (err, valFromDb) => {
-                            // target[memberName] = valFromDb;
-                            currentValue = transformFrom ? transformFrom(valFromDb) : valFromDb;
-                            // log.info(`["${memberName}"] set default value for `, valFromDb);
-                            resolve();
-                            this.endObserverAction(observe);
-                        });
-                    });
-                    //#endregion
-                };
-                if (defaultValue !== void 0) {
-                    //#region setting default value from db
-                    const observe = {
-                        engine,
-                        id: 'setting not rivial default value'
-                    };
-                    TaonStorage.pendingOperatins.push(observe);
-                    (new Promise((resolve, reject) => {
-                        storageEngine.getItem(keyDefaultValueAreadySet(this.onlyInThisComponentClass, memberName), async (err, val) => {
-                            // log.info(`["${memberName}"] was set default value for  ? `, val)
-                            if (val) {
-                                await setItemDefaultValue();
-                                resolve();
-                            }
-                            else {
-                                await new Promise((res, rej) => {
-                                    storageEngine.setItem(keyDefaultValueAreadySet(this.onlyInThisComponentClass, memberName), true, (err, v) => {
-                                        res();
-                                    });
-                                });
-                                await new Promise((res, rej) => {
-                                    storageEngine.setItem(keyValue(this.onlyInThisComponentClass, memberName), transformTo ? transformTo(defaultValue) : defaultValue, (err, val) => {
-                                        res();
-                                    });
-                                });
-                                currentValue = defaultValue;
-                                // log.i(`["${memberName}"]  defaultValue "${memberName}"`, currentValue)
-                                resolve();
-                            }
-                        });
-                    })).then(() => {
-                        this.endObserverAction(observe);
-                    });
-                    //#endregion
-                }
-                else {
-                    setItemDefaultValue();
+            catch {
+                // ignore (quota/private mode)
+            }
+        }
+    }
+    async removeItem(key) {
+        const ls = this.ls();
+        if (!ls)
+            return;
+        try {
+            ls.removeItem(key);
+        }
+        catch {
+            // ignore
+        }
+    }
+}
+class BrowserIndexedDbStore {
+    constructor() {
+        this.dbPromise = null;
+    }
+    openDb() {
+        if (!isBrowser || !window.indexedDB) {
+            return Promise.reject(new Error('IndexedDB not available'));
+        }
+        if (this.dbPromise)
+            return this.dbPromise;
+        const { dbName, storeName } = StorConfig.indexedDb;
+        this.dbPromise = new Promise((resolve, reject) => {
+            const req = indexedDB.open(dbName, 1);
+            req.onupgradeneeded = () => {
+                const db = req.result;
+                if (!db.objectStoreNames.contains(storeName)) {
+                    db.createObjectStore(storeName);
                 }
-                Object.defineProperty(target, memberName, {
-                    set: (newValue) => {
-                        //#region setting new value on setter
-                        const observe = {
-                            engine,
-                            id: 'setting in SET not rivial default value'
-                        };
-                        TaonStorage.pendingOperatins.push(observe);
-                        (new Promise((resolve, reject) => {
-                            storageEngine.setItem(keyValue(this.onlyInThisComponentClass, memberName), transformTo ? transformTo(newValue) : newValue, (err, savedValue) => {
-                                resolve();
-                            });
-                        })).then(() => {
-                            this.endObserverAction(observe);
-                        });
-                        //#endregion
-                        currentValue = newValue;
-                    },
-                    get: () => currentValue,
-                });
             };
-        };
-        //#endregion
-        //#endregion
+            req.onsuccess = () => resolve(req.result);
+            req.onerror = () => reject(req.error);
+        });
+        return this.dbPromise;
+    }
+    async withStore(mode, fn) {
+        const db = await this.openDb();
+        const { storeName } = StorConfig.indexedDb;
+        return await new Promise((resolve, reject) => {
+            const tx = db.transaction(storeName, mode);
+            const store = tx.objectStore(storeName);
+            const req = fn(store);
+            req.onsuccess = () => resolve(req.result);
+            req.onerror = () => reject(req.error);
+            tx.onabort = () => reject(tx.error);
+            // tx.oncomplete => nothing
+        });
     }
-    //#region static
-    static { this.pendingOperatins = []; }
+    async getItem(key) {
+        try {
+            const result = await this.withStore('readonly', s => s.get(key));
+            return result === undefined ? undefined : result;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async setItem(key, value) {
+        try {
+            await this.withStore('readwrite', s => s.put(value, key));
+        }
+        catch {
+            // ignore
+        }
+    }
+    async removeItem(key) {
+        try {
+            await this.withStore('readwrite', s => s.delete(key));
+        }
+        catch {
+            // ignore
+        }
+    }
+}
+/**
+ * Node-side file storage (optional). No top-level node imports (Angular-safe).
+ * Works only when executed in Node.
+ */
+class FileStor {
+    constructor(filePath, useJSON = false) {
+        this.filePath = filePath;
+        this.useJSON = useJSON;
+    }
+    isNodeRuntime() {
+        return UtilsOs.isNode;
+        // return (
+        //   typeof process !== 'undefined' &&
+        //   !!(process as any).versions?.node &&
+        //   typeof (globalThis as any).window === 'undefined'
+        // );
+    }
+    async setItem(_key, value) {
+        if (!this.isNodeRuntime())
+            return;
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    async getItem(_key) {
+        if (!this.isNodeRuntime())
+            return undefined;
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    async removeItem(_key) {
+        if (!this.isNodeRuntime())
+            return;
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+}
+/* ---------------------------
+ * Pending ops (so you can still await)
+ * -------------------------- */
+class StorPending {
+    static { this.pending = []; }
     static { this.id = 0; }
-    /**
-     * TODO This is fine for now, but could be something smarter here
-     */
-    static async awaitPendingOperatios(id = TaonStorage.id++) {
-        // console.log('AWAITING')
+    static { this.AWAITING_INTERVAL_TIME = 200; }
+    static async awaitPendingOperations(id = StorPending.id++) {
         if (id > Number.MAX_SAFE_INTEGER - 2) {
-            TaonStorage.id = 0;
-            id = TaonStorage.id++;
+            StorPending.id = 0;
+            id = StorPending.id++;
         }
-        const pending = this.pendingOperatins;
-        const toDeleteIndex = [];
-        for (let index = 0; index < pending.length; index++) {
-            const op = pending[index];
+        const pending = StorPending.pending;
+        for (const op of pending) {
             if (!op.isDone) {
-                await new Promise(async (resovle, reject) => {
+                await new Promise(resolve => {
                     setTimeout(async () => {
-                        await this.awaitPendingOperatios(id);
-                        resovle();
-                    }, AWAITING_INTERVAL_TIME);
+                        await StorPending.awaitPendingOperations(id);
+                        resolve();
+                    }, StorPending.AWAITING_INTERVAL_TIME);
                 });
                 return;
             }
-            else {
-                toDeleteIndex.push(index);
-            }
-        }
-        for (let index = 0; index < toDeleteIndex.length; index++) {
-            const toDelete = toDeleteIndex[index];
-            pending.splice(toDelete, 1);
         }
+        // cleanup
+        StorPending.pending = pending.filter(p => !p.isDone);
     }
-    static get property() {
-        return new TaonStorage();
-    }
-    //#region private fields / file path
-    /* */
-    /* */
-    //#endregion
-    //#endregion
-    //#region public getters
-    get in() {
-        const that = this;
-        return {
-            get indexedb() {
-                that.engine = 'indexeddb';
-                return that;
-            },
-            get localstorage() {
-                that.engine = 'localstorage';
-                return that;
-            },
-            /* */
-            /* */
-            /* */
-            /* */
-            /* */
-            /* */
-            /* */
-            /* */
-            /* */
-            /* */
-            /* */
-            /* */
-            /* */
-            /* */
-        };
+    static start(engine, id) {
+        const op = { engine, id, isDone: false };
+        StorPending.pending.push(op);
+        return op;
+    }
+    static done(op) {
+        op.isDone = true;
     }
-    //#endregion
-    //#region public methods
-    //#region public methods  / for
-    //#region @browser
-    for(onlyInThisComponentClass) {
-        this.onlyInThisComponentClass = onlyInThisComponentClass;
+}
+/* ---------------------------
+ * Decorator builder
+ * -------------------------- */
+class StorPropertyBuilder {
+    constructor(engine, store) {
+        this.useJsonFile = false;
+        this.engine = engine;
+        this.store = store;
+    }
+    for(scopeClass) {
+        this.scopeClass = scopeClass;
         return this;
     }
-    //#endregion
-    //#endregion
-    //#region public methods  / with default value
     withDefaultValue(defaultValue) {
-        // log.i(`["${}"]`)
-        return this.action(defaultValue, this.getEngine(), this.engine);
+        return this.withOptions({ defaultValue });
     }
-    //#endregion
-    //#region public methods / with options
     withOptions(options) {
-        const { defaultValue, transformFrom, transformTo } = (options || {});
-        return this.action(defaultValue ? defaultValue : this.defaultValue, this.getEngine(), this.engine, transformFrom, transformTo);
-    }
-    //#endregion
-    //#endregion
-    //#region private methods
-    //#region private methods / get engine
-    getEngine() {
-        switch (this.engine) {
-            //#region @browser
-            case 'localstorage':
-                return storLocalStorage;
-            case 'indexeddb':
-                return storIndexdDb;
-            //#endregion
-            /* */
-            /* */
-            /* */
-            /* */
-            /* */
-        }
+        const scopeClass = this.scopeClass;
+        // per-instance state (fixes prototype-closure sharing)
+        const values = new WeakMap();
+        const initStarted = new WeakMap();
+        const ensureInit = (instance) => {
+            if (initStarted.has(instance))
+                return;
+            const op = StorPending.start(this.engine, 'init');
+            const p = (async () => {
+                const memberName = ensureInit.__memberName;
+                const kVal = keyValue(scopeClass, memberName);
+                const kDef = keyDefaultValueAlreadySet(scopeClass, memberName);
+                const defProvided = options.defaultValue !== undefined;
+                if (!isBrowser &&
+                    (this.engine === 'localstorage' || this.engine === 'indexeddb')) {
+                    // SSR: just set defaults, no storage
+                    if (defProvided)
+                        values.set(instance, options.defaultValue);
+                    return;
+                }
+                // Browser (or node file/json)
+                if (defProvided) {
+                    const already = await this.store.getItem(kDef);
+                    if (already) {
+                        const stored = await this.store.getItem(kVal);
+                        const v = options.transformFrom
+                            ? options.transformFrom(stored)
+                            : stored;
+                        if (v !== undefined)
+                            values.set(instance, v);
+                        else
+                            values.set(instance, options.defaultValue);
+                    }
+                    else {
+                        await this.store.setItem(kDef, true);
+                        const toDb = options.transformTo
+                            ? options.transformTo(options.defaultValue)
+                            : options.defaultValue;
+                        await this.store.setItem(kVal, toDb);
+                        values.set(instance, options.defaultValue);
+                    }
+                }
+                else {
+                    const stored = await this.store.getItem(kVal);
+                    const v = options.transformFrom
+                        ? options.transformFrom(stored)
+                        : stored;
+                    if (v !== undefined)
+                        values.set(instance, v);
+                }
+            })()
+                .catch(() => {
+                // swallow, keep app alive
+            })
+                .finally(() => StorPending.done(op));
+            initStarted.set(instance, p);
+        };
+        return (target, memberName) => {
+            ensureInit.__memberName = memberName;
+            Object.defineProperty(target, memberName, {
+                configurable: true,
+                enumerable: true,
+                get: function () {
+                    ensureInit(this);
+                    if (values.has(this))
+                        return values.get(this);
+                    if (options.defaultValue !== undefined)
+                        return options.defaultValue;
+                    return undefined;
+                },
+                set: function (newValue) {
+                    values.set(this, newValue);
+                    // if this is the first interaction, init will happen anyway
+                    ensureInit(this);
+                    const op = StorPending.start(target?.engine ?? 'localstorage', 'set');
+                    const scope = scopeClass;
+                    const kVal = keyValue(scope, memberName);
+                    const toDb = options.transformTo
+                        ? options.transformTo(newValue)
+                        : newValue;
+                    Promise.resolve()
+                        .then(() => target)
+                        .then(() => this)
+                        .then(() => this)
+                        .then(async () => {
+                        // If we are SSR + browser engine => no-op
+                        if (!isBrowser && options)
+                            return;
+                        await options; // no-op line to keep TS happy about chaining in some builds
+                    })
+                        .catch(() => {
+                        // ignore
+                    });
+                    // do real store write (async)
+                    Promise.resolve()
+                        .then(async () => {
+                        // SSR guard for browser engines
+                        if (!isBrowser && StorPropertyInLocalStorage) {
+                            return;
+                        }
+                        await thisStoreForEngineWrite(this, kVal, toDb);
+                    })
+                        .catch(() => {
+                        // ignore
+                    })
+                        .finally(() => StorPending.done(op));
+                },
+            });
+            // small helper to keep closure clean
+            const builderStore = this.store;
+            const builderEngine = this.engine;
+            async function thisStoreForEngineWrite(_instance, key, value) {
+                // If browser engines but not browser, skip.
+                if (!isBrowser &&
+                    (builderEngine === 'localstorage' || builderEngine === 'indexeddb'))
+                    return;
+                await builderStore.setItem(key, value);
+            }
+        };
+    }
+    /* optional node-only engines (same builder) */
+    file(filePath) {
+        this.engine = 'file';
+        this.filePath = filePath;
+        this.useJsonFile = false;
+        this.store = new FileStor(filePath, false);
+        return this;
+    }
+    jsonFile(filePath) {
+        this.engine = 'json';
+        this.filePath = filePath;
+        this.useJsonFile = true;
+        this.store = new FileStor(filePath, true);
+        return this;
+    }
+}
+/* ---------------------------
+ * Public: clean API exports
+ * -------------------------- */
+const localStorageStore = isBrowser
+    ? new BrowserLocalStorageStore()
+    : new NoopStore();
+const indexedDbStore = isBrowser
+    ? new BrowserIndexedDbStore()
+    : new NoopStore();
+class StorPropertyInLocalStorage {
+    static for(scopeClass) {
+        return new StorPropertyBuilder('localstorage', localStorageStore).for(scopeClass);
+    }
+}
+class StorPropertyInIndexedDb {
+    static for(scopeClass) {
+        return new StorPropertyBuilder('indexeddb', indexedDbStore).for(scopeClass);
     }
-    //#endregion
-    //#region private methods / end observer action
-    endObserverAction(observe) {
-        // observe.subscribers.forEach(c => typeof c?.awaitId === 'function' && c());
-        observe.isDone = true;
+}
+/**
+ * Helpers
+ */
+async function uncache(onlyInThisComponentClass, propertyValueToDeleteFromCache) {
+    const scope = onlyInThisComponentClass || { name: '__GLOBAL_NAMESPACE__' };
+    const prop = String(propertyValueToDeleteFromCache);
+    await Promise.all([
+        localStorageStore.removeItem(keyValue(scope, prop)),
+        localStorageStore.removeItem(keyDefaultValueAlreadySet(scope, prop)),
+        indexedDbStore.removeItem(keyValue(scope, prop)),
+        indexedDbStore.removeItem(keyDefaultValueAlreadySet(scope, prop)),
+    ]);
+}
+/**
+ * Backwards-compatible facade:
+ * Stor.property.in.localstorage.for(...).withDefaultValue(...)
+ */
+class TaonStorageFacade {
+    static async awaitPendingOperatios() {
+        await StorPending.awaitPendingOperations();
+    }
+    static get property() {
+        return {
+            in: {
+                get localstorage() {
+                    return new StorPropertyBuilder('localstorage', localStorageStore);
+                },
+                get indexedb() {
+                    return new StorPropertyBuilder('indexeddb', indexedDbStore);
+                },
+                // node-only (safe: dynamic import inside FileStor)
+                file(filePath) {
+                    return new StorPropertyBuilder('file', new FileStor(filePath, false));
+                },
+                jsonFile(filePath) {
+                    return new StorPropertyBuilder('json', new FileStor(filePath, true));
+                },
+            },
+        };
     }
 }
-const Stor = TaonStorage;
+const Stor = TaonStorageFacade;
 
 //#region @browser
 
@@ -298,5 +511,5 @@ const Stor = TaonStorage;
  * Generated bundle index. Do not edit.
  */
 
-export { SampleLogCmpComponent, Stor, uncache };
+export { SampleLogCmpComponent, Stor, StorConfig, StorPropertyInIndexedDb, StorPropertyInLocalStorage, keyDefaultValueAlreadySet, keyDefaultValueAreadySet, keyValue, storeName, uncache };
 //# sourceMappingURL=taon-storage-browser.mjs.map