react-wire-persisted 2.0.1 → 3.0.0

package/dist/index.js

@@ -1,309 +1,245 @@
-import { createWire as U } from "@forminator/react-wire";
-import { useRef as b, useEffect as O } from "react";
+import { useEffect as e, useRef as t } from "react";
+import { createWire as n } from "@forminator/react-wire";
+//#region \0rolldown/runtime.js
+var r = Object.defineProperty, i = (e, t) => {
+	let n = {};
+	for (var i in e) r(n, i, {
+		get: e[i],
+		enumerable: !0
+	});
+	return t || r(n, Symbol.toStringTag, { value: "Module" }), n;
+};
+//#endregion
+//#region \0rollup-plugin-inject-process-env
 (function() {
-  const s = {};
-  try {
-    if (process) {
-      process.env = Object.assign({}, process.env), Object.assign(process.env, s);
-      return;
-    }
-  } catch {
-  }
-  globalThis.process = { env: s };
+	let e = {};
+	try {
+		if (process) {
+			process.env = Object.assign({}, process.env), Object.assign(process.env, e);
+			return;
+		}
+	} catch {}
+	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 = {
-  __IS_FAKE_LOCAL_STORAGE__: !0
-}, h = {
-  getItem: (s) => g[s],
-  setItem: (s, e) => {
-    g[s] = e;
-  },
-  removeItem: (s) => {
-    delete g[s];
-  },
-  // Make Object.keys() work properly for _resetAll method
-  ...g
-};
-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;
-  try {
-    const s = "__rwp_test__";
-    return window.localStorage.setItem(s, "test"), window.localStorage.removeItem(s), !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({
-  __proto__: null,
-  addKey: w,
-  fakeLocalStorage: h,
-  getHasHydrated: _,
-  getIsClient: m,
-  getKeys: x,
-  getPrefixedKeys: N,
-  isLocalStorageAvailable: d,
-  isPrimitive: A,
-  key: j
-}, Symbol.toStringTag, { value: "Module" }));
-class I {
-  /**
-   * 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)
-      throw TypeError("StorageProvider is abstract. Extend this class to implement it");
-    this.namespace = e || null, this.registry = t || /* istanbul ignore next */
-    {};
-  }
-  /**
-   * Sets the namespace for this storage provider, and migrates
-   * all stored values to the new namespace
-   * @param {String} namespace New namespace for this storage provider
-   */
-  /* istanbul ignore next */
-  setNamespace(e) {
-  }
-  /**
-   * 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;
-  }
-  /**
-   * Reads an item from storage
-   * @param {String} key Key for the item to retrieve
-   */
-  /* istanbul ignore next */
-  getItem(e) {
-  }
-  /**
-   * Stores a value
-   * @param {String} key Item's storage key
-   * @param {String} value Item's value to store
-   */
-  /* istanbul ignore next */
-  setItem(e, t) {
-  }
-  /**
-   * Removes an item from storage
-   * @param {String} key Item's storage key
-   * @param {Boolean} fromRegistry (Optional) If the item should also be removed from the registry
-   */
-  /* istanbul ignore next */
-  removeItem(e, t = !1) {
-  }
-  /**
-   * Gets all stored keys & values
-   * If a `namespace` was set, only keys prefixed with the namespace will be returned
-   */
-  /* istanbul ignore next */
-  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) {
-  }
-  /**
-   * Resets all values to their initial values
-   * If a `namespace` is set, only keys prefixed with the namespace will be reset
-   * @param {String[]} excludedKeys (Optional) List of keys to exclude
-   */
-  /* istanbul ignore next */
-  resetAll(e = []) {
-  }
-  /**
-   * Removes all items from local storage.
-   * If a `namespace` is set, only keys prefixed with the namespace will be removed
-   * @param {String[]} excludedKeys (Optional) List of keys to exclude
-   */
-  /* istanbul ignore next */
-  removeAll(e = []) {
-  }
-}
-class T extends I {
-  constructor(e = null, t = {}) {
-    super(e, t), this.storage = this.getStorage(), this._isUsingFakeStorage = !d();
-  }
-  getStorage() {
-    return d() ? window.localStorage : h;
-  }
-  setNamespace(e) {
-    if (!this.namespace) {
-      this.namespace = e;
-      return;
-    }
-    if (this.namespace === e)
-      return;
-    const t = 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);
-    }
-    this.namespace = e;
-  }
-  getItem(e) {
-    const t = this.storage.getItem(e);
-    if (t == null)
-      return null;
-    try {
-      return JSON.parse(t);
-    } catch {
-      return t;
-    }
-  }
-  setItem(e, t) {
-    let r = t;
-    return r != null && (r = A(t) ? t : JSON.stringify(t)), this.storage.setItem(e, r);
-  }
-  removeItem(e, t = !1) {
-    return t && delete this.registry[e], this.storage.removeItem(e);
-  }
-  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), {});
-  }
-  _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(e = [], t = !1) {
-    this._resetAll(!0, e || [], t);
-  }
-  removeAll(e = [], t = !1) {
-    this._resetAll(!1, e || [], t);
-  }
-  /**
-   * 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;
-  }
-  /**
-   * Check if currently using fake storage
-   */
-  isUsingFakeStorage() {
-    return this._isUsingFakeStorage;
-  }
-}
-const L = {
-  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,
-    getValue: r,
-    setValue: o,
-    subscribe: n
-  };
-}, J = (s = {}) => {
-  const {
-    autoUpgrade: e = !0,
-    onUpgrade: t
-  } = s, r = b(!1);
-  return O(() => {
-    if (!e || r.current || !m())
-      return;
-    const o = () => {
-      _() && !r.current && K() && (r.current = !0, t?.());
-    };
-    o();
-    const n = setTimeout(o, 0);
-    return () => clearTimeout(n);
-  }, [e, t]), {
-    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;
+//#endregion
+//#region src/utils/fakeLocalStorage.ts
+var a = { __IS_FAKE_LOCAL_STORAGE__: "true" }, o = {
+	getItem: (e) => a[e],
+	setItem: (e, t) => {
+		a[e] = t;
+	},
+	removeItem: (e) => {
+		delete a[e];
+	},
+	...a
+}, s = !1, c = !1, l = !1;
+typeof window < "u" && (s = !0, document.readyState === "loading" ? document.addEventListener("DOMContentLoaded", () => {
+	c = !0;
+}) : c = !0);
+var u = () => s, d = () => c, f = () => l, p = () => {
+	l = !0;
+}, m = () => {
+	if (!s) return !1;
+	try {
+		let e = "__rwp_test__";
+		return window.localStorage.setItem(e, "test"), window.localStorage.removeItem(e), !0;
+	} catch {
+		return !1;
+	}
+}, h = {}, g = (e) => {
+	h[e] = e;
+}, _ = (e) => g(e), v = () => h, y = (e, t = null) => {
+	let n = t || h;
+	return e ? Object.keys(n).reduce((t, r) => (t[r] = `${e}.${n[r]}`, t), {}) : n;
+}, b = /* @__PURE__ */ i({
+	addKey: () => g,
+	fakeLocalStorage: () => o,
+	getHasHydrated: () => d,
+	getHasHydratedStorage: () => f,
+	getIsClient: () => u,
+	getKeys: () => v,
+	getPrefixedKeys: () => y,
+	isLocalStorageAvailable: () => m,
+	isPrimitive: () => x,
+	key: () => _,
+	markStorageAsHydrated: () => p
+}), x = (e) => {
+	let t = typeof e;
+	return e === null ? !0 : Array.isArray(e) || t === "object" ? !1 : t !== "function";
+}, S = class e {
+	constructor(t, n) {
+		if (new.target === e) throw TypeError("StorageProvider is abstract. Extend this class to implement it");
+		this.namespace = t || null, this.registry = n || (		/* istanbul ignore next */ {});
+	}
+	register(e, t) {
+		this.registry[e] = t;
+	}
+	upgradeToRealStorage() {
+		return !1;
+	}
+	isUsingFakeStorage() {
+		return !1;
+	}
+}, C = class extends S {
+	constructor(e, t = {}) {
+		super(e, t), this.storage = o, this._isUsingFakeStorage = !0;
+	}
+	getStorage() {
+		return m() ? window.localStorage : o;
+	}
+	setNamespace(e) {
+		if (!this.namespace) {
+			this.namespace = e;
+			return;
+		}
+		if (this.namespace === e) return;
+		let t = JSON.parse(JSON.stringify(this.getAll()));
+		this.removeAll();
+		for (let [n, r] of Object.entries(t)) {
+			let t = n.replace(this.namespace, e);
+			this.setItem(t, r);
+		}
+		this.namespace = e;
+	}
+	getItem(e) {
+		let t = this.storage.getItem(e);
+		if (t == null) return null;
+		try {
+			return JSON.parse(t);
+		} catch {
+			return t;
+		}
+	}
+	setItem(e, t) {
+		return t == null ? this.removeItem(e) : this.storage.setItem(e, JSON.stringify(t));
+	}
+	removeItem(e, t = !1) {
+		return t && delete this.registry[e], this.storage.removeItem(e);
+	}
+	getAll() {
+		let e = `${this.namespace}.`;
+		return Object.keys(this.storage).reduce((t, n) => ((!this.namespace || n.startsWith(e)) && (t[n] = this.storage.getItem(n)), t), {});
+	}
+	_resetAll(e = !0, t = [], n = !1) {
+		let r = `${this.namespace}.`;
+		Object.keys(this.storage).forEach((i) => {
+			let a = this.namespace ? i.startsWith(r) : !0, o = t?.includes(i) || !1;
+			!a || o || (e ? Object.hasOwn(this.registry, i) ? this.registry[i] === void 0 || this.registry[i] === null ? this.storage.removeItem(i) : this.storage.setItem(i, JSON.stringify(this.registry[i])) : this.storage.removeItem(i) : (this.storage.removeItem(i), n && delete this.registry[i]));
+		});
+	}
+	resetAll(e = [], t = !1) {
+		this._resetAll(!0, e || [], t);
+	}
+	removeAll(e = [], t = !1) {
+		this._resetAll(!1, e || [], t);
+	}
+	upgradeToRealStorage() {
+		return !this._isUsingFakeStorage || !m() ? !1 : (this.storage = window.localStorage, this._isUsingFakeStorage = !1, !0);
+	}
+	isUsingFakeStorage() {
+		return this._isUsingFakeStorage;
+	}
+}, w = Math.random().toString(36).substring(7), T = (...e) => {
+	typeof globalThis < "u" && globalThis.__RWP_LOGGING_ENABLED__ !== !1 && console.log(...e);
+}, E = {
+	logging: { enabled: !1 },
+	storageProvider: C
+}, D = { ...E }, O, k = [];
+typeof globalThis < "u" && globalThis.__RWP_LOGGING_ENABLED__ === void 0 && (globalThis.__RWP_LOGGING_ENABLED__ = E.logging.enabled), T("[RWP] Module initialized, instance ID:", w), T("[RWP] About to check global storage, instanceId:", w);
+try {
+	globalThis.__RWP_STORAGE__ ? T("[RWP] Using existing global storage in instance:", w) : (T("[RWP] Creating global storage in instance:", w), globalThis.__RWP_STORAGE__ = new C("__internal_rwp_storage__")), O = globalThis.__RWP_STORAGE__, T("[RWP] InternalStorage assigned successfully");
+} catch (e) {
+	globalThis.__RWP_LOGGING_ENABLED__ && console.error("[RWP] Error setting up global storage:", e), O = new C("__internal_rwp_storage__");
 }
-export {
-  D as HydrationProvider,
-  W as createPersistedWire,
-  L as defaultOptions,
-  P as getNamespace,
-  $ as getOptions,
-  V as getStorage,
-  C as setNamespace,
-  H as setOptions,
-  K as upgradeStorage,
-  J as useHydration,
-  k as utils
+typeof globalThis < "u" && (globalThis.__RWP_REGISTERED_WIRES__ ? T("[RWP] Using existing global registeredWires in instance:", w) : (T("[RWP] Creating global registeredWires in instance:", w), globalThis.__RWP_REGISTERED_WIRES__ = /* @__PURE__ */ new Map()));
+var A = globalThis.__RWP_REGISTERED_WIRES__ || /* @__PURE__ */ new Map();
+T("[RWP] registeredWires Map reference in instance:", w, "size:", A.size);
+var j = () => O.namespace, M = () => O, N = (e) => {
+	T("[RWP] setNamespace() called with:", e, "registered wires before:", A.size);
+	let t = e || j();
+	if (!t) throw Error("react-wire-persisted: Cannot set namespace to null or undefined");
+	O.setNamespace(e), O = new C(t), T("[RWP] setNamespace() done, registered wires after:", A.size);
+}, P = () => D, F = (e) => {
+	/* istanbul ignore next */
+	if (D = {
+		...D,
+		...e
+	}, typeof globalThis < "u" && (globalThis.__RWP_LOGGING_ENABLED__ = D.logging.enabled), D.logging.enabled) for (console.info("Flushing", k.length, "pending logs"); k.length;)
+ /* istanbul ignore next */
+	console.log(...k.shift() || []);
+}, I = () => {
+	T("[RWP] refreshAllWires() called in instance:", w, "registered wires:", A.size), R("react-wire-persisted: refreshAllWires() called, registered wires:", A.size), A.forEach((e, t) => {
+		let n = O.getItem(t), r = e.getValue();
+		T("[RWP] Checking wire", t, {
+			storedValue: n,
+			currentValue: r,
+			willUpdate: n !== null && n !== r
+		}), R("react-wire-persisted: Checking wire", t, {
+			storedValue: n,
+			currentValue: r,
+			willUpdate: n !== null && n !== r
+		}), n !== null && n !== r && (T("[RWP] Refreshing wire", t, "with stored value", n), R("react-wire-persisted: Refreshing wire", t, "with stored value", n), e.setValue(n));
+	});
+}, L = () => {
+	if (T("[RWP] upgradeStorage() called in instance:", w, {
+		isClient: u(),
+		isUsingFakeStorage: O.isUsingFakeStorage()
+	}), R("react-wire-persisted: upgradeStorage() called", {
+		isClient: u(),
+		isUsingFakeStorage: O.isUsingFakeStorage()
+	}), !u()) return !1;
+	let e = O.upgradeToRealStorage();
+	return T("[RWP] upgradeToRealStorage() returned", e), R("react-wire-persisted: upgradeToRealStorage() returned", e), e && (p(), T("[RWP] Upgraded to real localStorage, calling refreshAllWires()"), R("react-wire-persisted: Upgraded to real localStorage after hydration"), I()), e;
+}, R = (...e) => {
+	/* istanbul ignore next */
+	D.logging.enabled ? console.log(...e) : k.push(e);
+}, z = (e, t = null) => {
+	if (T("[RWP] createPersistedWire() called in instance:", w, "key:", e, "value:", t), !e) throw Error(`createPersistedWire: Key cannot be a falsey value (${e}}`);
+	O.register(e, t);
+	let r = n(t), i = () => r.getValue(), a = (t) => (T("[RWP] setValue called in instance:", w, "key:", e, "isUsingFakeStorage:", O.isUsingFakeStorage()), O.setItem(e, t), r.setValue(t)), o = (e) => r.subscribe(e), s = t, c = f() || !O.isUsingFakeStorage();
+	if (c && u()) {
+		let t = O.getItem(e);
+		t !== null && (s = t);
+	}
+	return R("react-wire-persisted: create", e, {
+		value: t,
+		initialValue: s,
+		hasHydratedStorage: f(),
+		isUsingFakeStorage: O.isUsingFakeStorage(),
+		canReadStorage: c
+	}), s !== t && s !== void 0 && a(s), A.set(e, {
+		getValue: i,
+		setValue: a,
+		subscribe: o
+	}), T("[RWP] Wire registered, total wires:", A.size, "keys:", Array.from(A.keys())), {
+		...r,
+		getValue: i,
+		setValue: a,
+		subscribe: o
+	};
+}, B = (n = {}) => {
+	let { autoUpgrade: r = !0, onUpgrade: i } = n, a = t(!1);
+	return e(() => {
+		if (!r || a.current || !u()) return;
+		let e = () => {
+			d() && !a.current && L() && (a.current = !0, i?.());
+		};
+		e();
+		let t = setTimeout(e, 0);
+		return () => clearTimeout(t);
+	}, [r, i]), { hasUpgraded: a.current };
+}, V = ({ children: e, onUpgrade: t, autoUpgrade: n = !0 }) => (B({
+	onUpgrade: t,
+	autoUpgrade: n
+}), e), H = class extends C {
+	constructor(e, t = {}) {
+		super(e, t);
+	}
+	getStorage() {
+		return o;
+	}
 };
+//#endregion
+export { V as HydrationProvider, C as LocalStorageProvider, H as MemoryStorageProvider, S as RWPStorageProvider, z as createPersistedWire, E as defaultOptions, j as getNamespace, P as getOptions, M as getStorage, N as setNamespace, F as setOptions, L as upgradeStorage, B as useHydration, b as utils };
+
+//# sourceMappingURL=react-wire-persisted.js.map