jotai-state-tree 1.4.1 → 1.4.3

package/dist/{chunk-MSLAD5CJ.mjs → chunk-5OCZ6YLH.mjs}

@@ -42,9 +42,12 @@ var identifierFinalizationRegistry = new FinalizationRegistry(
   (info) => {
     const typeMap = identifierRegistry.get(info.typeName);
     if (typeMap) {
-      typeMap.delete(info.identifier);
-      if (typeMap.size === 0) {
-        identifierRegistry.delete(info.typeName);
+      const ref = typeMap.get(info.identifier);
+      if (!ref || ref.deref() === void 0) {
+        typeMap.delete(info.identifier);
+        if (typeMap.size === 0) {
+          identifierRegistry.delete(info.typeName);
+        }
       }
     }
   }
@@ -71,6 +74,35 @@ function notifyLifecycleChange(node, isAlive2) {
     listeners.forEach((listener) => listener(isAlive2));
   }
 }
+function cloneAndSerialize(value) {
+  if (value === null || value === void 0) {
+    return value;
+  }
+  if (hasStateTreeNode(value)) {
+    return getSnapshotFromNode(getStateTreeNode(value));
+  }
+  if (Array.isArray(value)) {
+    return value.map(cloneAndSerialize);
+  }
+  if (typeof value === "object") {
+    if (value instanceof Map) {
+      const res = {};
+      for (const [k, v] of value.entries()) {
+        res[k] = cloneAndSerialize(v);
+      }
+      return res;
+    }
+    const proto = Object.getPrototypeOf(value);
+    if (proto === null || proto === Object.prototype) {
+      const res = {};
+      for (const [k, v] of Object.entries(value)) {
+        res[k] = cloneAndSerialize(v);
+      }
+      return res;
+    }
+  }
+  return value;
+}
 var StateTreeNode = class {
   constructor(type, initialValue, env, parent, pathSegment) {
     this.$parent = null;
@@ -88,6 +120,8 @@ var StateTreeNode = class {
     /** Cached snapshot for structural sharing optimization */
     this.cachedSnapshot = void 0;
     this.isSnapshotDirty = true;
+    /** Strong reference to the instance proxy to prevent GC of active nodes */
+    this.instance = null;
     this.$id = generateNodeId();
     this.$type = type;
     this.$env = env ?? parent?.$env;
@@ -108,6 +142,7 @@ var StateTreeNode = class {
   }
   /** Set the instance reference */
   setInstance(instance) {
+    this.instance = instance;
     const entry = nodeRegistry.get(this.$id);
     if (entry && instance && typeof instance === "object") {
       entry.instance = new WeakRef(instance);
@@ -115,8 +150,7 @@ var StateTreeNode = class {
   }
   /** Get the instance */
   getInstance() {
-    const entry = nodeRegistry.get(this.$id);
-    return entry?.instance?.deref() ?? null;
+    return this.instance;
   }
   /** Get current value from atom */
   getValue() {
@@ -222,9 +256,27 @@ var StateTreeNode = class {
   }
   /** Notify patch listeners */
   notifyPatch(patch, reversePatch) {
-    this.patchListeners.forEach((listener) => listener(patch, reversePatch));
+    const serializedPatch = {
+      ...patch,
+      value: "value" in patch ? cloneAndSerialize(patch.value) : void 0
+    };
+    if (!("value" in patch)) {
+      delete serializedPatch.value;
+    }
+    const serializedReversePatch = {
+      ...reversePatch,
+      value: "value" in reversePatch ? cloneAndSerialize(reversePatch.value) : void 0,
+      oldValue: "oldValue" in reversePatch ? cloneAndSerialize(reversePatch.oldValue) : void 0
+    };
+    if (!("value" in reversePatch)) {
+      delete serializedReversePatch.value;
+    }
+    if (!("oldValue" in reversePatch)) {
+      delete serializedReversePatch.oldValue;
+    }
+    this.patchListeners.forEach((listener) => listener(serializedPatch, serializedReversePatch));
     if (this.$parent) {
-      this.$parent.notifyPatch(patch, reversePatch);
+      this.$parent.notifyPatch(serializedPatch, serializedReversePatch);
     }
   }
   /** Notify snapshot listeners */
@@ -261,6 +313,7 @@ var StateTreeNode = class {
   /** Destroy this node and all children */
   destroy() {
     if (!this.$isAlive) return;
+    this.instance = null;
     lifecycleHookHandlers.runBeforeDestroy?.(this);
     this.children.forEach((child) => child.destroy());
     this.children.clear();
@@ -900,26 +953,32 @@ function unfreeze(target) {
 }
 
 // src/undo.ts
-var UndoManager = class {
+import { atom as atom2 } from "jotai";
+var historyTrackersRegistry = /* @__PURE__ */ new WeakMap();
+var HistoryTracker = class {
   constructor(target, options = {}) {
-    this.historyEntries = [];
-    this.currentIndex = -1;
-    this.isUndoing = false;
-    this.isRedoing = false;
+    // Transient state
+    this.autoRecord = false;
+    this.isApplyingHistory = false;
     this.skipRecording = false;
     this.grouping = false;
     this.actionGrouping = false;
     this.currentGroup = [];
     this.currentGroupInverse = [];
+    this.lastChangeTime = 0;
     this.disposer = null;
     this.actionDisposer = null;
-    this.lastChangeTime = 0;
     this.target = target;
-    this.options = {
-      maxHistoryLength: options.maxHistoryLength ?? 100,
-      groupByTime: options.groupByTime ?? false,
-      groupingWindow: options.groupingWindow ?? 200
-    };
+    this.maxHistoryLength = options.maxHistoryLength ?? options.maxSnapshots ?? 100;
+    this.groupByTime = options.groupByTime ?? false;
+    this.groupingWindow = options.groupingWindow ?? 200;
+    this.autoRecord = options.autoRecord ?? false;
+    const initialSnapshot = getSnapshot(target);
+    this.historyAtom = atom2({
+      entries: [],
+      currentIndex: -1,
+      initialSnapshot
+    });
     this.disposer = onPatch(target, (patch, reversePatch) => {
       this.recordPatch(patch, reversePatch);
     });
@@ -932,32 +991,18 @@ var UndoManager = class {
       }
     });
   }
-  get canUndo() {
-    return this.currentIndex >= 0;
-  }
-  get canRedo() {
-    return this.currentIndex < this.historyEntries.length - 1;
-  }
-  get undoLevels() {
-    return this.currentIndex + 1;
-  }
-  get redoLevels() {
-    return this.historyEntries.length - this.currentIndex - 1;
-  }
-  get history() {
-    return [...this.historyEntries];
-  }
-  get historyIndex() {
-    return this.currentIndex;
-  }
   recordPatch(patch, reversePatch) {
-    if (this.isUndoing || this.isRedoing || this.skipRecording) {
+    if (!this.autoRecord) {
+      return;
+    }
+    if (this.isApplyingHistory || this.skipRecording) {
       return;
     }
     const node = getStateTreeNode(this.target);
     if (node.getRoot().$isApplyingHistory) {
       return;
     }
+    const store = getGlobalStore();
     const now = Date.now();
     if (isActionRunning() && !this.grouping) {
       this.grouping = true;
@@ -975,72 +1020,172 @@ var UndoManager = class {
       this.currentGroupInverse.push({ ...patch });
       return;
     }
-    if (this.options.groupByTime && this.historyEntries.length > 0 && now - this.lastChangeTime < this.options.groupingWindow && this.currentIndex === this.historyEntries.length - 1) {
-      const lastEntry = this.historyEntries[this.currentIndex];
-      lastEntry.patches.push(reversePatch);
-      lastEntry.inversePatches.push({ ...patch });
-      lastEntry.timestamp = now;
-    } else {
-      if (this.currentIndex < this.historyEntries.length - 1) {
-        this.historyEntries.splice(this.currentIndex + 1);
-      }
-      this.historyEntries.push({
-        patches: [reversePatch],
-        inversePatches: [{ ...patch }],
-        timestamp: now
-      });
-      this.currentIndex++;
-      if (this.historyEntries.length > this.options.maxHistoryLength) {
-        const excess = this.historyEntries.length - this.options.maxHistoryLength;
-        this.historyEntries.splice(0, excess);
-        this.currentIndex -= excess;
+    store.set(this.historyAtom, (prev) => {
+      let entries = prev.currentIndex < prev.entries.length - 1 ? prev.entries.slice(0, prev.currentIndex + 1) : [...prev.entries];
+      if (this.groupByTime && entries.length > 0 && now - this.lastChangeTime < this.groupingWindow && prev.currentIndex === prev.entries.length - 1) {
+        const lastEntry = { ...entries[entries.length - 1] };
+        lastEntry.patches = [...lastEntry.patches, reversePatch];
+        lastEntry.inversePatches = [...lastEntry.inversePatches, { ...patch }];
+        lastEntry.timestamp = now;
+        lastEntry.snapshot = getSnapshot(this.target);
+        entries[entries.length - 1] = lastEntry;
+        this.lastChangeTime = now;
+        return {
+          ...prev,
+          entries
+        };
+      } else {
+        const newEntry = {
+          patches: [reversePatch],
+          inversePatches: [{ ...patch }],
+          timestamp: now,
+          snapshot: getSnapshot(this.target)
+        };
+        entries.push(newEntry);
+        let newIndex = entries.length - 1;
+        if (entries.length > this.maxHistoryLength) {
+          const excess = entries.length - this.maxHistoryLength;
+          entries = entries.slice(excess);
+          newIndex -= excess;
+        }
+        this.lastChangeTime = now;
+        return {
+          ...prev,
+          entries,
+          currentIndex: newIndex
+        };
       }
-    }
-    this.lastChangeTime = now;
+    });
   }
   undo() {
-    if (!this.canUndo) {
+    const store = getGlobalStore();
+    const state = store.get(this.historyAtom);
+    if (state.currentIndex < 0) {
       return;
     }
     const node = getStateTreeNode(this.target);
     const rootNode = node.getRoot();
     const wasApplying = rootNode.$isApplyingHistory;
     rootNode.$isApplyingHistory = true;
-    this.isUndoing = true;
+    this.isApplyingHistory = true;
     try {
-      const entry = this.historyEntries[this.currentIndex];
+      const entry = state.entries[state.currentIndex];
       for (let i = entry.patches.length - 1; i >= 0; i--) {
         applyPatch(this.target, entry.patches[i]);
       }
-      this.currentIndex--;
+      store.set(this.historyAtom, (prev) => ({
+        ...prev,
+        currentIndex: prev.currentIndex - 1
+      }));
     } finally {
-      this.isUndoing = false;
+      this.isApplyingHistory = false;
       rootNode.$isApplyingHistory = wasApplying;
     }
   }
   redo() {
-    if (!this.canRedo) {
+    const store = getGlobalStore();
+    const state = store.get(this.historyAtom);
+    if (state.currentIndex >= state.entries.length - 1) {
       return;
     }
     const node = getStateTreeNode(this.target);
     const rootNode = node.getRoot();
     const wasApplying = rootNode.$isApplyingHistory;
     rootNode.$isApplyingHistory = true;
-    this.isRedoing = true;
+    this.isApplyingHistory = true;
     try {
-      this.currentIndex++;
-      const entry = this.historyEntries[this.currentIndex];
+      const nextIndex = state.currentIndex + 1;
+      const entry = state.entries[nextIndex];
       for (const patch of entry.inversePatches) {
         applyPatch(this.target, patch);
       }
+      store.set(this.historyAtom, (prev) => ({
+        ...prev,
+        currentIndex: nextIndex
+      }));
+    } finally {
+      this.isApplyingHistory = false;
+      rootNode.$isApplyingHistory = wasApplying;
+    }
+  }
+  goTo(index) {
+    const store = getGlobalStore();
+    const state = store.get(this.historyAtom);
+    const maxIdx = state.entries.length;
+    if (index < 0 || index > maxIdx) {
+      return;
+    }
+    const node = getStateTreeNode(this.target);
+    const rootNode = node.getRoot();
+    const wasApplying = rootNode.$isApplyingHistory;
+    rootNode.$isApplyingHistory = true;
+    this.isApplyingHistory = true;
+    try {
+      const targetSnapshot = index === 0 ? state.initialSnapshot : state.entries[index - 1].snapshot;
+      applySnapshot(this.target, targetSnapshot);
+      store.set(this.historyAtom, (prev) => ({
+        ...prev,
+        currentIndex: index - 1
+      }));
     } finally {
-      this.isRedoing = false;
+      this.isApplyingHistory = false;
       rootNode.$isApplyingHistory = wasApplying;
     }
   }
+  goBack() {
+    const store = getGlobalStore();
+    const state = store.get(this.historyAtom);
+    const currentSnapshotIndex = state.currentIndex + 1;
+    if (currentSnapshotIndex > 0) {
+      this.goTo(currentSnapshotIndex - 1);
+    }
+  }
+  goForward() {
+    const store = getGlobalStore();
+    const state = store.get(this.historyAtom);
+    const currentSnapshotIndex = state.currentIndex + 1;
+    if (currentSnapshotIndex < state.entries.length) {
+      this.goTo(currentSnapshotIndex + 1);
+    }
+  }
+  record() {
+    const store = getGlobalStore();
+    const state = store.get(this.historyAtom);
+    let entries = state.currentIndex < state.entries.length - 1 ? state.entries.slice(0, state.currentIndex + 1) : [...state.entries];
+    const newEntry = {
+      patches: [],
+      inversePatches: [],
+      timestamp: Date.now(),
+      snapshot: getSnapshot(this.target)
+    };
+    entries.push(newEntry);
+    let newIndex = entries.length - 1;
+    if (entries.length > this.maxHistoryLength) {
+      const excess = entries.length - this.maxHistoryLength;
+      entries = entries.slice(excess);
+      newIndex -= excess;
+    }
+    store.set(this.historyAtom, {
+      ...state,
+      entries,
+      currentIndex: newIndex
+    });
+  }
+  getSnapshot(index) {
+    const store = getGlobalStore();
+    const state = store.get(this.historyAtom);
+    if (index < 0 || index > state.entries.length) {
+      throw new Error(`[jotai-state-tree] Invalid snapshot index: ${index}`);
+    }
+    return index === 0 ? state.initialSnapshot : state.entries[index - 1].snapshot;
+  }
   clear() {
-    this.historyEntries = [];
-    this.currentIndex = -1;
+    const store = getGlobalStore();
+    store.set(this.historyAtom, {
+      entries: [],
+      currentIndex: -1,
+      initialSnapshot: getSnapshot(this.target)
+    });
     this.currentGroup = [];
     this.currentGroupInverse = [];
     this.grouping = false;
@@ -1059,20 +1204,28 @@ var UndoManager = class {
     this.grouping = false;
     this.actionGrouping = false;
     if (this.currentGroup.length > 0) {
-      if (this.currentIndex < this.historyEntries.length - 1) {
-        this.historyEntries.splice(this.currentIndex + 1);
-      }
-      this.historyEntries.push({
-        patches: this.currentGroup,
-        inversePatches: this.currentGroupInverse,
-        timestamp: Date.now()
+      const store = getGlobalStore();
+      store.set(this.historyAtom, (prev) => {
+        let entries = prev.currentIndex < prev.entries.length - 1 ? prev.entries.slice(0, prev.currentIndex + 1) : [...prev.entries];
+        const newEntry = {
+          patches: [...this.currentGroup],
+          inversePatches: [...this.currentGroupInverse],
+          timestamp: Date.now(),
+          snapshot: getSnapshot(this.target)
+        };
+        entries.push(newEntry);
+        let newIndex = entries.length - 1;
+        if (entries.length > this.maxHistoryLength) {
+          const excess = entries.length - this.maxHistoryLength;
+          entries = entries.slice(excess);
+          newIndex -= excess;
+        }
+        return {
+          ...prev,
+          entries,
+          currentIndex: newIndex
+        };
       });
-      this.currentIndex++;
-      if (this.historyEntries.length > this.options.maxHistoryLength) {
-        const excess = this.historyEntries.length - this.options.maxHistoryLength;
-        this.historyEntries.splice(0, excess);
-        this.currentIndex -= excess;
-      }
     }
     this.currentGroup = [];
     this.currentGroupInverse = [];
@@ -1086,6 +1239,7 @@ var UndoManager = class {
     }
   }
   dispose() {
+    historyTrackersRegistry.delete(this.target);
     if (this.disposer) {
       this.disposer();
       this.disposer = null;
@@ -1094,134 +1248,113 @@ var UndoManager = class {
       this.actionDisposer();
       this.actionDisposer = null;
     }
-    this.clear();
   }
 };
-function createUndoManager(target, options) {
-  return new UndoManager(target, options);
-}
-var TimeTravelManager = class {
-  constructor(target, options = {}) {
-    this.snapshots = [];
-    this.index = -1;
-    this.isApplying = false;
-    this.disposer = null;
-    this.actionDisposer = null;
-    this.pendingRecord = false;
-    this.actionGrouping = false;
-    this.target = target;
-    this.maxSnapshots = options.maxSnapshots ?? 50;
-    this.autoRecord = options.autoRecord ?? false;
-    this.record();
-    if (this.autoRecord) {
-      this.disposer = onPatch(target, () => {
-        if (this.isApplying) return;
-        const node = getStateTreeNode(this.target);
-        if (node.getRoot().$isApplyingHistory) {
-          return;
-        }
-        if (isActionRunning()) {
-          this.pendingRecord = true;
-          if (!this.actionGrouping) {
-            this.actionGrouping = true;
-            Promise.resolve().then(() => {
-              if (this.actionGrouping) {
-                this.commitPendingRecord();
-              }
-            });
-          }
-        } else {
-          this.record();
-        }
-      });
-      this.actionDisposer = onAction(target, () => {
-        const current = getCurrentAction();
-        if (current && !current.parent) {
-          if (this.actionGrouping) {
-            this.commitPendingRecord();
-          }
-        }
-      });
-    }
-  }
-  commitPendingRecord() {
-    this.actionGrouping = false;
-    if (this.pendingRecord) {
-      this.pendingRecord = false;
-      this.record();
-    }
-  }
-  get currentIndex() {
-    return this.index;
-  }
-  get snapshotCount() {
-    return this.snapshots.length;
-  }
-  get canGoBack() {
-    return this.index > 0;
-  }
-  get canGoForward() {
-    return this.index < this.snapshots.length - 1;
+function getOrCreateHistoryTracker(target, options = {}) {
+  let tracker = historyTrackersRegistry.get(target);
+  if (!tracker) {
+    tracker = new HistoryTracker(target, options);
+    historyTrackersRegistry.set(target, tracker);
   }
-  record() {
-    if (this.index < this.snapshots.length - 1) {
-      this.snapshots.splice(this.index + 1);
-    }
-    this.snapshots.push(getSnapshot(this.target));
-    this.index++;
-    if (this.snapshots.length > this.maxSnapshots) {
-      const excess = this.snapshots.length - this.maxSnapshots;
-      this.snapshots.splice(0, excess);
-      this.index -= excess;
-    }
-  }
-  goBack() {
-    if (!this.canGoBack) return;
-    this.goTo(this.index - 1);
-  }
-  goForward() {
-    if (!this.canGoForward) return;
-    this.goTo(this.index + 1);
-  }
-  goTo(index) {
-    if (index < 0 || index >= this.snapshots.length) return;
-    const node = getStateTreeNode(this.target);
-    const rootNode = node.getRoot();
-    const wasApplying = rootNode.$isApplyingHistory;
-    rootNode.$isApplyingHistory = true;
-    this.isApplying = true;
-    try {
-      this.index = index;
-      applySnapshot(this.target, this.snapshots[index]);
-    } finally {
-      this.isApplying = false;
-      rootNode.$isApplyingHistory = wasApplying;
-    }
-  }
-  getSnapshot(index) {
-    if (index < 0 || index >= this.snapshots.length) {
-      throw new Error(`[jotai-state-tree] Invalid snapshot index: ${index}`);
+  return tracker;
+}
+function createUndoManager(target, options) {
+  const tracker = getOrCreateHistoryTracker(target, options);
+  tracker.autoRecord = true;
+  const store = getGlobalStore();
+  return {
+    get canUndo() {
+      const state = store.get(tracker.historyAtom);
+      return state.currentIndex >= 0;
+    },
+    get canRedo() {
+      const state = store.get(tracker.historyAtom);
+      return state.currentIndex < state.entries.length - 1;
+    },
+    get undoLevels() {
+      const state = store.get(tracker.historyAtom);
+      return state.currentIndex + 1;
+    },
+    get redoLevels() {
+      const state = store.get(tracker.historyAtom);
+      return state.entries.length - state.currentIndex - 1;
+    },
+    get history() {
+      const state = store.get(tracker.historyAtom);
+      return state.entries;
+    },
+    get historyIndex() {
+      const state = store.get(tracker.historyAtom);
+      return state.currentIndex;
+    },
+    undo() {
+      tracker.undo();
+    },
+    redo() {
+      tracker.redo();
+    },
+    clear() {
+      tracker.clear();
+    },
+    startGroup() {
+      tracker.startGroup();
+    },
+    endGroup() {
+      tracker.endGroup();
+    },
+    withoutUndo(fn) {
+      return tracker.withoutUndo(fn);
+    },
+    dispose() {
+      tracker.dispose();
     }
-    return this.snapshots[index];
-  }
-  clear() {
-    this.snapshots = [];
-    this.index = -1;
-    this.record();
+  };
+}
+function createTimeTravelManager(target, options) {
+  const tracker = getOrCreateHistoryTracker(target, options);
+  if (options?.autoRecord) {
+    tracker.autoRecord = true;
   }
-  dispose() {
-    if (this.disposer) {
-      this.disposer();
-      this.disposer = null;
-    }
-    if (this.actionDisposer) {
-      this.actionDisposer();
-      this.actionDisposer = null;
+  const store = getGlobalStore();
+  return {
+    get currentIndex() {
+      const state = store.get(tracker.historyAtom);
+      return state.currentIndex + 1;
+    },
+    get snapshotCount() {
+      const state = store.get(tracker.historyAtom);
+      return state.entries.length + 1;
+    },
+    get canGoBack() {
+      const state = store.get(tracker.historyAtom);
+      return state.currentIndex + 1 > 0;
+    },
+    get canGoForward() {
+      const state = store.get(tracker.historyAtom);
+      return state.currentIndex + 1 < state.entries.length + 1 - 1;
+    },
+    record() {
+      tracker.record();
+    },
+    goBack() {
+      tracker.goBack();
+    },
+    goForward() {
+      tracker.goForward();
+    },
+    goTo(index) {
+      tracker.goTo(index);
+    },
+    getSnapshot(index) {
+      return tracker.getSnapshot(index);
+    },
+    clear() {
+      tracker.clear();
+    },
+    dispose() {
+      tracker.dispose();
     }
-  }
-};
-function createTimeTravelManager(target, options) {
-  return new TimeTravelManager(target, options);
+  };
 }
 var ActionRecorder = class {
   constructor(target) {
@@ -1302,6 +1435,7 @@ function createActionRecorder(target) {
 export {
   setLifecycleHookHandlers,
   getIsApplyingSnapshotOrPatch,
+  setIsApplyingSnapshotOrPatch,
   getGlobalStore,
   setGlobalStore,
   resetGlobalStore,
@@ -1362,6 +1496,7 @@ export {
   freeze,
   isFrozen,
   unfreeze,
+  getOrCreateHistoryTracker,
   createUndoManager,
   createTimeTravelManager,
   createActionRecorder