gjendje 1.0.1 → 1.0.3

package/dist/{chunk-QSE3476L.js → chunk-ALDPHYTI.js}

@@ -46,8 +46,15 @@ function flush() {
 
 // src/config.ts
 var globalConfig = {};
+var PERSISTENT_SCOPES = /* @__PURE__ */ new Set(["local", "session", "bucket"]);
 function configure(config) {
   globalConfig = { ...globalConfig, ...config };
+  if (globalConfig.registry === false && globalConfig.scope && PERSISTENT_SCOPES.has(globalConfig.scope)) {
+    log(
+      "warn",
+      `registry: false has no effect on scope "${globalConfig.scope}" \u2014 persistent scopes always use the registry.`
+    );
+  }
 }
 function getConfig() {
   return globalConfig;
@@ -65,6 +72,7 @@ function reportError(key, scope, error) {
 }
 
 // src/utils.ts
+var RESOLVED = Promise.resolve();
 function isRecord(value) {
   return value !== null && typeof value === "object";
 }
@@ -116,16 +124,19 @@ function createLazyDestroyed() {
 }
 
 // src/listeners.ts
+function safeCall(listener, value) {
+  try {
+    listener(value);
+  } catch (err) {
+    console.error("[gjendje] Listener threw:", err);
+  }
+}
 function createListeners() {
   const set = /* @__PURE__ */ new Set();
   return {
     notify(value) {
       for (const listener of set) {
-        try {
-          listener(value);
-        } catch (err) {
-          console.error("[gjendje] Listener threw:", err);
-        }
+        safeCall(listener, value);
       }
     },
     subscribe(listener) {
@@ -148,14 +159,9 @@ var registry = /* @__PURE__ */ new Map();
 function getRegistered(rKey) {
   return registry.get(rKey);
 }
-function registerByKey(rKey, key, scope, instance, config) {
-  const existing = registry.get(rKey);
+function registerNew(rKey, key, scope, instance, config, existing) {
   if (existing !== void 0) {
-    if (existing.isDestroyed) {
-      registry.set(rKey, instance);
-    } else if (config.warnOnDuplicate) {
-      log("warn", `Duplicate state("${key}") with scope "${scope}". Returning cached instance.`);
-    }
+    registry.set(rKey, instance);
     return;
   }
   if (config.maxKeys !== void 0 && registry.size >= config.maxKeys) {
@@ -218,7 +224,6 @@ function readAndMigrate(raw, options, key, scope) {
       storedVersion = parsed.v;
       data = parsed.data;
     } else {
-      storedVersion = 1;
       data = parsed;
     }
     if (storedVersion < currentVersion && options.migrate) {
@@ -329,8 +334,8 @@ function createStorageAdapter(storage, key, options) {
       const toStore = pickKeys(value, persist);
       const raw = serialize ? serialize.stringify(toStore) : wrapForStorage(toStore, version);
       storage.setItem(key, raw);
-      cachedRaw = void 0;
-      cachedValue = void 0;
+      cachedRaw = raw;
+      cachedValue = persist ? mergeKeys(toStore, defaultValue, persist) : value;
     } catch (e) {
       cachedRaw = void 0;
       cachedValue = void 0;
@@ -357,7 +362,7 @@ function createStorageAdapter(storage, key, options) {
     window.addEventListener("storage", onStorageEvent);
   }
   return {
-    ready: Promise.resolve(),
+    ready: RESOLVED,
     get() {
       return read();
     },
@@ -506,17 +511,12 @@ function createBucketAdapter(key, bucketOptions, options) {
 }
 
 // src/adapters/memory.ts
-var RESOLVED = Promise.resolve();
 function createMemoryAdapter(defaultValue) {
   let current = defaultValue;
   const listeners = /* @__PURE__ */ new Set();
   const notifyListeners = () => {
     for (const listener of listeners) {
-      try {
-        listener(current);
-      } catch (err) {
-        console.error("[gjendje] Listener threw:", err);
-      }
+      safeCall(listener, current);
     }
   };
   return {
@@ -553,8 +553,8 @@ function withSync(adapter, key, scope) {
     channel.onmessage = (event) => {
       if (isDestroyed) return;
       const msg = event.data;
-      if (msg == null || typeof msg !== "object" || !("value" in msg)) return;
-      if (Object.keys(msg).length !== 1) return;
+      if (msg == null || typeof msg !== "object" || !("value" in msg) || Object.keys(msg).length !== 1)
+        return;
       const value = msg.value;
       try {
         adapter.set(value);
@@ -603,12 +603,23 @@ function createUrlAdapter(key, defaultValue, serializer, persist) {
   }
   const listeners = createListeners();
   const defaultSerialized = serializer.stringify(defaultValue);
+  let cachedSearch;
+  let cachedValue = defaultValue;
   function read() {
     try {
-      const params = new URLSearchParams(window.location.search);
+      const search = window.location.search;
+      if (search === cachedSearch) return cachedValue;
+      const params = new URLSearchParams(search);
       const raw = params.get(key);
-      if (raw === null) return defaultValue;
-      return mergeKeys(serializer.parse(raw), defaultValue, persist);
+      if (raw === null) {
+        cachedSearch = search;
+        cachedValue = defaultValue;
+        return defaultValue;
+      }
+      const value = mergeKeys(serializer.parse(raw), defaultValue, persist);
+      cachedSearch = search;
+      cachedValue = value;
+      return value;
     } catch {
       return defaultValue;
     }
@@ -627,18 +638,22 @@ function createUrlAdapter(key, defaultValue, serializer, persist) {
       const search = params.toString();
       const newUrl = search ? `${window.location.pathname}?${search}${window.location.hash}` : `${window.location.pathname}${window.location.hash}`;
       window.history.pushState(null, "", newUrl);
+      cachedSearch = search ? `?${search}` : "";
+      cachedValue = persist ? mergeKeys(toStore, defaultValue, persist) : value;
     } catch {
+      cachedSearch = void 0;
     }
   }
   let lastNotifiedValue = defaultValue;
   const notifyListeners = () => listeners.notify(lastNotifiedValue);
   function onPopState() {
+    cachedSearch = void 0;
     lastNotifiedValue = read();
     notify(notifyListeners);
   }
   window.addEventListener("popstate", onPopState);
   return {
-    ready: Promise.resolve(),
+    ready: RESOLVED,
     get() {
       return read();
     },
@@ -661,7 +676,7 @@ function isServer() {
 }
 var BROWSER_SCOPES = /* @__PURE__ */ new Set(["session", "local", "url", "bucket"]);
 function afterHydration(fn) {
-  if (isServer()) return Promise.resolve();
+  if (isServer()) return RESOLVED;
   return new Promise((resolve) => {
     Promise.resolve().then(() => {
       if (typeof requestAnimationFrame !== "undefined") {
@@ -684,11 +699,10 @@ var _serverAdapterFactory;
 function registerServerAdapter(factory) {
   _serverAdapterFactory = factory;
 }
-var PERSISTENT_SCOPES = /* @__PURE__ */ new Set(["local", "session", "bucket"]);
+var PERSISTENT_SCOPES2 = /* @__PURE__ */ new Set(["local", "session", "bucket"]);
 var SYNCABLE_SCOPES = /* @__PURE__ */ new Set(["local", "bucket"]);
-var RESOLVED2 = Promise.resolve();
 var MEMORY_SHIM = {
-  ready: RESOLVED2,
+  ready: RESOLVED,
   get: () => void 0,
   set: () => {
   },
@@ -723,10 +737,7 @@ function resolveAdapter(storageKey, scope, options) {
       return createUrlAdapter(
         storageKey,
         options.default,
-        options.serialize ?? {
-          stringify: (v) => JSON.stringify(v),
-          parse: (s) => JSON.parse(s)
-        },
+        options.serialize ?? { stringify: JSON.stringify, parse: JSON.parse },
         options.persist
       );
     case "server":
@@ -759,7 +770,7 @@ var StateImpl = class {
   _rKey;
   _config;
   _s;
-  constructor(key, scope, rKey, adapter, options, config) {
+  constructor(key, scope, rKey, adapter, options, config, preallocatedState) {
     this.key = key;
     this.scope = scope;
     this._rKey = rKey;
@@ -767,12 +778,12 @@ var StateImpl = class {
     this._defaultValue = options.default;
     this._options = options;
     this._config = config;
-    this._s = {
+    this._s = preallocatedState ?? {
       lastValue: adapter.get(),
       isDestroyed: false,
       interceptors: void 0,
       changeHandlers: void 0,
-      settled: RESOLVED2,
+      settled: RESOLVED,
       resolveDestroyed: void 0,
       destroyed: void 0,
       hydrated: void 0,
@@ -847,7 +858,7 @@ var StateImpl = class {
     return this._s.settled;
   }
   get hydrated() {
-    return this._s.hydrated ?? RESOLVED2;
+    return this._s.hydrated ?? RESOLVED;
   }
   get destroyed() {
     const s = this._s;
@@ -917,7 +928,7 @@ var StateImpl = class {
     if (s.resolveDestroyed) {
       s.resolveDestroyed();
     } else {
-      s.destroyed = RESOLVED2;
+      s.destroyed = RESOLVED;
     }
   }
   _ensureWatchSubscription() {
@@ -932,33 +943,70 @@ var StateImpl = class {
     });
   }
 };
+function getExt(c) {
+  if (c.ext === void 0) {
+    c.ext = {
+      interceptors: void 0,
+      changeHandlers: void 0,
+      watchers: void 0,
+      watchUnsub: void 0,
+      watchPrev: void 0,
+      resolveDestroyed: void 0,
+      destroyed: void 0
+    };
+  }
+  return c.ext;
+}
+var MEMORY_MUTABLE_SHIM = {
+  lastValue: void 0,
+  isDestroyed: false,
+  interceptors: void 0,
+  changeHandlers: void 0,
+  settled: RESOLVED,
+  resolveDestroyed: void 0,
+  destroyed: void 0,
+  hydrated: void 0,
+  watchers: void 0,
+  watchUnsub: void 0,
+  watchPrev: void 0
+};
 var MemoryStateImpl = class extends StateImpl {
-  // Direct reference — avoids a getter cast on every get()/set() call
-  _r;
+  _c;
   _hasIsEqual;
   constructor(key, rKey, options, config) {
-    super(key, "memory", rKey, MEMORY_SHIM, options, config);
-    const rs = this._s;
-    rs.current = options.default;
-    rs.memoryListeners = void 0;
-    rs.notifyFn = void 0;
-    this._r = rs;
+    super(
+      key,
+      "memory",
+      rKey,
+      MEMORY_SHIM,
+      options,
+      config,
+      MEMORY_MUTABLE_SHIM
+    );
+    this._c = {
+      current: options.default,
+      isDestroyed: false,
+      listeners: void 0,
+      notifyFn: void 0,
+      ext: void 0
+    };
     this._hasIsEqual = options.isEqual !== void 0;
   }
   get() {
-    return this._r.current;
+    return this._c.current;
   }
   peek() {
-    return this._r.current;
+    return this._c.current;
   }
   set(valueOrUpdater) {
-    const s = this._r;
-    if (s.isDestroyed) return;
-    const prev = s.current;
+    const c = this._c;
+    if (c.isDestroyed) return;
+    const prev = c.current;
     let next = typeof valueOrUpdater === "function" ? valueOrUpdater(prev) : valueOrUpdater;
-    if (s.interceptors !== void 0 && s.interceptors.size > 0) {
+    const ext = c.ext;
+    if (ext !== void 0 && ext.interceptors !== void 0 && ext.interceptors.size > 0) {
       const original = next;
-      for (const interceptor of s.interceptors) {
+      for (const interceptor of ext.interceptors) {
         next = interceptor(next, prev);
       }
       if (!Object.is(original, next)) {
@@ -971,46 +1019,43 @@ var MemoryStateImpl = class extends StateImpl {
       }
     }
     if (this._hasIsEqual && this._options.isEqual?.(next, prev)) return;
-    s.current = next;
-    if (s.notifyFn !== void 0) {
-      notify(s.notifyFn);
+    c.current = next;
+    if (c.notifyFn !== void 0) {
+      notify(c.notifyFn);
     }
-    if (s.changeHandlers !== void 0 && s.changeHandlers.size > 0) {
-      for (const hook of s.changeHandlers) {
+    if (ext !== void 0 && ext.changeHandlers !== void 0 && ext.changeHandlers.size > 0) {
+      for (const hook of ext.changeHandlers) {
         hook(next, prev);
       }
     }
     this._config.onChange?.({ key: this.key, scope: this.scope, value: next, previousValue: prev });
   }
   subscribe(listener) {
-    const s = this._r;
-    if (!s.memoryListeners) {
+    const c = this._c;
+    if (!c.listeners) {
       const listeners = /* @__PURE__ */ new Set();
-      s.memoryListeners = listeners;
-      s.notifyFn = () => {
+      c.listeners = listeners;
+      c.notifyFn = () => {
         for (const l of listeners) {
-          try {
-            l(s.current);
-          } catch (err) {
-            console.error("[gjendje] Listener threw:", err);
-          }
+          safeCall(l, c.current);
         }
       };
     }
-    const set = s.memoryListeners;
+    const set = c.listeners;
     set.add(listener);
     return () => {
       set.delete(listener);
     };
   }
   reset() {
-    const s = this._r;
-    if (s.isDestroyed) return;
-    const prev = s.current;
+    const c = this._c;
+    if (c.isDestroyed) return;
+    const prev = c.current;
     let next = this._defaultValue;
-    if (s.interceptors !== void 0 && s.interceptors.size > 0) {
+    const ext = c.ext;
+    if (ext !== void 0 && ext.interceptors !== void 0 && ext.interceptors.size > 0) {
       const original = next;
-      for (const interceptor of s.interceptors) {
+      for (const interceptor of ext.interceptors) {
         next = interceptor(next, prev);
       }
       if (!Object.is(original, next)) {
@@ -1023,12 +1068,12 @@ var MemoryStateImpl = class extends StateImpl {
       }
     }
     if (this._hasIsEqual && this._options.isEqual?.(next, prev)) return;
-    s.current = next;
-    if (s.notifyFn !== void 0) {
-      notify(s.notifyFn);
+    c.current = next;
+    if (c.notifyFn !== void 0) {
+      notify(c.notifyFn);
     }
-    if (s.changeHandlers !== void 0 && s.changeHandlers.size > 0) {
-      for (const hook of s.changeHandlers) {
+    if (ext !== void 0 && ext.changeHandlers !== void 0 && ext.changeHandlers.size > 0) {
+      for (const hook of ext.changeHandlers) {
         hook(next, prev);
       }
     }
@@ -1036,39 +1081,82 @@ var MemoryStateImpl = class extends StateImpl {
     this._config.onChange?.({ key: this.key, scope: this.scope, value: next, previousValue: prev });
   }
   get ready() {
-    return RESOLVED2;
+    return RESOLVED;
+  }
+  get settled() {
+    return RESOLVED;
+  }
+  get hydrated() {
+    return RESOLVED;
+  }
+  get isDestroyed() {
+    return this._c.isDestroyed;
+  }
+  get destroyed() {
+    if (this._c.isDestroyed) return RESOLVED;
+    const ext = getExt(this._c);
+    if (!ext.destroyed) {
+      ext.destroyed = new Promise((resolve) => {
+        ext.resolveDestroyed = resolve;
+      });
+    }
+    return ext.destroyed;
+  }
+  intercept(fn) {
+    const ext = getExt(this._c);
+    if (!ext.interceptors) ext.interceptors = /* @__PURE__ */ new Set();
+    ext.interceptors.add(fn);
+    return () => {
+      ext.interceptors?.delete(fn);
+    };
+  }
+  onChange(fn) {
+    const ext = getExt(this._c);
+    if (!ext.changeHandlers) ext.changeHandlers = /* @__PURE__ */ new Set();
+    ext.changeHandlers.add(fn);
+    return () => {
+      ext.changeHandlers?.delete(fn);
+    };
+  }
+  watch(watchKey, listener) {
+    const ext = getExt(this._c);
+    if (!ext.watchers) ext.watchers = /* @__PURE__ */ new Map();
+    this._ensureWatchSubscription();
+    return addWatcher(ext.watchers, watchKey, listener);
   }
   _ensureWatchSubscription() {
-    const s = this._r;
-    if (s.watchUnsub) return;
-    s.watchPrev = s.current;
-    s.watchUnsub = this.subscribe((next) => {
-      if (s.watchers && s.watchers.size > 0) {
-        notifyWatchers(s.watchers, s.watchPrev, next);
+    const ext = getExt(this._c);
+    if (ext.watchUnsub) return;
+    ext.watchPrev = this._c.current;
+    ext.watchUnsub = this.subscribe((next) => {
+      if (ext.watchers && ext.watchers.size > 0) {
+        notifyWatchers(ext.watchers, ext.watchPrev, next);
       }
-      s.watchPrev = next;
+      ext.watchPrev = next;
     });
   }
   destroy() {
-    const s = this._r;
-    if (s.isDestroyed) return;
-    s.lastValue = s.current;
-    s.isDestroyed = true;
-    s.interceptors?.clear();
-    s.changeHandlers?.clear();
-    s.watchers?.clear();
-    s.watchUnsub?.();
-    s.memoryListeners?.clear();
-    unregisterByKey(this._rKey);
+    const c = this._c;
+    if (c.isDestroyed) return;
+    c.isDestroyed = true;
+    const ext = c.ext;
+    if (ext !== void 0) {
+      ext.interceptors?.clear();
+      ext.changeHandlers?.clear();
+      ext.watchers?.clear();
+      ext.watchUnsub?.();
+    }
+    c.listeners?.clear();
+    if (this._rKey) unregisterByKey(this._rKey);
     this._config.onDestroy?.({ key: this.key, scope: this.scope });
-    if (s.resolveDestroyed) {
-      s.resolveDestroyed();
-    } else {
-      s.destroyed = RESOLVED2;
+    if (ext?.resolveDestroyed) {
+      ext.resolveDestroyed();
+    } else if (ext !== void 0) {
+      ext.destroyed = RESOLVED;
     }
   }
 };
-function resolveKeyAndScope(key, options) {
+function createBase(key, options) {
   if (!key) {
     throw new Error("[gjendje] key must be a non-empty string.");
   }
@@ -1080,19 +1168,37 @@ function resolveKeyAndScope(key, options) {
   }
   const rawScope = options.scope ?? config.scope ?? "memory";
   const scope = rawScope === "render" ? "memory" : rawScope;
+  if (scope === "memory") {
+    if (options.sync || config.sync) {
+      log(
+        "warn",
+        `sync: true is ignored for scope "memory". Only "local" and "bucket" scopes support cross-tab sync.`
+      );
+    }
+    if (config.registry === false) {
+      return new MemoryStateImpl(key, "", options, config);
+    }
+    const rKey2 = scopedKey(key, scope);
+    const existing2 = getRegistered(rKey2);
+    if (existing2 && !existing2.isDestroyed) {
+      if (config.warnOnDuplicate) {
+        log("warn", `Duplicate state("${key}") with scope "${scope}". Returning cached instance.`);
+      }
+      return existing2;
+    }
+    const instance2 = new MemoryStateImpl(key, rKey2, options, config);
+    registerNew(rKey2, key, scope, instance2, config, existing2);
+    return instance2;
+  }
   const rKey = scopedKey(key, scope);
   const existing = getRegistered(rKey);
-  return { config, scope, rKey, existing };
-}
-function createBase(key, options) {
-  const { config, scope, rKey, existing } = resolveKeyAndScope(key, options);
   if (existing && !existing.isDestroyed) {
     if (config.warnOnDuplicate) {
       log("warn", `Duplicate state("${key}") with scope "${scope}". Returning cached instance.`);
     }
     return existing;
   }
-  if (config.requireValidation && PERSISTENT_SCOPES.has(scope) && !options.validate) {
+  if (config.requireValidation && PERSISTENT_SCOPES2.has(scope) && !options.validate) {
     throw new Error(
       `[gjendje] A validate function is required for persisted scope "${scope}" on state("${key}"). Set requireValidation: false in configure() to disable.`
     );
@@ -1106,44 +1212,39 @@ function createBase(key, options) {
       `sync: true is ignored for scope "${scope}". Only "local" and "bucket" scopes support cross-tab sync.`
     );
   }
-  let instance;
-  if (scope === "memory" && !isSsrMode) {
-    instance = new MemoryStateImpl(key, rKey, options, config);
-  } else {
-    const storageKey = resolveStorageKey(key, options, config.prefix);
-    const baseAdapter = useMemoryFallback ? createMemoryAdapter(options.default) : resolveAdapter(storageKey, scope, options);
-    const shouldSync = effectiveSync && SYNCABLE_SCOPES.has(scope) && !useMemoryFallback;
-    const adapter = shouldSync ? withSync(baseAdapter, storageKey, scope) : baseAdapter;
-    instance = new StateImpl(key, scope, rKey, adapter, options, config);
-    if (isSsrMode && !isServer()) {
-      instance._s.hydrated = afterHydration(() => {
-        if (instance.isDestroyed) return;
-        const currentValue = instance.get();
-        if (!shallowEqual(currentValue, options.default)) return;
-        let realAdapter;
-        try {
-          realAdapter = resolveAdapter(storageKey, scope, options);
-          const storedValue = realAdapter.get();
-          if (!shallowEqual(storedValue, options.default)) {
-            instance.set(storedValue);
-          }
-          config.onHydrate?.({
-            key,
-            scope,
-            serverValue: options.default,
-            clientValue: storedValue
-          });
-        } catch (err) {
-          log("debug", `Hydration adapter unavailable for state("${key}") \u2014 using memory fallback.`);
-          reportError(key, scope, err);
-        } finally {
-          realAdapter?.destroy?.();
+  const storageKey = resolveStorageKey(key, options, config.prefix);
+  const baseAdapter = useMemoryFallback ? createMemoryAdapter(options.default) : resolveAdapter(storageKey, scope, options);
+  const shouldSync = effectiveSync && SYNCABLE_SCOPES.has(scope) && !useMemoryFallback;
+  const adapter = shouldSync ? withSync(baseAdapter, storageKey, scope) : baseAdapter;
+  const instance = new StateImpl(key, scope, rKey, adapter, options, config);
+  if (isSsrMode && !isServer()) {
+    instance._s.hydrated = afterHydration(() => {
+      if (instance.isDestroyed) return;
+      const currentValue = instance.get();
+      if (!shallowEqual(currentValue, options.default)) return;
+      let realAdapter;
+      try {
+        realAdapter = resolveAdapter(storageKey, scope, options);
+        const storedValue = realAdapter.get();
+        if (!shallowEqual(storedValue, options.default)) {
+          instance.set(storedValue);
         }
-      });
-    }
+        config.onHydrate?.({
+          key,
+          scope,
+          serverValue: options.default,
+          clientValue: storedValue
+        });
+      } catch (err) {
+        log("debug", `Hydration adapter unavailable for state("${key}") \u2014 using memory fallback.`);
+        reportError(key, scope, err);
+      } finally {
+        realAdapter?.destroy?.();
+      }
+    });
   }
-  registerByKey(rKey, key, scope, instance, config);
+  registerNew(rKey, key, scope, instance, config, existing);
   return instance;
 }
 
-export { addWatcher, batch, configure, createBase, createLazyDestroyed, createListeners, getRegistry, isRecord, notify, notifyWatchers, registerServerAdapter, shallowEqual };
+export { RESOLVED, addWatcher, batch, configure, createBase, createLazyDestroyed, createListeners, getRegistry, isRecord, notify, notifyWatchers, registerServerAdapter, shallowEqual };