taon-storage 21.0.27 → 21.0.30

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

@@ -1,42 +1,21 @@
-import * as i0 from '@angular/core';
-import { ChangeDetectionStrategy, Component } from '@angular/core';
-import { CommonModule } from '@angular/common';
-import { _, UtilsOs } from 'tnp-core/browser';
+import { signal } from '@angular/core';
+import { UtilsOs, _ } from 'tnp-core/browser';
 
-class SampleLogCmpComponent {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.9", ngImport: i0, type: SampleLogCmpComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.0.9", type: SampleLogCmpComponent, isStandalone: true, selector: "sample-log-cmp", ngImport: i0, 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"], dependencies: [{ kind: "ngmodule", type: CommonModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.9", ngImport: i0, type: SampleLogCmpComponent, decorators: [{
-            type: Component,
-            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"] }]
-        }] });
-
-/* taon-storage (native, SSR-safe) */
-const isBrowser = typeof window !== 'undefined' &&
-    typeof document !== 'undefined' &&
-    typeof navigator !== 'undefined';
-function safeLocationPort() {
+const isBrowser = UtilsOs.isBrowser;
+const isNode = UtilsOs.isNode;
+const 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 defaultNamespace = () => {
     const project = _.kebabCase(globalThis['CURRENT_PROJECT_GENERIC_NAME'] ?? '');
     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: {
@@ -44,7 +23,7 @@ const StorConfig = {
         storeName: 'keyvaluepairs',
     },
 };
-function normalizeScopeClass(cls) {
+const normalizeScopeClass = (cls) => {
     if (!cls)
         return { name: '__GLOBAL_NAMESPACE__' };
     // if it's a function/class
@@ -52,83 +31,70 @@ function normalizeScopeClass(cls) {
         return { name: cls.name || '__ANON__' };
     // if it's already object with name
     return { name: cls.name || '__ANON__' };
-}
-function keyValue(scopeClass, memberName) {
+};
+const keyValue = (scopeClass, memberName) => {
     const c = normalizeScopeClass(scopeClass);
     return `${StorConfig.namespace}::taon.storage.class.${c.name}.prop.${memberName}`;
-}
-function keyDefaultValueAlreadySet(scopeClass, memberName) {
+};
+const 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() {
+};
+//#region local storage
+class LocalStorageStore {
+    async getItem(key) {
         if (!isBrowser)
             return undefined;
+        const raw = localStorage.getItem(key);
+        if (raw == null)
+            return undefined;
         try {
-            return window.localStorage;
+            return JSON.parse(raw);
         }
         catch {
-            return undefined;
+            return raw;
         }
     }
+    async setItem(key, value) {
+        if (!isBrowser)
+            return;
+        localStorage.setItem(key, JSON.stringify(value));
+    }
+    async removeItem(key) {
+        if (!isBrowser)
+            return;
+        localStorage.removeItem(key);
+    }
+}
+//#endregion
+//#region session storage
+class SessionStorageStore extends LocalStorageStore {
     async getItem(key) {
-        const ls = this.ls();
-        if (!ls)
+        if (!isBrowser)
             return undefined;
-        const raw = ls.getItem(key);
-        if (raw === null)
+        const raw = sessionStorage.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)
+        if (!isBrowser)
             return;
-        try {
-            ls.setItem(key, JSON.stringify(value));
-        }
-        catch {
-            // last resort: try as string
-            try {
-                ls.setItem(key, String(value));
-            }
-            catch {
-                // ignore (quota/private mode)
-            }
-        }
+        sessionStorage.setItem(key, JSON.stringify(value));
     }
     async removeItem(key) {
-        const ls = this.ls();
-        if (!ls)
+        if (!isBrowser)
             return;
-        try {
-            ls.removeItem(key);
-        }
-        catch {
-            // ignore
-        }
+        sessionStorage.removeItem(key);
     }
 }
-class BrowserIndexedDbStore {
+//#endregion
+//#region indexed db store
+class IndexedDbStore {
     constructor() {
         this.dbPromise = null;
     }
@@ -191,10 +157,8 @@ class BrowserIndexedDbStore {
         }
     }
 }
-/**
- * Node-side file storage (optional). No top-level node imports (Angular-safe).
- * Works only when executed in Node.
- */
+//#endregion
+//#region file stor
 class FileStor {
     constructor(filePath, useJSON = false) {
         this.filePath = filePath;
@@ -202,11 +166,6 @@ class FileStor {
     }
     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())
@@ -250,262 +209,123 @@ class FileStor {
         return (void 0);
     }
 }
-/* ---------------------------
- * Pending ops (so you can still await)
- * -------------------------- */
-class StorPending {
-    static { this.pending = []; }
-    static { this.id = 0; }
-    static { this.AWAITING_INTERVAL_TIME = 200; }
-    static async awaitPendingOperations(id = StorPending.id++) {
-        if (id > Number.MAX_SAFE_INTEGER - 2) {
-            StorPending.id = 0;
-            id = StorPending.id++;
+//#endregion
+// --- global registry
+const ALL_READY = [];
+function createStorSignal(key, store, options) {
+    const hasDefault = options.defaultValue !== undefined;
+    const s = signal(options.defaultValue, ...(ngDevMode ? [{ debugName: "s" }] : []));
+    const readyPromise = (async () => {
+        // SSR: just use default
+        if (!isBrowser && !isNode) {
+            return;
         }
-        const pending = StorPending.pending;
-        for (const op of pending) {
-            if (!op.isDone) {
-                await new Promise(resolve => {
-                    setTimeout(async () => {
-                        await StorPending.awaitPendingOperations(id);
-                        resolve();
-                    }, StorPending.AWAITING_INTERVAL_TIME);
-                });
-                return;
-            }
+        const stored = await store.getItem(key);
+        if (stored !== undefined) {
+            const v = options.transformFrom ? options.transformFrom(stored) : stored;
+            s.set(v);
         }
-        // cleanup
-        StorPending.pending = pending.filter(p => !p.isDone);
-    }
-    static start(engine, id) {
-        const op = { engine, id, isDone: false };
-        StorPending.pending.push(op);
-        return op;
-    }
-    static done(op) {
-        op.isDone = true;
-    }
+        else if (hasDefault) {
+            const toDb = options.transformTo
+                ? options.transformTo(options.defaultValue)
+                : options.defaultValue;
+            await store.setItem(key, toDb);
+            s.set(options.defaultValue);
+        }
+    })();
+    ALL_READY.push(readyPromise);
+    const fn = (() => s());
+    fn.signal = s;
+    fn.set = async (v) => {
+        s.set(v);
+        const toDb = options.transformTo ? options.transformTo(v) : v;
+        await store.setItem(key, toDb);
+    };
+    fn.ready = () => readyPromise;
+    return fn;
 }
-/* ---------------------------
- * Decorator builder
- * -------------------------- */
-class StorPropertyBuilder {
-    constructor(engine, store) {
-        this.useJsonFile = false;
-        this.engine = engine;
-        this.store = store;
-    }
-    for(scopeClass) {
-        this.scopeClass = scopeClass;
-        return this;
-    }
-    withDefaultValue(defaultValue) {
-        return this.withOptions({ defaultValue });
-    }
-    withOptions(options) {
-        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;
+//#endregion
+const create = (engine, scopeClass, memberName, options) => {
+    const key = keyValue(scopeClass, memberName);
+    return createStorSignal(key, engine, options);
+};
+const local = new LocalStorageStore();
+const session = new SessionStorageStore();
+const indexedDBInstace = new IndexedDbStore();
+//#region API
+var TaonStor;
+(function (TaonStor) {
+    function inLocalstorage(options, scopeClass) {
+        return create(local, scopeClass, options.keyOrPath ?? '__global__', options);
+    }
+    TaonStor.inLocalstorage = inLocalstorage;
+    function inSessionStorage(options, scopeClass) {
+        return create(session, scopeClass, options.keyOrPath ?? '__global__', options);
+    }
+    TaonStor.inSessionStorage = inSessionStorage;
+    function inIndexedDbStorage(options, scopeClass) {
+        return create(indexedDBInstace, scopeClass, options.keyOrPath ?? '__global__', options);
+    }
+    TaonStor.inIndexedDbStorage = inIndexedDbStorage;
+    function inFile(options, scopeClass) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
     }
-}
-/* ---------------------------
- * 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);
+    TaonStor.inFile = inFile;
+    function inJson(options, scopeClass) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
     }
-}
-class StorPropertyInIndexedDb {
-    static for(scopeClass) {
-        return new StorPropertyBuilder('indexeddb', indexedDbStore).for(scopeClass);
+    TaonStor.inJson = inJson;
+    async function awaitAll() {
+        await Promise.all(ALL_READY);
     }
-}
+    TaonStor.awaitAll = awaitAll;
+})(TaonStor || (TaonStor = {}));
+//#endregion
 /**
- * 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(...)
+ * exampel useage
+ *
+ * class SomeAngularComponentOrWhatever {
+ *
+ *  positionX = TaonStor.inLocalstorage({
+ *     defaultValue: 0
+ *  });
+ *
+ *  async ngOnInit() {
+ *    console.log(this.positionX()) // I wonder if this can be angular signal
+ *
+ *    this.positionX.set(12)
+ *
+ *    await this.positionX.ready(); // but with addional this
+ *  }
+ *
+ * }
+ *
+
+ *
  */
-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 = TaonStorageFacade;
 
-//#region @browser
+// export * from './storage';
+// export * from './storage';
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { SampleLogCmpComponent, Stor, StorConfig, StorPropertyInIndexedDb, StorPropertyInLocalStorage, keyDefaultValueAlreadySet, keyDefaultValueAreadySet, keyValue, storeName, uncache };
-//# sourceMappingURL=taon-storage-browser.mjs.map
+export { TaonStor };
+//# sourceMappingURL=taon-storage-browser.mjs.map