react-wire-persisted 2.0.1 → 2.1.0

package/client.js

@@ -55,4 +55,4 @@ export function HydrationProvider({ children, onUpgrade, autoUpgrade = true }) {
 }
 
 // Re-export the hook from the main package for convenience
-export { useHydration } from './dist/react-wire-persisted.js'
+export { useHydration } from './dist/react-wire-persisted.js'

package/client.mjs

@@ -16,7 +16,7 @@ const isLocalStorageAvailable = () => {
         window.localStorage.setItem(testKey, 'test')
         window.localStorage.removeItem(testKey)
         return true
-    } catch (e) {
+    } catch (_) {
         return false
     }
 }
@@ -30,10 +30,11 @@ const fakeStorage = {
     },
     removeItem: (key) => {
         delete fakeStorage.data[key]
-    }
+    },
 }
 
 // Get current storage (real or fake)
+// biome-ignore lint/correctness/noUnusedVariables: client usage only
 const getCurrentStorage = () => {
     return isLocalStorageAvailable() ? window.localStorage : fakeStorage
 }
@@ -52,7 +53,7 @@ const upgradeStorageToReal = () => {
     try {
         // Move data from fake to real storage
         const fakeData = { ...fakeStorage.data }
-        Object.keys(fakeData).forEach(key => {
+        Object.keys(fakeData).forEach((key) => {
             if (fakeData[key] != null) {
                 window.localStorage.setItem(key, fakeData[key])
             }
@@ -61,7 +62,7 @@ const upgradeStorageToReal = () => {
         // Clear fake storage
         fakeStorage.data = {}
         return true
-    } catch (e) {
+    } catch (_) {
         return false
     }
 }
@@ -105,4 +106,4 @@ export function HydrationProvider({ children, onUpgrade, autoUpgrade = true }) {
     }, [autoUpgrade, onUpgrade])
 
     return children
-}
+}

package/dist/index.js

@@ -1,74 +1,75 @@
-import { createWire as U } from "@forminator/react-wire";
-import { useRef as b, useEffect as O } from "react";
+import { useRef as A, useEffect as T } from "react";
+import { createWire as k } from "@forminator/react-wire";
 (function() {
-  const s = {};
+  const e = {};
   try {
     if (process) {
-      process.env = Object.assign({}, process.env), Object.assign(process.env, s);
+      process.env = Object.assign({}, process.env), Object.assign(process.env, e);
       return;
     }
   } catch {
   }
-  globalThis.process = { env: s };
+  globalThis.process = { env: e };
 })();
-const y = {}, w = (s) => {
-  y[s] = s;
-}, j = (s) => w(s), x = () => y, N = (s, e = null) => {
-  const t = e || y;
-  return s ? Object.keys(t).reduce((r, o) => ({
-    ...r,
-    [o]: `${s}.${t[o]}`
-  }), {}) : t;
-}, g = {
+const p = {
   __IS_FAKE_LOCAL_STORAGE__: !0
-}, h = {
-  getItem: (s) => g[s],
-  setItem: (s, e) => {
-    g[s] = e;
+}, S = {
+  getItem: (e) => p[e],
+  setItem: (e, t) => {
+    p[e] = t;
   },
-  removeItem: (s) => {
-    delete g[s];
+  removeItem: (e) => {
+    delete p[e];
   },
   // Make Object.keys() work properly for _resetAll method
-  ...g
+  ...p
 };
-let S = !1, p = !1;
-typeof window < "u" && (S = !0, document.readyState === "loading" ? document.addEventListener("DOMContentLoaded", () => {
-  p = !0;
-}) : p = !0);
-const m = () => S, _ = () => p, d = () => {
-  if (!S) return !1;
+let w = !1, R = !1, O = !1;
+typeof window < "u" && (w = !0, document.readyState === "loading" ? document.addEventListener("DOMContentLoaded", () => {
+  R = !0;
+}) : R = !0);
+const u = () => w, I = () => R, b = () => O, U = () => {
+  O = !0;
+}, y = () => {
+  if (!w) return !1;
   try {
-    const s = "__rwp_test__";
-    return window.localStorage.setItem(s, "test"), window.localStorage.removeItem(s), !0;
+    const e = "__rwp_test__";
+    return window.localStorage.setItem(e, "test"), window.localStorage.removeItem(e), !0;
   } catch {
     return !1;
   }
-}, A = (s) => {
-  const e = typeof s;
-  return s === null ? !0 : Array.isArray(s) || e === "object" ? !1 : e !== "function";
-}, k = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, P = {}, N = (e) => {
+  P[e] = e;
+}, F = (e) => N(e), x = () => P, K = (e, t = null) => {
+  const s = t || P;
+  return e ? Object.keys(s).reduce((r, n) => (r[n] = `${e}.${s[n]}`, r), {}) : s;
+}, G = (e) => {
+  const t = typeof e;
+  return e === null ? !0 : Array.isArray(e) || t === "object" ? !1 : t !== "function";
+}, z = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  addKey: w,
-  fakeLocalStorage: h,
-  getHasHydrated: _,
-  getIsClient: m,
+  addKey: N,
+  fakeLocalStorage: S,
+  getHasHydrated: I,
+  getHasHydratedStorage: b,
+  getIsClient: u,
   getKeys: x,
-  getPrefixedKeys: N,
-  isLocalStorageAvailable: d,
-  isPrimitive: A,
-  key: j
+  getPrefixedKeys: K,
+  isLocalStorageAvailable: y,
+  isPrimitive: G,
+  key: F,
+  markStorageAsHydrated: U
 }, Symbol.toStringTag, { value: "Module" }));
-class I {
+class E {
   /**
    * Initializes the class
    * @param {String} namespace Namespace to prefix all keys with. Mostly used for the logging & reset functions
    * @param {Object} registry (Optional) Initialize the storage provider with an existing registry
    */
-  constructor(e, t) {
-    if (new.target === I)
+  constructor(t, s) {
+    if (new.target === E)
       throw TypeError("StorageProvider is abstract. Extend this class to implement it");
-    this.namespace = e || null, this.registry = t || /* istanbul ignore next */
+    this.namespace = t || null, this.registry = s || /* istanbul ignore next */
     {};
   }
   /**
@@ -77,22 +78,22 @@ class I {
    * @param {String} namespace New namespace for this storage provider
    */
   /* istanbul ignore next */
-  setNamespace(e) {
+  setNamespace(t) {
   }
   /**
    * Registers an item with it's initial value. This is used for logging, resetting, etc.
    * @param {String} key Storage item's key
    * @param {*} initialValue Storage item's initial value
    */
-  register(e, t) {
-    this.registry[e] = t;
+  register(t, s) {
+    this.registry[t] = s;
   }
   /**
    * Reads an item from storage
    * @param {String} key Key for the item to retrieve
    */
   /* istanbul ignore next */
-  getItem(e) {
+  getItem(t) {
   }
   /**
    * Stores a value
@@ -100,7 +101,7 @@ class I {
    * @param {String} value Item's value to store
    */
   /* istanbul ignore next */
-  setItem(e, t) {
+  setItem(t, s) {
   }
   /**
    * Removes an item from storage
@@ -108,7 +109,7 @@ class I {
    * @param {Boolean} fromRegistry (Optional) If the item should also be removed from the registry
    */
   /* istanbul ignore next */
-  removeItem(e, t = !1) {
+  removeItem(t, s = !1) {
   }
   /**
    * Gets all stored keys & values
@@ -118,13 +119,13 @@ class I {
   getAll() {
   }
   /**
-   * 
+   *
    * @param {Boolean} useInitialValues If values should be replaced with their initial values. If false, keys are removed
    * @param {String[]} excludedKeys (Optional) List of keys to exclude
    * @param {Boolean} clearRegistry (Optional) If the registry should also be cleared
    */
   /* istanbul ignore next */
-  _resetAll(e = !0, t = [], r = !1) {
+  _resetAll(t = !0, s = [], r = !1) {
   }
   /**
    * Resets all values to their initial values
@@ -132,7 +133,7 @@ class I {
    * @param {String[]} excludedKeys (Optional) List of keys to exclude
    */
   /* istanbul ignore next */
-  resetAll(e = []) {
+  resetAll(t = []) {
   }
   /**
    * Removes all items from local storage.
@@ -140,81 +141,69 @@ class I {
    * @param {String[]} excludedKeys (Optional) List of keys to exclude
    */
   /* istanbul ignore next */
-  removeAll(e = []) {
+  removeAll(t = []) {
   }
 }
-class T extends I {
-  constructor(e = null, t = {}) {
-    super(e, t), this.storage = this.getStorage(), this._isUsingFakeStorage = !d();
+class V extends E {
+  constructor(t = null, s = {}) {
+    super(t, s), this.storage = S, this._isUsingFakeStorage = !0;
   }
   getStorage() {
-    return d() ? window.localStorage : h;
+    return y() ? window.localStorage : S;
   }
-  setNamespace(e) {
+  setNamespace(t) {
     if (!this.namespace) {
-      this.namespace = e;
+      this.namespace = t;
       return;
     }
-    if (this.namespace === e)
-      return;
-    const t = JSON.parse(JSON.stringify(this.getAll()));
+    if (this.namespace === t) return;
+    const s = JSON.parse(JSON.stringify(this.getAll()));
     this.removeAll();
-    for (const [r, o] of Object.entries(t)) {
-      const n = r.replace(this.namespace, e);
-      this.setItem(n, o);
+    for (const [r, n] of Object.entries(s)) {
+      const a = r.replace(this.namespace, t);
+      this.setItem(a, n);
     }
-    this.namespace = e;
+    this.namespace = t;
   }
-  getItem(e) {
-    const t = this.storage.getItem(e);
-    if (t == null)
-      return null;
+  getItem(t) {
+    const s = this.storage.getItem(t);
+    if (s == null) return null;
     try {
-      return JSON.parse(t);
+      return JSON.parse(s);
     } catch {
-      return t;
+      return s;
     }
   }
-  setItem(e, t) {
-    let r = t;
-    return r != null && (r = A(t) ? t : JSON.stringify(t)), this.storage.setItem(e, r);
+  setItem(t, s) {
+    let r = s;
+    return r != null && (r = G(s) ? s : JSON.stringify(s)), this.storage.setItem(t, r);
   }
-  removeItem(e, t = !1) {
-    return t && delete this.registry[e], this.storage.removeItem(e);
+  removeItem(t, s = !1) {
+    return s && delete this.registry[t], this.storage.removeItem(t);
   }
   getAll() {
-    const e = `${this.namespace}.`;
-    return Object.keys(this.storage).reduce((t, r) => ((!this.namespace || r.startsWith(e)) && (t[r] = this.storage.getItem(r)), t), {});
+    const t = `${this.namespace}.`;
+    return Object.keys(this.storage).reduce((s, r) => ((!this.namespace || r.startsWith(t)) && (s[r] = this.storage.getItem(r)), s), {});
   }
-  _resetAll(e = !0, t = [], r = !1) {
-    const o = `${this.namespace}.`;
-    Object.keys(this.storage).forEach((n) => {
-      const a = this.namespace ? n.startsWith(o) : !0, l = t?.includes(n) || !1;
-      !a || l || (e ? Object.prototype.hasOwnProperty.call(this.registry, n) ? this.storage.setItem(n, this.registry[n]) : this.storage.removeItem(n) : (this.storage.removeItem(n), r && delete this.registry[n]));
+  _resetAll(t = !0, s = [], r = !1) {
+    const n = `${this.namespace}.`;
+    Object.keys(this.storage).forEach((a) => {
+      const c = this.namespace ? a.startsWith(n) : !0, _ = s?.includes(a) || !1;
+      !c || _ || (t ? Object.hasOwn(this.registry, a) ? this.storage.setItem(a, this.registry[a]) : this.storage.removeItem(a) : (this.storage.removeItem(a), r && delete this.registry[a]));
     });
   }
-  resetAll(e = [], t = !1) {
-    this._resetAll(!0, e || [], t);
+  resetAll(t = [], s = !1) {
+    this._resetAll(!0, t || [], s);
   }
-  removeAll(e = [], t = !1) {
-    this._resetAll(!1, e || [], t);
+  removeAll(t = [], s = !1) {
+    this._resetAll(!1, t || [], s);
   }
   /**
    * Attempt to upgrade from fake storage to real localStorage
    * This is useful for hydration scenarios
    */
   upgradeToRealStorage() {
-    if (!this._isUsingFakeStorage || !d())
-      return !1;
-    const e = { ...this.storage };
-    return this.storage = window.localStorage, this._isUsingFakeStorage = !1, Object.keys(e).forEach((t) => {
-      if (t !== "__IS_FAKE_LOCAL_STORAGE__" && e[t] != null)
-        try {
-          this.storage.setItem(t, e[t]);
-        } catch {
-          return this.storage = h, this._isUsingFakeStorage = !0, !1;
-        }
-    }), !0;
+    return !this._isUsingFakeStorage || !y() ? !1 : (this.storage = window.localStorage, this._isUsingFakeStorage = !1, !0);
   }
   /**
    * Check if currently using fake storage
@@ -223,87 +212,135 @@ class T extends I {
     return this._isUsingFakeStorage;
   }
 }
-const L = {
+const l = Math.random().toString(36).substring(7), i = (...e) => {
+  typeof globalThis < "u" && globalThis.__RWP_LOGGING_ENABLED__ !== !1 && console.log(...e);
+}, v = {
   logging: {
     enabled: !1
   }
 };
-let v = T, i = new v(), u = { ...L }, f = [];
-const P = () => i.namespace, V = () => i, $ = () => u, C = (s) => {
-  i.setNamespace(s), i = new v(s || P());
-}, H = (s) => {
-  if (u = {
-    ...u,
-    ...s
-  }, u.logging.enabled)
-    for (console.info("Flushing", f.length, "pending logs"); f.length; )
-      console.log(...f.shift());
-}, K = () => {
-  if (!m())
-    return !1;
-  const s = i.upgradeToRealStorage();
-  return s && E("react-wire-persisted: Upgraded to real localStorage after hydration"), s;
-}, E = (...s) => {
-  u.logging.enabled ? console.log(...s) : f.push(s);
-}, W = (s, e = null) => {
-  if (!s && typeof s != "number") throw new Error(
-    `createPersistedWire: Key cannot be a falsey value (${s}}`
-  );
-  i.register(s, e);
-  const t = U(e), r = () => t.getValue(), o = (c) => (i.setItem(s, c), t.setValue(c)), n = (c) => {
-    t.subscribe(c);
-  }, a = i.getItem(s), l = a === null ? e : a;
-  return E("react-wire-persisted: create", s, {
-    value: e,
-    storedValue: a,
-    initialValue: l
-  }), l !== e && o(l), {
-    ...t,
+typeof globalThis < "u" && globalThis.__RWP_LOGGING_ENABLED__ === void 0 && (globalThis.__RWP_LOGGING_ENABLED__ = v.logging.enabled);
+i("[RWP] Module initialized, instance ID:", l);
+const W = V;
+i("[RWP] About to check global storage, instanceId:", l);
+let o;
+try {
+  globalThis.__RWP_STORAGE__ ? i("[RWP] Using existing global storage in instance:", l) : (i("[RWP] Creating global storage in instance:", l), globalThis.__RWP_STORAGE__ = new W()), o = globalThis.__RWP_STORAGE__, i("[RWP] Storage assigned successfully");
+} catch (e) {
+  globalThis.__RWP_LOGGING_ENABLED__ && console.error("[RWP] Error setting up global storage:", e), o = new W();
+}
+let h = { ...v };
+const m = [];
+typeof globalThis < "u" && (globalThis.__RWP_REGISTERED_WIRES__ ? i("[RWP] Using existing global registeredWires in instance:", l) : (i("[RWP] Creating global registeredWires in instance:", l), globalThis.__RWP_REGISTERED_WIRES__ = /* @__PURE__ */ new Map()));
+const g = globalThis.__RWP_REGISTERED_WIRES__ || /* @__PURE__ */ new Map();
+i("[RWP] registeredWires Map reference in instance:", l, "size:", g.size);
+const j = () => o.namespace, M = () => o, $ = () => h, B = (e) => {
+  i("[RWP] setNamespace() called with:", e, "registered wires before:", g.size), o.setNamespace(e), o = new W(e || j()), i("[RWP] setNamespace() done, registered wires after:", g.size);
+}, J = (e) => {
+  if (h = {
+    ...h,
+    ...e
+  }, typeof globalThis < "u" && (globalThis.__RWP_LOGGING_ENABLED__ = h.logging.enabled), h.logging.enabled)
+    for (console.info("Flushing", m.length, "pending logs"); m.length; )
+      console.log(...m.shift());
+}, C = () => {
+  i("[RWP] refreshAllWires() called in instance:", l, "registered wires:", g.size), f("react-wire-persisted: refreshAllWires() called, registered wires:", g.size), g.forEach((e, t) => {
+    const s = o.getItem(t), r = e.getValue();
+    i("[RWP] Checking wire", t, {
+      storedValue: s,
+      currentValue: r,
+      willUpdate: s !== null && s !== r
+    }), f("react-wire-persisted: Checking wire", t, {
+      storedValue: s,
+      currentValue: r,
+      willUpdate: s !== null && s !== r
+    }), s !== null && s !== r && (i("[RWP] Refreshing wire", t, "with stored value", s), f("react-wire-persisted: Refreshing wire", t, "with stored value", s), e.setValue(s));
+  });
+}, L = () => {
+  if (i("[RWP] upgradeStorage() called in instance:", l, {
+    isClient: u(),
+    isUsingFakeStorage: o.isUsingFakeStorage()
+  }), f("react-wire-persisted: upgradeStorage() called", {
+    isClient: u(),
+    isUsingFakeStorage: o.isUsingFakeStorage()
+  }), !u()) return !1;
+  const e = o.upgradeToRealStorage();
+  return i("[RWP] upgradeToRealStorage() returned", e), f("react-wire-persisted: upgradeToRealStorage() returned", e), e && (U(), i("[RWP] Upgraded to real localStorage, calling refreshAllWires()"), f("react-wire-persisted: Upgraded to real localStorage after hydration"), C()), e;
+}, f = (...e) => {
+  h.logging.enabled ? console.log(...e) : m.push(e);
+}, q = (e, t = null) => {
+  if (i("[RWP] createPersistedWire() called in instance:", l, "key:", e, "value:", t), !e && typeof e != "number") throw new Error(`createPersistedWire: Key cannot be a falsey value (${e}}`);
+  o.register(e, t);
+  const s = k(t), r = () => s.getValue(), n = (d) => (i(
+    "[RWP] setValue called in instance:",
+    l,
+    "key:",
+    e,
+    "isUsingFakeStorage:",
+    o.isUsingFakeStorage()
+  ), o.setItem(e, d), s.setValue(d)), a = (d) => {
+    s.subscribe(d);
+  };
+  let c = t;
+  const _ = b() || !o.isUsingFakeStorage();
+  if (_ && u()) {
+    const d = o.getItem(e);
+    d !== null && (c = d);
+  }
+  return f("react-wire-persisted: create", e, {
+    value: t,
+    initialValue: c,
+    hasHydratedStorage: b(),
+    isUsingFakeStorage: o.isUsingFakeStorage(),
+    canReadStorage: _
+  }), c !== t && n(c), g.set(e, {
+    getValue: r,
+    setValue: n,
+    subscribe: a
+  }), i("[RWP] Wire registered, total wires:", g.size, "keys:", Array.from(g.keys())), {
+    ...s,
     getValue: r,
-    setValue: o,
-    subscribe: n
+    setValue: n,
+    subscribe: a
   };
-}, J = (s = {}) => {
-  const {
-    autoUpgrade: e = !0,
-    onUpgrade: t
-  } = s, r = b(!1);
-  return O(() => {
-    if (!e || r.current || !m())
+};
+function Q({ children: e, onUpgrade: t, autoUpgrade: s = !0 }) {
+  const r = A(!1);
+  return T(() => {
+    if (!s || r.current || !u())
       return;
-    const o = () => {
-      _() && !r.current && K() && (r.current = !0, t?.());
+    const n = () => {
+      I() && !r.current && L() && (r.current = !0, t?.());
+    };
+    n();
+    const a = setTimeout(n, 0);
+    return () => clearTimeout(a);
+  }, [s, t]), e;
+}
+const X = (e = {}) => {
+  const { autoUpgrade: t = !0, onUpgrade: s } = e, r = A(!1);
+  return T(() => {
+    if (!t || r.current || !u()) return;
+    const n = () => {
+      I() && !r.current && L() && (r.current = !0, s?.());
     };
-    o();
-    const n = setTimeout(o, 0);
-    return () => clearTimeout(n);
-  }, [e, t]), {
+    n();
+    const a = setTimeout(n, 0);
+    return () => clearTimeout(a);
+  }, [t, s]), {
     hasUpgraded: r.current
   };
 };
-function D({ children: s, onUpgrade: e, autoUpgrade: t = !0 }) {
-  const r = b(!1);
-  return O(() => {
-    if (!t || r.current || !m())
-      return;
-    const o = () => {
-      _() && !r.current && K() && (r.current = !0, e?.());
-    };
-    o();
-    const n = setTimeout(o, 0);
-    return () => clearTimeout(n);
-  }, [t, e]), s;
-}
 export {
-  D as HydrationProvider,
-  W as createPersistedWire,
-  L as defaultOptions,
-  P as getNamespace,
+  Q as HydrationProvider,
+  q as createPersistedWire,
+  v as defaultOptions,
+  j as getNamespace,
   $ as getOptions,
-  V as getStorage,
-  C as setNamespace,
-  H as setOptions,
-  K as upgradeStorage,
-  J as useHydration,
-  k as utils
+  M as getStorage,
+  B as setNamespace,
+  J as setOptions,
+  L as upgradeStorage,
+  X as useHydration,
+  z as utils
 };