taon-storage 21.0.19 → 21.0.20

package/lib-prod/storage.js

@@ -1,384 +1,491 @@
-import { ___NS__kebabCase, UtilsOs__NS__isNode } from "tnp-core/lib-prod";
-const isBrowser = typeof window !== "undefined" && typeof document !== "undefined" && typeof navigator !== "undefined";
+/* taon-storage (native, SSR-safe) */
+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';
+    }
 }
-const storeName = `taon-storage_${safeLocationPort()}`;
+/**
+ * Keeps the spirit of your old `storeName = taon-storage_<port>`
+ * plus project name namespacing (but without localForage).
+ */
+export const storeName = `taon-storage_${safeLocationPort()}`;
 function defaultNamespace() {
-  const project = ___NS__kebabCase(globalThis["CURRENT_PROJECT_GENERIC_NAME"] ?? "");
-  return project ? `${storeName}_${project}` : storeName;
+    const project = ___NS__kebabCase(globalThis['CURRENT_PROJECT_GENERIC_NAME'] ?? '');
+    return project ? `${storeName}_${project}` : storeName;
 }
-const StorConfig = {
-  namespace: defaultNamespace(),
-  indexedDb: {
-    dbName: `${defaultNamespace()}_INDEXEDDB`,
-    storeName: "keyvaluepairs"
-  }
+/**
+ * Central config (optional).
+ * You can set it once at app bootstrap if you want a stable namespace.
+ */
+export const StorConfig = {
+    namespace: defaultNamespace(),
+    indexedDb: {
+        dbName: `${defaultNamespace()}_INDEXEDDB`,
+        storeName: 'keyvaluepairs',
+    },
 };
 function normalizeScopeClass(cls) {
-  if (!cls) return { name: "__GLOBAL_NAMESPACE__" };
-  if (typeof cls === "function")
-    return { name: cls.name || "__ANON__" };
-  return { name: cls.name || "__ANON__" };
+    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__' };
 }
-function keyValue(scopeClass, memberName) {
-  const c = normalizeScopeClass(scopeClass);
-  return `${StorConfig.namespace}::taon.storage.class.${c.name}.prop.${memberName}`;
+export function keyValue(scopeClass, memberName) {
+    const c = normalizeScopeClass(scopeClass);
+    return `${StorConfig.namespace}::taon.storage.class.${c.name}.prop.${memberName}`;
 }
-function keyDefaultValueAlreadySet(scopeClass, memberName) {
-  return `${keyValue(scopeClass, memberName)}::defaultvalueisset`;
+export function keyDefaultValueAlreadySet(scopeClass, memberName) {
+    return `${keyValue(scopeClass, memberName)}::defaultvalueisset`;
 }
-const keyDefaultValueAreadySet = keyDefaultValueAlreadySet;
+/** Back-compat alias (your old typo) */
+export const keyDefaultValueAreadySet = keyDefaultValueAlreadySet;
 class NoopStore {
-  async getItem(_key) {
-    return void 0;
-  }
-  async setItem(_key, _value) {
-  }
-  async removeItem(_key) {
-  }
+    async getItem(_key) {
+        return undefined;
+    }
+    async setItem(_key, _value) {
+        // noop
+    }
+    async removeItem(_key) {
+        // noop
+    }
 }
 class BrowserLocalStorageStore {
-  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 {
+    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
+        }
     }
-  }
 }
 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: 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);
+    constructor() {
+        this.dbPromise = null;
+    }
+    openDb() {
+        if (!isBrowser || !window.indexedDB) {
+            return Promise.reject(new Error('IndexedDB not available'));
         }
-      };
-      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;
+        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);
+                }
+            };
+            req.onsuccess = () => resolve(req.result);
+            req.onerror = () => reject(req.error);
+        });
+        return this.dbPromise;
     }
-  }
-  async setItem(key, value) {
-    try {
-      await this.withStore("readwrite", (s) => s.put(value, key));
-    } catch {
+    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
+        });
     }
-  }
-  async removeItem(key) {
-    try {
-      await this.withStore("readwrite", (s) => s.delete(key));
-    } catch {
+    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__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 {
+    constructor(filePath, useJSON = false) {
+        this.filePath = filePath;
+        this.useJSON = useJSON;
+    }
+    isNodeRuntime() {
+        return 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 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');
+        }
+        //#endregion
+    }
+    async getItem(_key) {
+        if (!this.isNodeRuntime())
+            return undefined;
+        //#region @backendFunc
+        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 undefined;
+        }
+        //#endregion
+    }
+    async removeItem(_key) {
+        if (!this.isNodeRuntime())
+            return;
+        //#region @backendFunc
+        const fs = await import('node:fs/promises');
+        try {
+            await fs.rm(this.filePath, { force: true });
+        }
+        catch {
+            // ignore
+        }
+        //#endregion
     }
-  }
 }
+/* ---------------------------
+ * 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;
-      }
-    }
-    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;
-  }
-}
-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;
-    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;
+    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++;
         }
-        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;
+        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;
             }
-            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;
-  }
+        // 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;
+    }
 }
-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
-    );
-  }
+/* ---------------------------
+ * 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;
+    }
+}
+/* ---------------------------
+ * Public: clean API exports
+ * -------------------------- */
+const localStorageStore = isBrowser
+    ? new BrowserLocalStorageStore()
+    : new NoopStore();
+const indexedDbStore = isBrowser
+    ? new BrowserIndexedDbStore()
+    : new NoopStore();
+export class StorPropertyInLocalStorage {
+    static for(scopeClass) {
+        return new StorPropertyBuilder('localstorage', localStorageStore).for(scopeClass);
+    }
 }
-class StorPropertyInIndexedDb {
-  static for(scopeClass) {
-    return new StorPropertyBuilder("indexeddb", indexedDbStore).for(scopeClass);
-  }
+export class StorPropertyInIndexedDb {
+    static for(scopeClass) {
+        return new StorPropertyBuilder('indexeddb', indexedDbStore).for(scopeClass);
+    }
 }
-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))
-  ]);
+/**
+ * Helpers
+ */
+export 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));
-        }
-      }
-    };
-  }
+    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;
-export {
-  Stor,
-  StorConfig,
-  StorPropertyInIndexedDb,
-  StorPropertyInLocalStorage,
-  keyDefaultValueAlreadySet,
-  keyDefaultValueAreadySet,
-  keyValue,
-  storeName,
-  uncache
-};
+export const Stor = TaonStorageFacade;