taon-storage 21.0.16 → 21.0.19

package/lib-prod/storage.js

@@ -1,504 +1,384 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Stor = exports.StorPropertyInIndexedDb = exports.StorPropertyInLocalStorage = exports.keyDefaultValueAreadySet = exports.StorConfig = exports.storeName = void 0;
-exports.keyValue = keyValue;
-exports.keyDefaultValueAlreadySet = keyDefaultValueAlreadySet;
-exports.uncache = uncache;
-/* taon-storage (native, SSR-safe) */
-const lib_prod_1 = require("tnp-core/lib-prod");
-const isBrowser = typeof window !== 'undefined' &&
-    typeof document !== 'undefined' &&
-    typeof navigator !== 'undefined';
+import { ___NS__kebabCase, UtilsOs__NS__isNode } from "tnp-core/lib-prod";
+const isBrowser = typeof window !== "undefined" && typeof document !== "undefined" && typeof navigator !== "undefined";
 function safeLocationPort() {
-    try {
-        return globalThis?.location?.port || 'no-port';
-    }
-    catch {
-        return 'no-port';
-    }
+  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).
- */
-exports.storeName = `taon-storage_${safeLocationPort()}`;
+const storeName = `taon-storage_${safeLocationPort()}`;
 function defaultNamespace() {
-    const project = lib_prod_1._.kebabCase(globalThis['CURRENT_PROJECT_GENERIC_NAME'] ?? '');
-    return project ? `${exports.storeName}_${project}` : exports.storeName;
+  const project = ___NS__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.
- */
-exports.StorConfig = {
-    namespace: defaultNamespace(),
-    indexedDb: {
-        dbName: `${defaultNamespace()}_INDEXEDDB`,
-        storeName: 'keyvaluepairs',
-    },
+const StorConfig = {
+  namespace: defaultNamespace(),
+  indexedDb: {
+    dbName: `${defaultNamespace()}_INDEXEDDB`,
+    storeName: "keyvaluepairs"
+  }
 };
 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__' };
+  if (!cls) return { name: "__GLOBAL_NAMESPACE__" };
+  if (typeof cls === "function")
+    return { name: cls.name || "__ANON__" };
+  return { name: cls.name || "__ANON__" };
 }
 function keyValue(scopeClass, memberName) {
-    const c = normalizeScopeClass(scopeClass);
-    return `${exports.StorConfig.namespace}::taon.storage.class.${c.name}.prop.${memberName}`;
+  const c = normalizeScopeClass(scopeClass);
+  return `${StorConfig.namespace}::taon.storage.class.${c.name}.prop.${memberName}`;
 }
 function keyDefaultValueAlreadySet(scopeClass, memberName) {
-    return `${keyValue(scopeClass, memberName)}::defaultvalueisset`;
+  return `${keyValue(scopeClass, memberName)}::defaultvalueisset`;
 }
-/** Back-compat alias (your old typo) */
-exports.keyDefaultValueAreadySet = keyDefaultValueAlreadySet;
+const keyDefaultValueAreadySet = keyDefaultValueAlreadySet;
 class NoopStore {
-    async getItem(_key) {
-        return undefined;
-    }
-    async setItem(_key, _value) {
-        // noop
-    }
-    async removeItem(_key) {
-        // noop
-    }
+  async getItem(_key) {
+    return void 0;
+  }
+  async setItem(_key, _value) {
+  }
+  async removeItem(_key) {
+  }
 }
 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));
-            }
-            catch {
-                // ignore (quota/private mode)
-            }
-        }
-    }
-    async removeItem(key) {
-        const ls = this.ls();
-        if (!ls)
-            return;
-        try {
-            ls.removeItem(key);
-        }
-        catch {
-            // ignore
-        }
+  ls() {
+    if (!isBrowser) return void 0;
+    try {
+      return window.localStorage;
+    } catch {
+      return void 0;
+    }
+  }
+  async getItem(key) {
+    const ls = this.ls();
+    if (!ls) return void 0;
+    const raw = ls.getItem(key);
+    if (raw === null) return void 0;
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return raw;
+    }
+  }
+  async setItem(key, value) {
+    const ls = this.ls();
+    if (!ls) return;
+    try {
+      ls.setItem(key, JSON.stringify(value));
+    } catch {
+      try {
+        ls.setItem(key, String(value));
+      } catch {
+      }
+    }
+  }
+  async removeItem(key) {
+    const ls = this.ls();
+    if (!ls) return;
+    try {
+      ls.removeItem(key);
+    } catch {
     }
+  }
 }
 class BrowserIndexedDbStore {
-    dbPromise = null;
-    openDb() {
-        if (!isBrowser || !window.indexedDB) {
-            return Promise.reject(new Error('IndexedDB not available'));
-        }
-        if (this.dbPromise)
-            return this.dbPromise;
-        const { dbName, storeName } = exports.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);
-                }
-            };
-            req.onsuccess = () => resolve(req.result);
-            req.onerror = () => reject(req.error);
-        });
-        return this.dbPromise;
-    }
-    async withStore(mode, fn) {
-        const db = await this.openDb();
-        const { storeName } = exports.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
-        });
-    }
-    async getItem(key) {
-        try {
-            const result = await this.withStore('readonly', s => s.get(key));
-            return result === undefined ? undefined : result;
-        }
-        catch {
-            return undefined;
+  dbPromise = null;
+  openDb() {
+    if (!isBrowser || !window.indexedDB) {
+      return Promise.reject(new Error("IndexedDB not available"));
+    }
+    if (this.dbPromise) return this.dbPromise;
+    const { dbName, storeName: storeName2 } = StorConfig.indexedDb;
+    this.dbPromise = new Promise((resolve, reject) => {
+      const req = indexedDB.open(dbName, 1);
+      req.onupgradeneeded = () => {
+        const db = req.result;
+        if (!db.objectStoreNames.contains(storeName2)) {
+          db.createObjectStore(storeName2);
         }
+      };
+      req.onsuccess = () => resolve(req.result);
+      req.onerror = () => reject(req.error);
+    });
+    return this.dbPromise;
+  }
+  async withStore(mode, fn) {
+    const db = await this.openDb();
+    const { storeName: storeName2 } = StorConfig.indexedDb;
+    return await new Promise((resolve, reject) => {
+      const tx = db.transaction(storeName2, mode);
+      const store = tx.objectStore(storeName2);
+      const req = fn(store);
+      req.onsuccess = () => resolve(req.result);
+      req.onerror = () => reject(req.error);
+      tx.onabort = () => reject(tx.error);
+    });
+  }
+  async getItem(key) {
+    try {
+      const result = await this.withStore("readonly", (s) => s.get(key));
+      return result === void 0 ? void 0 : result;
+    } catch {
+      return void 0;
     }
-    async setItem(key, value) {
-        try {
-            await this.withStore('readwrite', s => s.put(value, key));
-        }
-        catch {
-            // ignore
-        }
+  }
+  async setItem(key, value) {
+    try {
+      await this.withStore("readwrite", (s) => s.put(value, key));
+    } catch {
     }
-    async removeItem(key) {
-        try {
-            await this.withStore('readwrite', s => s.delete(key));
-        }
-        catch {
-            // ignore
-        }
+  }
+  async removeItem(key) {
+    try {
+      await this.withStore("readwrite", (s) => s.delete(key));
+    } catch {
     }
+  }
 }
-/**
- * Node-side file storage (optional). No top-level node imports (Angular-safe).
- * Works only when executed in Node.
- */
 class FileStor {
-    filePath;
-    useJSON;
-    constructor(filePath, useJSON = false) {
-        this.filePath = filePath;
-        this.useJSON = useJSON;
-    }
-    isNodeRuntime() {
-        return lib_prod_1.UtilsOs__NS__isNode;
-        // return (
-        //   typeof process !== 'undefined' &&
-        //   !!(process as any).versions?.node &&
-        //   typeof (globalThis as any).window === 'undefined'
-        // );
-    }
-    async setItem(_key, value) {
-        if (!this.isNodeRuntime())
-            return;
-        //#region @backendFunc
-        const fs = await Promise.resolve().then(() => require('node:fs/promises'));
-        const data = this.useJSON ? JSON.stringify(value, null, 2) : value;
-        if (this.useJSON) {
-            await fs.writeFile(this.filePath, String(data), 'utf8');
-        }
-        else {
-            await fs.writeFile(this.filePath, String(data), 'utf8');
-        }
-        //#endregion
-    }
-    async getItem(_key) {
-        if (!this.isNodeRuntime())
-            return undefined;
-        //#region @backendFunc
-        const fs = await Promise.resolve().then(() => require('node:fs/promises'));
-        try {
-            const buf = await fs.readFile(this.filePath, 'utf8');
-            if (!this.useJSON)
-                return buf;
-            return JSON.parse(buf);
-        }
-        catch {
-            return undefined;
-        }
-        //#endregion
-    }
-    async removeItem(_key) {
-        if (!this.isNodeRuntime())
-            return;
-        //#region @backendFunc
-        const fs = await Promise.resolve().then(() => require('node:fs/promises'));
-        try {
-            await fs.rm(this.filePath, { force: true });
-        }
-        catch {
-            // ignore
-        }
-        //#endregion
+  constructor(filePath, useJSON = false) {
+    this.filePath = filePath;
+    this.useJSON = useJSON;
+  }
+  isNodeRuntime() {
+    return UtilsOs__NS__isNode;
+  }
+  async setItem(_key, value) {
+    if (!this.isNodeRuntime()) return;
+    const fs = await import("node:fs/promises");
+    const data = this.useJSON ? JSON.stringify(value, null, 2) : value;
+    if (this.useJSON) {
+      await fs.writeFile(this.filePath, String(data), "utf8");
+    } else {
+      await fs.writeFile(this.filePath, String(data), "utf8");
+    }
+  }
+  async getItem(_key) {
+    if (!this.isNodeRuntime()) return void 0;
+    const fs = await import("node:fs/promises");
+    try {
+      const buf = await fs.readFile(this.filePath, "utf8");
+      if (!this.useJSON) return buf;
+      return JSON.parse(buf);
+    } catch {
+      return void 0;
+    }
+  }
+  async removeItem(_key) {
+    if (!this.isNodeRuntime()) return;
+    const fs = await import("node:fs/promises");
+    try {
+      await fs.rm(this.filePath, { force: true });
+    } catch {
     }
+  }
 }
-/* ---------------------------
- * Pending ops (so you can still await)
- * -------------------------- */
 class StorPending {
-    static pending = [];
-    static id = 0;
-    static AWAITING_INTERVAL_TIME = 200;
-    static async awaitPendingOperations(id = StorPending.id++) {
-        if (id > Number.MAX_SAFE_INTEGER - 2) {
-            StorPending.id = 0;
-            id = StorPending.id++;
-        }
-        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;
-            }
-        }
-        // 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;
-    }
+  static pending = [];
+  static id = 0;
+  static AWAITING_INTERVAL_TIME = 200;
+  static async awaitPendingOperations(id = StorPending.id++) {
+    if (id > Number.MAX_SAFE_INTEGER - 2) {
+      StorPending.id = 0;
+      id = StorPending.id++;
+    }
+    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;
+      }
+    }
+    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;
+  }
 }
-/* ---------------------------
- * Decorator builder
- * -------------------------- */
 class StorPropertyBuilder {
-    scopeClass;
-    engine;
-    store;
-    filePath;
-    useJsonFile = false;
-    constructor(engine, store) {
-        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);
+  scopeClass;
+  engine;
+  store;
+  filePath;
+  useJsonFile = false;
+  constructor(engine, store) {
+    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;
+    const values = /* @__PURE__ */ new WeakMap();
+    const initStarted = /* @__PURE__ */ 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 !== void 0;
+        if (!isBrowser && (this.engine === "localstorage" || this.engine === "indexeddb")) {
+          if (defProvided) values.set(instance, options.defaultValue);
+          return;
+        }
+        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 !== void 0) 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 !== void 0) values.set(instance, v);
+        }
+      })().catch(() => {
+      }).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 !== void 0) return options.defaultValue;
+          return void 0;
+        },
+        set: function(newValue) {
+          values.set(this, newValue);
+          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 (!isBrowser && options) return;
+            await options;
+          }).catch(() => {
+          });
+          Promise.resolve().then(async () => {
+            if (!isBrowser && StorPropertyInLocalStorage) {
+              return;
             }
-        };
-    }
-    /* 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;
-    }
+            await thisStoreForEngineWrite(this, kVal, toDb);
+          }).catch(() => {
+          }).finally(() => StorPending.done(op));
+        }
+      });
+      const builderStore = this.store;
+      const builderEngine = this.engine;
+      async function thisStoreForEngineWrite(_instance, key, value) {
+        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();
+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);
-    }
+  static for(scopeClass) {
+    return new StorPropertyBuilder("localstorage", localStorageStore).for(
+      scopeClass
+    );
+  }
 }
-exports.StorPropertyInLocalStorage = StorPropertyInLocalStorage;
 class StorPropertyInIndexedDb {
-    static for(scopeClass) {
-        return new StorPropertyBuilder('indexeddb', indexedDbStore).for(scopeClass);
-    }
+  static for(scopeClass) {
+    return new StorPropertyBuilder("indexeddb", indexedDbStore).for(scopeClass);
+  }
 }
-exports.StorPropertyInIndexedDb = StorPropertyInIndexedDb;
-/**
- * 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)),
-    ]);
+  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));
-                },
-            },
-        };
-    }
+  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));
+        }
+      }
+    };
+  }
 }
-exports.Stor = TaonStorageFacade;
-//# sourceMappingURL=storage.js.map
+const Stor = TaonStorageFacade;
+export {
+  Stor,
+  StorConfig,
+  StorPropertyInIndexedDb,
+  StorPropertyInLocalStorage,
+  keyDefaultValueAlreadySet,
+  keyDefaultValueAreadySet,
+  keyValue,
+  storeName,
+  uncache
+};