jotai-state-tree 1.8.0 → 1.9.1

package/dist/{chunk-MGW4FLIA.mjs → chunk-MLAEAO2W.mjs}

@@ -3900,6 +3900,692 @@ function useRouter() {
   return router;
 }
 
+// src/persistence.ts
+import { atom as atom4 } from "jotai";
+var workerCode = `
+self.onmessage = function(e) {
+  const { key, dbName, currentSnapshot } = e.data;
+  
+  function applyPatch(obj, patch) {
+    if (patch.path === "" || patch.path === "/") {
+      if (patch.op === "replace") {
+        return JSON.parse(JSON.stringify(patch.value));
+      }
+      return obj;
+    }
+    
+    const parts = patch.path.split("/").filter(Boolean);
+    let current = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+      const part = parts[i];
+      const index = isNaN(part) ? part : Number(part);
+      if (current === undefined || current === null) return obj;
+      current = current[index];
+    }
+    if (current === undefined || current === null) return obj;
+    
+    const lastPart = parts[parts.length - 1];
+    const lastKey = isNaN(lastPart) ? lastPart : Number(lastPart);
+
+    if (patch.op === "replace" || patch.op === "add") {
+      const val = patch.value !== undefined ? JSON.parse(JSON.stringify(patch.value)) : undefined;
+      if (patch.op === "replace") {
+        current[lastKey] = val;
+      } else {
+        if (Array.isArray(current)) {
+          current.splice(lastKey, 0, val);
+        } else {
+          current[lastKey] = val;
+        }
+      }
+    } else if (patch.op === "remove") {
+      if (Array.isArray(current)) {
+        current.splice(lastKey, 1);
+      } else {
+        delete current[lastKey];
+      }
+    }
+    return obj;
+  }
+
+  const request = indexedDB.open(dbName, 1);
+  request.onerror = function() {
+    self.postMessage({ error: "Failed to open IndexedDB in worker" });
+  };
+  request.onsuccess = function() {
+    const db = request.result;
+    const tx = db.transaction("sync_queue", "readwrite");
+    const store = tx.objectStore("sync_queue");
+    const getReq = store.getAll();
+    
+    getReq.onerror = function() {
+      db.close();
+      self.postMessage({ error: "Failed to get queue from store in worker" });
+    };
+    
+    getReq.onsuccess = function() {
+      const allItems = getReq.result || [];
+      const queue = allItems.filter(item => item.key === key);
+      
+      if (queue.length <= 1) {
+        db.close();
+        self.postMessage({ success: true, key, compacted: false });
+        return;
+      }
+      
+      // Reconstruct initial snapshot by applying inverse patches in reverse order
+      let initialSnapshot = JSON.parse(JSON.stringify(currentSnapshot));
+      for (let i = queue.length - 1; i >= 0; i--) {
+        const item = queue[i];
+        for (let j = item.inversePatches.length - 1; j >= 0; j--) {
+          initialSnapshot = applyPatch(initialSnapshot, item.inversePatches[j]);
+        }
+      }
+      
+      // Delete old queue items
+      let deleteCount = 0;
+      let hasError = false;
+      
+      function checkDone() {
+        if (hasError) return;
+        if (deleteCount === queue.length) {
+          // Add consolidated item
+          const addReq = store.add({
+            key: key,
+            patches: [{ op: "replace", path: "", value: currentSnapshot }],
+            inversePatches: [{ op: "replace", path: "", value: initialSnapshot }],
+            timestamp: Date.now()
+          });
+          
+          addReq.onerror = function() {
+            db.close();
+            self.postMessage({ error: "Failed to add consolidated mutation in worker" });
+          };
+          addReq.onsuccess = function() {
+            db.close();
+            self.postMessage({ success: true, key, compacted: true });
+          };
+        }
+      }
+      
+      for (const item of queue) {
+        if (item.id !== undefined) {
+          const delReq = store.delete(item.id);
+          delReq.onerror = function() {
+            hasError = true;
+            db.close();
+            self.postMessage({ error: "Failed to delete queue item in worker" });
+          };
+          delReq.onsuccess = function() {
+            deleteCount++;
+            checkDone();
+          };
+        }
+      }
+    };
+  };
+};
+`;
+var IndexedDBStorage = class {
+  constructor(dbName) {
+    this.db = null;
+    this.dbName = dbName;
+  }
+  async init() {
+    if (this.db) return;
+    return new Promise((resolve, reject) => {
+      if (typeof indexedDB === "undefined") {
+        reject(
+          new Error(
+            "[jotai-state-tree] IndexedDB is not supported in this environment."
+          )
+        );
+        return;
+      }
+      const request = indexedDB.open(this.dbName, 1);
+      request.onupgradeneeded = () => {
+        const db = request.result;
+        if (!db.objectStoreNames.contains("snapshots")) {
+          db.createObjectStore("snapshots");
+        }
+        if (!db.objectStoreNames.contains("sync_queue")) {
+          db.createObjectStore("sync_queue", {
+            keyPath: "id",
+            autoIncrement: true
+          });
+        }
+      };
+      request.onsuccess = () => {
+        this.db = request.result;
+        resolve();
+      };
+      request.onerror = () => {
+        reject(request.error);
+      };
+    });
+  }
+  async getSnapshot(key) {
+    await this.init();
+    return new Promise((resolve, reject) => {
+      const tx = this.db.transaction("snapshots", "readonly");
+      const store = tx.objectStore("snapshots");
+      const req = store.get(key);
+      req.onsuccess = () => resolve(req.result);
+      req.onerror = () => reject(req.error);
+    });
+  }
+  async setSnapshot(key, value) {
+    await this.init();
+    return new Promise((resolve, reject) => {
+      const tx = this.db.transaction("snapshots", "readwrite");
+      const store = tx.objectStore("snapshots");
+      const req = store.put(value, key);
+      req.onsuccess = () => resolve();
+      req.onerror = () => reject(req.error);
+    });
+  }
+  async clearSnapshots() {
+    await this.init();
+    return new Promise((resolve, reject) => {
+      const tx = this.db.transaction("snapshots", "readwrite");
+      const store = tx.objectStore("snapshots");
+      const req = store.clear();
+      req.onsuccess = () => resolve();
+      req.onerror = () => reject(req.error);
+    });
+  }
+  async getQueue(key) {
+    await this.init();
+    return new Promise((resolve, reject) => {
+      const tx = this.db.transaction("sync_queue", "readonly");
+      const store = tx.objectStore("sync_queue");
+      const req = store.getAll();
+      req.onsuccess = () => {
+        const results = req.result.filter(
+          (item) => item.key === key
+        );
+        resolve(results);
+      };
+      req.onerror = () => reject(req.error);
+    });
+  }
+  async addQueue(item) {
+    await this.init();
+    return new Promise((resolve, reject) => {
+      const tx = this.db.transaction("sync_queue", "readwrite");
+      const store = tx.objectStore("sync_queue");
+      const req = store.add(item);
+      req.onsuccess = () => resolve(req.result);
+      req.onerror = () => reject(req.error);
+    });
+  }
+  async deleteQueue(id) {
+    await this.init();
+    return new Promise((resolve, reject) => {
+      const tx = this.db.transaction("sync_queue", "readwrite");
+      const store = tx.objectStore("sync_queue");
+      const req = store.delete(id);
+      req.onsuccess = () => resolve();
+      req.onerror = () => reject(req.error);
+    });
+  }
+  async clearQueue(key) {
+    await this.init();
+    const items = await this.getQueue(key);
+    if (items.length === 0) return;
+    return new Promise((resolve, reject) => {
+      const tx = this.db.transaction("sync_queue", "readwrite");
+      const store = tx.objectStore("sync_queue");
+      let completed = 0;
+      let hasError = false;
+      for (const item of items) {
+        if (item.id !== void 0) {
+          const req = store.delete(item.id);
+          req.onsuccess = () => {
+            completed++;
+            if (completed === items.length && !hasError) {
+              resolve();
+            }
+          };
+          req.onerror = () => {
+            hasError = true;
+            reject(req.error);
+          };
+        }
+      }
+    });
+  }
+};
+function defaultShouldRollback(error) {
+  if (typeof navigator !== "undefined" && !navigator.onLine) {
+    return false;
+  }
+  const errMsg = String(error.message || error).toLowerCase();
+  if (errMsg.includes("network") || errMsg.includes("fetch") || errMsg.includes("timeout") || errMsg.includes("abort") || errMsg.includes("failed to fetch")) {
+    return false;
+  }
+  return true;
+}
+var PersistenceManager = class {
+  constructor(target, options = {}) {
+    this.key = "root";
+    this.patchDisposer = null;
+    this.skipSyncing = false;
+    this.lastFetchedTime = 0;
+    this.fetchTimeout = null;
+    // Optimistic & High-Performance Batching State
+    this.pendingPatches = [];
+    this.pendingInversePatches = [];
+    this.batchScheduled = false;
+    this.debounceSnapshotTimeout = null;
+    this.lastSnapshotToWrite = null;
+    // Window Focus and Reconnect Listeners
+    this.focusListener = null;
+    this.onlineListener = null;
+    this.offlineListener = null;
+    this.target = target;
+    this.options = options;
+    if (typeof indexedDB === "undefined") {
+      throw new Error(
+        "[jotai-state-tree] IndexedDB is not supported in this environment."
+      );
+    }
+    if (options.key) {
+      this.key = options.key;
+    } else {
+      const node = getStateTreeNode(target);
+      const idAttribute = node.$type.identifierAttribute;
+      if (idAttribute) {
+        const idValue = target[idAttribute];
+        if (idValue !== void 0 && idValue !== null) {
+          this.key = String(idValue);
+        }
+      }
+    }
+    const dbName = options.dbName ?? "jotai-state-tree-persistence";
+    this.storage = new IndexedDBStorage(dbName);
+    const initialOffline = typeof navigator !== "undefined" ? !navigator.onLine : false;
+    this.statusAtom = atom4({
+      isLoading: true,
+      isFetching: false,
+      isSyncing: false,
+      isOffline: initialOffline,
+      pendingSyncCount: 0,
+      error: null
+    });
+  }
+  async initialize() {
+    const store = getGlobalStore();
+    const cachedSnapshot = await this.storage.getSnapshot(this.key);
+    let queue = await this.storage.getQueue(this.key);
+    if (cachedSnapshot !== void 0 && cachedSnapshot !== null) {
+      this.skipSyncing = true;
+      try {
+        applySnapshot(this.target, cachedSnapshot);
+      } finally {
+        this.skipSyncing = false;
+      }
+      store.set(this.statusAtom, (prev) => ({
+        ...prev,
+        isLoading: false
+      }));
+    } else {
+      store.set(this.statusAtom, (prev) => ({
+        ...prev,
+        isLoading: !!this.options.query?.queryFn
+      }));
+    }
+    const maxQueueSize = this.options.maxQueueSize ?? 20;
+    if (queue.length > maxQueueSize) {
+      try {
+        await this.compact();
+        queue = await this.storage.getQueue(this.key);
+      } catch (err) {
+        console.warn("[jotai-state-tree] Initial compaction failed:", err);
+      }
+    }
+    store.set(this.statusAtom, (prev) => ({
+      ...prev,
+      pendingSyncCount: queue.length
+    }));
+    if (this.patchDisposer) {
+      this.patchDisposer();
+    }
+    this.patchDisposer = onPatch(this.target, (patch, reversePatch) => {
+      this.handlePatch(patch, reversePatch);
+    });
+    if (typeof window !== "undefined") {
+      this.onlineListener = () => {
+        store.set(this.statusAtom, (prev) => ({ ...prev, isOffline: false }));
+        this.sync();
+        if (this.options.query?.refetchOnReconnect !== false) {
+          this.fetch();
+        }
+      };
+      this.offlineListener = () => {
+        store.set(this.statusAtom, (prev) => ({ ...prev, isOffline: true }));
+      };
+      window.addEventListener("online", this.onlineListener);
+      window.addEventListener("offline", this.offlineListener);
+      if (this.options.query?.refetchOnWindowFocus) {
+        this.focusListener = () => {
+          this.fetch();
+        };
+        window.addEventListener("focus", this.focusListener);
+      }
+    }
+    if (this.options.query?.queryFn) {
+      this.fetchTimeout = setTimeout(() => this.fetch(), 0);
+    }
+    if (queue.length > 0) {
+      await this.sync();
+    }
+  }
+  async fetch(force = false) {
+    const query = this.options.query;
+    if (!query?.queryFn) return;
+    const store = getGlobalStore();
+    const status = store.get(this.statusAtom);
+    if (status.isFetching) return;
+    if (!force && query.staleTime !== void 0) {
+      const now = Date.now();
+      if (now - this.lastFetchedTime < query.staleTime) {
+        return;
+      }
+    }
+    store.set(this.statusAtom, (prev) => ({
+      ...prev,
+      isFetching: true
+    }));
+    try {
+      const data = await query.queryFn();
+      if (data !== void 0 && data !== null) {
+        this.skipSyncing = true;
+        try {
+          applySnapshot(this.target, data);
+        } finally {
+          this.skipSyncing = false;
+        }
+        this.lastSnapshotToWrite = data;
+        await this.storage.setSnapshot(this.key, data);
+      }
+      this.lastFetchedTime = Date.now();
+      store.set(this.statusAtom, (prev) => ({
+        ...prev,
+        isFetching: false,
+        isLoading: false,
+        error: null
+      }));
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      store.set(this.statusAtom, (prev) => ({
+        ...prev,
+        isFetching: false,
+        isLoading: false,
+        error
+      }));
+      throw error;
+    }
+  }
+  handlePatch(patch, reversePatch) {
+    if (this.skipSyncing) return;
+    this.pendingPatches.push(patch);
+    this.pendingInversePatches.push(reversePatch);
+    if (!this.batchScheduled) {
+      this.batchScheduled = true;
+      Promise.resolve().then(() => {
+        this.flushBatch();
+      });
+    }
+  }
+  async flushBatch() {
+    this.batchScheduled = false;
+    const patches = [...this.pendingPatches];
+    const inversePatches = [...this.pendingInversePatches];
+    this.pendingPatches = [];
+    this.pendingInversePatches = [];
+    if (patches.length === 0) return;
+    const currentSnapshot = getSnapshot(this.target);
+    this.lastSnapshotToWrite = currentSnapshot;
+    if (this.debounceSnapshotTimeout) {
+      clearTimeout(this.debounceSnapshotTimeout);
+    }
+    this.debounceSnapshotTimeout = setTimeout(async () => {
+      if (this.lastSnapshotToWrite) {
+        await this.storage.setSnapshot(this.key, this.lastSnapshotToWrite);
+      }
+    }, 150);
+    if (this.options.mutation?.syncFn) {
+      await this.storage.addQueue({
+        key: this.key,
+        patches,
+        inversePatches,
+        timestamp: Date.now()
+      });
+      const store = getGlobalStore();
+      let queue = await this.storage.getQueue(this.key);
+      const maxQueueSize = this.options.maxQueueSize ?? 20;
+      if (queue.length > maxQueueSize) {
+        try {
+          await this.compact();
+          queue = await this.storage.getQueue(this.key);
+        } catch (err) {
+          console.warn("[jotai-state-tree] Auto-compaction failed:", err);
+        }
+      }
+      store.set(this.statusAtom, (prev) => ({
+        ...prev,
+        pendingSyncCount: queue.length
+      }));
+      try {
+        await this.sync();
+      } catch (err) {
+      }
+    }
+  }
+  /**
+   * Compacts the queue by squashing multiple mutations into a single root replacement patch.
+   * Runs in a background Web Worker if supported, falling back to main-thread execution.
+   */
+  async compact() {
+    const store = getGlobalStore();
+    const currentSnapshot = getSnapshot(this.target);
+    const dbName = this.options.dbName ?? "jotai-state-tree-persistence";
+    const isWorkerSupported = typeof Worker !== "undefined" && typeof Blob !== "undefined" && typeof URL !== "undefined";
+    if (isWorkerSupported) {
+      return new Promise((resolve, reject) => {
+        try {
+          const blob = new Blob([workerCode], {
+            type: "application/javascript"
+          });
+          const workerUrl = URL.createObjectURL(blob);
+          const worker = new Worker(workerUrl);
+          worker.onmessage = async (e) => {
+            worker.terminate();
+            URL.revokeObjectURL(workerUrl);
+            if (e.data.error) {
+              reject(new Error(e.data.error));
+            } else {
+              const queue = await this.storage.getQueue(this.key);
+              store.set(this.statusAtom, (prev) => ({
+                ...prev,
+                pendingSyncCount: queue.length
+              }));
+              resolve();
+            }
+          };
+          worker.onerror = (err) => {
+            worker.terminate();
+            URL.revokeObjectURL(workerUrl);
+            reject(err);
+          };
+          worker.postMessage({
+            key: this.key,
+            dbName,
+            currentSnapshot
+          });
+        } catch (err) {
+          reject(err);
+        }
+      });
+    } else {
+      const queue = await this.storage.getQueue(this.key);
+      if (queue.length <= 1) return;
+      this.skipSyncing = true;
+      try {
+        for (let i = queue.length - 1; i >= 0; i--) {
+          const item = queue[i];
+          for (let j = item.inversePatches.length - 1; j >= 0; j--) {
+            applyPatch(this.target, item.inversePatches[j]);
+          }
+        }
+      } finally {
+        this.skipSyncing = false;
+      }
+      const initialSnapshot = getSnapshot(this.target);
+      this.skipSyncing = true;
+      try {
+        applySnapshot(this.target, currentSnapshot);
+      } finally {
+        this.skipSyncing = false;
+      }
+      await this.storage.clearQueue(this.key);
+      await this.storage.addQueue({
+        key: this.key,
+        patches: [{ op: "replace", path: "", value: currentSnapshot }],
+        inversePatches: [{ op: "replace", path: "", value: initialSnapshot }],
+        timestamp: Date.now()
+      });
+      const newQueue = await this.storage.getQueue(this.key);
+      store.set(this.statusAtom, (prev) => ({
+        ...prev,
+        pendingSyncCount: newQueue.length
+      }));
+    }
+  }
+  async sync() {
+    const mutation = this.options.mutation;
+    if (!mutation?.syncFn) return;
+    const store = getGlobalStore();
+    const status = store.get(this.statusAtom);
+    if (status.isSyncing || status.isOffline) return;
+    store.set(this.statusAtom, (prev) => ({ ...prev, isSyncing: true }));
+    try {
+      let queue = await this.storage.getQueue(this.key);
+      while (queue.length > 0) {
+        if (typeof navigator !== "undefined" && !navigator.onLine) {
+          store.set(this.statusAtom, (prev) => ({ ...prev, isOffline: true }));
+          break;
+        }
+        const item = queue[0];
+        try {
+          const currentSnapshot = getSnapshot(this.target);
+          const syncResult = await mutation.syncFn(
+            currentSnapshot,
+            item.patches
+          );
+          if (item.id !== void 0) {
+            await this.storage.deleteQueue(item.id);
+          }
+          if (mutation.onSuccess) {
+            mutation.onSuccess(syncResult);
+          }
+        } catch (err) {
+          const error = err instanceof Error ? err : new Error(String(err));
+          const shouldRollback = mutation.shouldRollback ?? defaultShouldRollback;
+          if (shouldRollback(error)) {
+            this.skipSyncing = true;
+            try {
+              for (let i = item.inversePatches.length - 1; i >= 0; i--) {
+                applyPatch(this.target, item.inversePatches[i]);
+              }
+              const currentSnapshot = getSnapshot(this.target);
+              this.lastSnapshotToWrite = currentSnapshot;
+              await this.storage.setSnapshot(this.key, currentSnapshot);
+            } finally {
+              this.skipSyncing = false;
+            }
+            if (item.id !== void 0) {
+              await this.storage.deleteQueue(item.id);
+            }
+            if (mutation.onError) {
+              mutation.onError(error);
+            }
+            throw error;
+          } else {
+            store.set(this.statusAtom, (prev) => ({ ...prev, error }));
+            if (mutation.onError) {
+              mutation.onError(error);
+            }
+            break;
+          }
+        }
+        queue = await this.storage.getQueue(this.key);
+        store.set(this.statusAtom, (prev) => ({
+          ...prev,
+          pendingSyncCount: queue.length
+        }));
+      }
+      const finalQueue = await this.storage.getQueue(this.key);
+      store.set(this.statusAtom, (prev) => ({
+        ...prev,
+        isSyncing: false,
+        pendingSyncCount: finalQueue.length,
+        error: finalQueue.length === 0 ? null : prev.error
+      }));
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      store.set(this.statusAtom, (prev) => ({
+        ...prev,
+        isSyncing: false,
+        error
+      }));
+      throw error;
+    }
+  }
+  async clear() {
+    await this.storage.clearSnapshots();
+    await this.storage.clearQueue(this.key);
+    const store = getGlobalStore();
+    store.set(this.statusAtom, (prev) => ({
+      ...prev,
+      pendingSyncCount: 0,
+      error: null
+    }));
+  }
+  dispose() {
+    if (this.fetchTimeout) {
+      clearTimeout(this.fetchTimeout);
+      this.fetchTimeout = null;
+    }
+    if (this.debounceSnapshotTimeout) {
+      clearTimeout(this.debounceSnapshotTimeout);
+      this.debounceSnapshotTimeout = null;
+    }
+    if (this.patchDisposer) {
+      this.patchDisposer();
+      this.patchDisposer = null;
+    }
+    if (typeof window !== "undefined") {
+      if (this.onlineListener) {
+        window.removeEventListener("online", this.onlineListener);
+        this.onlineListener = null;
+      }
+      if (this.offlineListener) {
+        window.removeEventListener("offline", this.offlineListener);
+        this.offlineListener = null;
+      }
+      if (this.focusListener) {
+        window.removeEventListener("focus", this.focusListener);
+        this.focusListener = null;
+      }
+    }
+  }
+};
+function createPersistenceManager(target, options) {
+  return new PersistenceManager(target, options);
+}
+
 export {
   string,
   number,
@@ -4005,5 +4691,7 @@ export {
   RouterModel,
   createRouter,
   RouterContext,
-  useRouter
+  useRouter,
+  PersistenceManager,
+  createPersistenceManager
 };