gjendje 1.3.0 → 1.3.2

package/dist/{chunk-ARCB4TVB.cjs → chunk-3YGK3425.cjs}

@@ -4,7 +4,14 @@
 var globalConfig = {};
 var PERSISTENT_SCOPES = /* @__PURE__ */ new Set(["local", "session", "bucket"]);
 function configure(config) {
-  globalConfig = { ...globalConfig, ...config };
+  for (const key of Object.keys(config)) {
+    const value = config[key];
+    if (value === void 0) {
+      delete globalConfig[key];
+    } else {
+      globalConfig[key] = value;
+    }
+  }
   if (globalConfig.registry === false && globalConfig.scope && PERSISTENT_SCOPES.has(globalConfig.scope)) {
     log(
       "warn",
@@ -12,6 +19,9 @@ function configure(config) {
     );
   }
 }
+function resetConfig() {
+  globalConfig = {};
+}
 function getConfig() {
   return globalConfig;
 }
@@ -102,16 +112,27 @@ function unregisterByKey(rKey) {
 function getRegistry() {
   return registry;
 }
+function destroyAll() {
+  const instances = [...registry.values()];
+  for (const instance of instances) {
+    if (!instance.isDestroyed) {
+      instance.destroy();
+    }
+  }
+  registry.clear();
+}
 
 exports.PERSISTENT_SCOPES = PERSISTENT_SCOPES;
 exports.configure = configure;
 exports.createListeners = createListeners;
+exports.destroyAll = destroyAll;
 exports.getConfig = getConfig;
 exports.getRegistered = getRegistered;
 exports.getRegistry = getRegistry;
 exports.log = log;
 exports.registerNew = registerNew;
 exports.reportError = reportError;
+exports.resetConfig = resetConfig;
 exports.safeCall = safeCall;
 exports.safeCallChange = safeCallChange;
 exports.safeCallConfig = safeCallConfig;

package/dist/{chunk-UEEINLOF.js → chunk-JRTZTDT6.js}

@@ -1,4 +1,4 @@
-import { safeCall, getConfig, log, scopedKey, getRegistered, registerNew, PERSISTENT_SCOPES, reportError, safeCallConfig, safeCallChange, unregisterByKey, createListeners } from './chunk-FAISWCIZ.js';
+import { safeCall, getConfig, log, scopedKey, getRegistered, registerNew, PERSISTENT_SCOPES, reportError, safeCallConfig, safeCallChange, unregisterByKey, createListeners } from './chunk-YPT6TO4H.js';
 
 // src/batch.ts
 var depth = 0;
@@ -24,8 +24,27 @@ function notify(fn) {
   }
   fn();
 }
+var MAX_FLUSH_ITERATIONS = 100;
 function flush() {
+  let iterations = 0;
   while (queue.length > 0) {
+    if (++iterations > MAX_FLUSH_ITERATIONS) {
+      console.error(
+        "[gjendje] Batch flush exceeded maximum iterations \u2014 possible infinite loop. Delivering remaining notifications once before stopping."
+      );
+      const remaining = queue;
+      queue = [];
+      for (let i = 0; i < remaining.length; i++) {
+        const fn = remaining[i];
+        try {
+          if (fn) fn();
+        } catch (err) {
+          console.error("[gjendje] Notification threw during best-effort delivery:", err);
+        }
+      }
+      queue = [];
+      break;
+    }
     generation++;
     const current = queue;
     queue = [];
@@ -64,6 +83,28 @@ function shallowEqual(a, b) {
     return true;
   }
   if (Array.isArray(b)) return false;
+  if (a instanceof Set) {
+    if (!(b instanceof Set)) return false;
+    if (a.size !== b.size) return false;
+    for (const item of a) {
+      if (!b.has(item)) return false;
+    }
+    return true;
+  }
+  if (a instanceof Map) {
+    if (!(b instanceof Map)) return false;
+    if (a.size !== b.size) return false;
+    for (const [key, val] of a) {
+      if (!b.has(key) || !Object.is(val, b.get(key))) return false;
+    }
+    return true;
+  }
+  if (a instanceof Date) {
+    return b instanceof Date && a.getTime() === b.getTime();
+  }
+  if (a instanceof RegExp) {
+    return b instanceof RegExp && a.toString() === b.toString();
+  }
   const objA = a;
   const objB = b;
   const keysA = Object.keys(objA);
@@ -210,9 +251,9 @@ function notifyWatchers(watchers, prev, next) {
 // src/persist.ts
 function isVersionedValue(value) {
   if (!isRecord(value)) return false;
-  return "v" in value && "data" in value && Number.isSafeInteger(value.v);
+  return Object.keys(value).length === 2 && "v" in value && "data" in value && Number.isSafeInteger(value.v);
 }
-function readAndMigrate(raw, options, key, scope) {
+function readAndMigrate(raw, options, key, scope, onFallback) {
   const currentVersion = options.version ?? 1;
   const defaultValue = options.default;
   try {
@@ -244,6 +285,7 @@ function readAndMigrate(raw, options, key, scope) {
         const validationErr = new ValidationError(key, scope, data);
         safeCallConfig(config.onError, { key, scope, error: validationErr });
       }
+      onFallback?.();
       return defaultValue;
     }
     return data;
@@ -253,6 +295,7 @@ function readAndMigrate(raw, options, key, scope) {
       const readErr = new StorageReadError(key, scope, err);
       safeCallConfig(getConfig().onError, { key, scope, error: readErr });
     }
+    onFallback?.();
     return defaultValue;
   }
 }
@@ -290,12 +333,12 @@ function runMigrations(data, fromVersion, toVersion, migrations, key, scope) {
       try {
         current = migrateFn(current);
       } catch (err) {
-        log("warn", `Migration from v${v} failed \u2014 returning partially migrated value.`);
+        log("warn", `Migration from v${v} failed \u2014 discarding partially migrated data.`);
+        const migrationErr = new MigrationError(key ?? "", scope ?? "memory", v, toVersion, err);
         if (key && scope) {
-          const migrationErr = new MigrationError(key, scope, v, toVersion, err);
           safeCallConfig(getConfig().onError, { key, scope, error: migrationErr });
         }
-        return current;
+        throw migrationErr;
       }
     }
   }
@@ -309,11 +352,40 @@ function createStorageAdapter(storage, key, options) {
   let cachedRaw;
   let cachedValue;
   let cacheValid = false;
+  const backupKey = `${key}:__gjendje_backup`;
+  function backupRawData(raw) {
+    try {
+      if (storage.getItem(backupKey) === null) {
+        storage.setItem(backupKey, raw);
+        log(
+          "warn",
+          `Original data for key "${key}" backed up to "${backupKey}" after migration/validation failure.`
+        );
+      }
+    } catch (backupErr) {
+      const scope = options.scope ?? "local";
+      log(
+        "error",
+        `Failed to backup data for key "${key}" to "${backupKey}" \u2014 original data may be lost.`
+      );
+      reportError(key, scope, backupErr);
+    }
+  }
   function parse(raw) {
     if (serialize) {
-      return serialize.parse(raw);
+      const value = serialize.parse(raw);
+      if (options.validate && !options.validate(value)) {
+        const scope = options.scope ?? "local";
+        const config = getConfig();
+        safeCallConfig(config.onValidationFail, { key, scope, value });
+        const validationErr = new ValidationError(key, scope, value);
+        safeCallConfig(config.onError, { key, scope, error: validationErr });
+        backupRawData(raw);
+        return defaultValue;
+      }
+      return value;
     }
-    return readAndMigrate(raw, options, key, options.scope);
+    return readAndMigrate(raw, options, key, options.scope, () => backupRawData(raw));
   }
   function read() {
     if (cacheValid) return cachedValue;
@@ -367,6 +439,7 @@ function createStorageAdapter(storage, key, options) {
         safeCallConfig(getConfig().onQuotaExceeded, { key, scope, error: writeErr });
       }
       reportError(key, scope, writeErr);
+      throw writeErr;
     }
   }
   let lastNotifiedValue = defaultValue;
@@ -452,6 +525,7 @@ function createBucketAdapter(key, bucketOptions, options) {
   let delegateUnsub;
   const ready = (async () => {
     if (!isBucketSupported()) return;
+    let hadUserWrite = false;
     try {
       const openOptions = {
         persisted: bucketOptions.persisted ?? false,
@@ -485,7 +559,7 @@ function createBucketAdapter(key, bucketOptions, options) {
       const storage = await bucket.localStorage();
       if (isDestroyed) return;
       const currentValue = delegate.get();
-      const hadUserWrite = !shallowEqual(currentValue, defaultValue);
+      hadUserWrite = !shallowEqual(currentValue, defaultValue);
       delegate.destroy?.();
       delegate = createStorageAdapter(storage, key, options);
       if (isDestroyed) {
@@ -507,10 +581,12 @@ function createBucketAdapter(key, bucketOptions, options) {
       reportError(key, "bucket", err);
     }
     if (isDestroyed) return;
-    const storedValue = delegate.get();
-    if (!shallowEqual(storedValue, defaultValue)) {
-      lastNotifiedValue = storedValue;
-      notify(notifyListeners);
+    if (!hadUserWrite) {
+      const storedValue = delegate.get();
+      if (!shallowEqual(storedValue, defaultValue)) {
+        lastNotifiedValue = storedValue;
+        notify(notifyListeners);
+      }
     }
     delegateUnsub = delegate.subscribe((value) => {
       lastNotifiedValue = value;
@@ -646,7 +722,7 @@ function withSync(adapter, key, scope) {
 }
 
 // src/adapters/url.ts
-function createUrlAdapter(key, defaultValue, serializer, persist) {
+function createUrlAdapter(key, defaultValue, serializer, persist, urlReplace) {
   if (typeof window === "undefined") {
     throw new Error("[gjendje] URL scope is not available in this environment.");
   }
@@ -686,11 +762,19 @@ 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);
+      if (urlReplace) {
+        window.history.replaceState(null, "", newUrl);
+      } else {
+        window.history.pushState(null, "", newUrl);
+      }
       cachedSearch = search ? `?${search}` : "";
       cachedValue = persist ? mergeKeys(toStore, defaultValue, persist) : value;
-    } catch {
+    } catch (e) {
       cachedSearch = void 0;
+      const writeErr = new StorageWriteError(key, "url", e);
+      log("error", writeErr.message);
+      reportError(key, "url", writeErr);
+      throw writeErr;
     }
   }
   let lastNotifiedValue = defaultValue;
@@ -775,7 +859,8 @@ function resolveAdapter(storageKey, scope, options) {
         storageKey,
         options.default,
         options.serialize ?? { stringify: JSON.stringify, parse: JSON.parse },
-        options.persist
+        options.persist,
+        options.urlReplace
       );
     case "server":
       if (!_serverAdapterFactory) {
@@ -818,6 +903,7 @@ var StateImpl = class {
     this._s = preallocatedState ?? {
       lastValue: adapter.get(),
       isDestroyed: false,
+      hasUserWrite: false,
       interceptors: void 0,
       changeHandlers: void 0,
       settled: RESOLVED,
@@ -878,8 +964,14 @@ var StateImpl = class {
     let next = typeof valueOrUpdater === "function" ? valueOrUpdater(prev) : valueOrUpdater;
     next = this._applyInterceptors(next, prev);
     if (this._options.isEqual?.(next, prev)) return;
+    try {
+      this._adapter.set(next);
+    } catch (err) {
+      if (err instanceof StorageWriteError) return;
+      throw err;
+    }
     s.lastValue = next;
-    this._adapter.set(next);
+    s.hasUserWrite = true;
     s.settled = this._adapter.ready;
     this._notifyChange(next, prev);
   }
@@ -892,8 +984,14 @@ var StateImpl = class {
     const prev = this._adapter.get();
     const next = this._applyInterceptors(this._defaultValue, prev);
     if (this._options.isEqual?.(next, prev)) return;
+    try {
+      this._adapter.set(next);
+    } catch (err) {
+      if (err instanceof StorageWriteError) return;
+      throw err;
+    }
     s.lastValue = next;
-    this._adapter.set(next);
+    s.hasUserWrite = true;
     s.settled = this._adapter.ready;
     safeCallConfig(this._config.onReset, { key: this.key, scope: this.scope, previousValue: prev });
     this._notifyChange(next, prev);
@@ -1298,7 +1396,7 @@ function createBase(key, options) {
   const instance = new StateImpl(key, scope, rKey, adapter, options, config);
   if (isSsrMode && !isServer()) {
     instance._s.hydrated = afterHydration(() => {
-      if (instance.isDestroyed) return;
+      if (instance.isDestroyed || instance._s.hasUserWrite) return;
       const currentValue = instance.get();
       if (!shallowEqual(currentValue, options.default)) return;
       let realAdapter;