jotai-state-tree 1.3.6 → 1.4.0

package/dist/{chunk-K2MLK6B7.mjs → chunk-MSLAD5CJ.mjs}

@@ -899,6 +899,406 @@ function unfreeze(target) {
   }
 }
 
+// src/undo.ts
+var UndoManager = class {
+  constructor(target, options = {}) {
+    this.historyEntries = [];
+    this.currentIndex = -1;
+    this.isUndoing = false;
+    this.isRedoing = false;
+    this.skipRecording = false;
+    this.grouping = false;
+    this.actionGrouping = false;
+    this.currentGroup = [];
+    this.currentGroupInverse = [];
+    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.disposer = onPatch(target, (patch, reversePatch) => {
+      this.recordPatch(patch, reversePatch);
+    });
+    this.actionDisposer = onAction(target, () => {
+      const current = getCurrentAction();
+      if (current && !current.parent) {
+        if (this.actionGrouping) {
+          this.endGroup();
+        }
+      }
+    });
+  }
+  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) {
+      return;
+    }
+    const node = getStateTreeNode(this.target);
+    if (node.getRoot().$isApplyingHistory) {
+      return;
+    }
+    const now = Date.now();
+    if (isActionRunning() && !this.grouping) {
+      this.grouping = true;
+      this.actionGrouping = true;
+      this.currentGroup = [];
+      this.currentGroupInverse = [];
+      Promise.resolve().then(() => {
+        if (this.actionGrouping) {
+          this.endGroup();
+        }
+      });
+    }
+    if (this.grouping) {
+      this.currentGroup.push(reversePatch);
+      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;
+      }
+    }
+    this.lastChangeTime = now;
+  }
+  undo() {
+    if (!this.canUndo) {
+      return;
+    }
+    const node = getStateTreeNode(this.target);
+    const rootNode = node.getRoot();
+    const wasApplying = rootNode.$isApplyingHistory;
+    rootNode.$isApplyingHistory = true;
+    this.isUndoing = true;
+    try {
+      const entry = this.historyEntries[this.currentIndex];
+      for (let i = entry.patches.length - 1; i >= 0; i--) {
+        applyPatch(this.target, entry.patches[i]);
+      }
+      this.currentIndex--;
+    } finally {
+      this.isUndoing = false;
+      rootNode.$isApplyingHistory = wasApplying;
+    }
+  }
+  redo() {
+    if (!this.canRedo) {
+      return;
+    }
+    const node = getStateTreeNode(this.target);
+    const rootNode = node.getRoot();
+    const wasApplying = rootNode.$isApplyingHistory;
+    rootNode.$isApplyingHistory = true;
+    this.isRedoing = true;
+    try {
+      this.currentIndex++;
+      const entry = this.historyEntries[this.currentIndex];
+      for (const patch of entry.inversePatches) {
+        applyPatch(this.target, patch);
+      }
+    } finally {
+      this.isRedoing = false;
+      rootNode.$isApplyingHistory = wasApplying;
+    }
+  }
+  clear() {
+    this.historyEntries = [];
+    this.currentIndex = -1;
+    this.currentGroup = [];
+    this.currentGroupInverse = [];
+    this.grouping = false;
+    this.actionGrouping = false;
+  }
+  startGroup() {
+    this.grouping = true;
+    this.actionGrouping = false;
+    this.currentGroup = [];
+    this.currentGroupInverse = [];
+  }
+  endGroup() {
+    if (!this.grouping) {
+      return;
+    }
+    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()
+      });
+      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 = [];
+  }
+  withoutUndo(fn) {
+    this.skipRecording = true;
+    try {
+      return fn();
+    } finally {
+      this.skipRecording = false;
+    }
+  }
+  dispose() {
+    if (this.disposer) {
+      this.disposer();
+      this.disposer = null;
+    }
+    if (this.actionDisposer) {
+      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;
+  }
+  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 this.snapshots[index];
+  }
+  clear() {
+    this.snapshots = [];
+    this.index = -1;
+    this.record();
+  }
+  dispose() {
+    if (this.disposer) {
+      this.disposer();
+      this.disposer = null;
+    }
+    if (this.actionDisposer) {
+      this.actionDisposer();
+      this.actionDisposer = null;
+    }
+  }
+};
+function createTimeTravelManager(target, options) {
+  return new TimeTravelManager(target, options);
+}
+var ActionRecorder = class {
+  constructor(target) {
+    this.recording = false;
+    this.recordedActions = [];
+    this.disposer = null;
+    this.target = target;
+  }
+  get isRecording() {
+    return this.recording;
+  }
+  get actions() {
+    return [...this.recordedActions];
+  }
+  start() {
+    if (this.recording) return;
+    this.recording = true;
+    this.disposer = onAction(this.target, (action) => {
+      this.recordedActions.push({
+        ...action,
+        timestamp: Date.now()
+      });
+    });
+  }
+  stop() {
+    this.recording = false;
+    if (this.disposer) {
+      this.disposer();
+      this.disposer = null;
+    }
+  }
+  clear() {
+    this.recordedActions = [];
+  }
+  replay(target) {
+    const node = getStateTreeNode(target);
+    for (const action of this.recordedActions) {
+      let currentNode = node;
+      if (action.path) {
+        const parts = action.path.split("/").filter(Boolean);
+        for (const part of parts) {
+          const child = currentNode.getChild(part);
+          if (!child) {
+            console.warn(`[jotai-state-tree] Could not find path: ${action.path}`);
+            continue;
+          }
+          currentNode = child;
+        }
+      }
+      const instance = currentNode.getInstance();
+      if (typeof instance[action.name] === "function") {
+        instance[action.name](...action.args);
+      }
+    }
+  }
+  export() {
+    return JSON.stringify(this.recordedActions, null, 2);
+  }
+  import(json) {
+    try {
+      const actions = JSON.parse(json);
+      if (Array.isArray(actions)) {
+        this.recordedActions = actions;
+      }
+    } catch (e) {
+      throw new Error(`[jotai-state-tree] Failed to import actions: ${e}`);
+    }
+  }
+  dispose() {
+    this.stop();
+    this.clear();
+  }
+};
+function createActionRecorder(target) {
+  return new ActionRecorder(target);
+}
+
 export {
   setLifecycleHookHandlers,
   getIsApplyingSnapshotOrPatch,
@@ -961,5 +1361,8 @@ export {
   getOrCreatePath,
   freeze,
   isFrozen,
-  unfreeze
+  unfreeze,
+  createUndoManager,
+  createTimeTravelManager,
+  createActionRecorder
 };

package/dist/index.d.mts

@@ -1,5 +1,5 @@
-import { I as ISimpleType, a as IType, b as IIdentifierType, c as IIdentifierNumberType, d as ILiteralType, e as IEnumerationType, f as IFrozenType, M as ModelProperties, g as IModelType, h as MixinConfig, i as IMixin, j as IAnyType, k as IArrayType, l as IMapType, m as IOptionalType, n as IMaybeType, o as IMaybeNullType, p as IUnionType, U as UnionOptions, q as ILateType, r as IAnyModelType, R as ReferenceOptions, s as IReferenceType, t as ISafeReferenceType, u as IRefinementType, v as IDisposer, S as SnapshotIn, w as Instance, x as IReversibleJsonPatch } from './tree-C2ADWEka.mjs';
-export { L as CustomTypeOptions, D as IAnyComplexType, E as IAnyMixin, G as IJsonPatch, z as IMSTArray, A as IMSTMap, y as IStateTreeNode, H as IValidationContext, K as IValidationError, J as IValidationResult, B as ModelInstance, F as ModelSelf, C as SnapshotOut, T as applyPatch, O as applySnapshot, aw as cleanupStaleEntries, ax as clearAllRegistries, aa as clone, aq as cloneDeep, a8 as destroy, a9 as detach, am as findAll, an as findFirst, as as freeze, a2 as getEnv, ag as getGlobalStore, a4 as getIdentifier, af as getMembers, ar as getOrCreatePath, Y as getParent, $ as getParentOfType, a0 as getPath, a1 as getPathParts, av as getRegistryStats, aj as getRelativePath, X as getRoot, N as getSnapshot, ap as getTreeStats, a3 as getType, _ as hasParent, al as haveSameRoot, a5 as isAlive, ak as isAncestor, at as isFrozen, a6 as isRoot, a7 as isStateTreeNode, ao as isValidReference, W as onAction, ay as onLifecycleChange, Q as onPatch, P as onSnapshot, V as recordPatches, ai as resetGlobalStore, ae as resolveIdentifier, ac as resolvePath, ah as setGlobalStore, Z as tryGetParent, ad as tryResolve, au as unfreeze, ab as walk } from './tree-C2ADWEka.mjs';
+import { I as ISimpleType, a as IType, b as IIdentifierType, c as IIdentifierNumberType, d as ILiteralType, e as IEnumerationType, f as IFrozenType, M as ModelProperties, g as IModelType, h as MixinConfig, i as IMixin, j as IAnyType, k as IArrayType, l as IMapType, m as IOptionalType, n as IMaybeType, o as IMaybeNullType, p as IUnionType, U as UnionOptions, q as ILateType, r as IAnyModelType, R as ReferenceOptions, s as IReferenceType, t as ISafeReferenceType, u as IRefinementType, v as IDisposer, S as SnapshotIn, w as Instance } from './undo-BcBI_BQM.mjs';
+export { L as CustomTypeOptions, aG as IActionRecorder, aH as IActionRecording, C as IAnyComplexType, D as IAnyMixin, aE as IHistoryEntry, F as IJsonPatch, y as IMSTArray, z as IMSTMap, G as IReversibleJsonPatch, x as IStateTreeNode, aF as ITimeTravelManager, aC as IUndoManager, aD as IUndoManagerOptions, H as IValidationContext, K as IValidationError, J as IValidationResult, A as ModelInstance, E as ModelSelf, B as SnapshotOut, T as applyPatch, O as applySnapshot, aw as cleanupStaleEntries, ax as clearAllRegistries, aa as clone, aq as cloneDeep, aB as createActionRecorder, aA as createTimeTravelManager, az as createUndoManager, a8 as destroy, a9 as detach, am as findAll, an as findFirst, as as freeze, a2 as getEnv, ag as getGlobalStore, a4 as getIdentifier, af as getMembers, ar as getOrCreatePath, Y as getParent, $ as getParentOfType, a0 as getPath, a1 as getPathParts, av as getRegistryStats, aj as getRelativePath, X as getRoot, N as getSnapshot, ap as getTreeStats, a3 as getType, _ as hasParent, al as haveSameRoot, a5 as isAlive, ak as isAncestor, at as isFrozen, a6 as isRoot, a7 as isStateTreeNode, ao as isValidReference, W as onAction, ay as onLifecycleChange, Q as onPatch, P as onSnapshot, V as recordPatches, ai as resetGlobalStore, ae as resolveIdentifier, ac as resolvePath, ah as setGlobalStore, Z as tryGetParent, ad as tryResolve, au as unfreeze, ab as walk } from './undo-BcBI_BQM.mjs';
 import 'jotai/vanilla/internals';
 import 'jotai';
 
@@ -493,125 +493,6 @@ declare function safeCreate<T extends IAnyType>(type: T, snapshot: unknown, env?
  */
 declare function createWithDefaults<T extends IAnyType>(type: T, snapshot?: Partial<SnapshotIn<T>>, env?: unknown): Instance<T>;
 
-/**
- * Undo/Redo Manager for jotai-state-tree
- * Provides time-travel debugging capabilities
- */
-
-interface IUndoManagerOptions {
-    /** Maximum number of history entries to keep */
-    maxHistoryLength?: number;
-    /** Whether to group rapid changes together */
-    groupByTime?: boolean;
-    /** Time window for grouping changes (ms) */
-    groupingWindow?: number;
-}
-interface IHistoryEntry {
-    /** Patches to apply to undo this entry */
-    patches: IReversibleJsonPatch[];
-    /** Patches to apply to redo this entry */
-    inversePatches: IReversibleJsonPatch[];
-    /** Timestamp when this entry was created */
-    timestamp: number;
-}
-interface IUndoManager {
-    /** Whether there are entries that can be undone */
-    readonly canUndo: boolean;
-    /** Whether there are entries that can be redone */
-    readonly canRedo: boolean;
-    /** Number of undo entries available */
-    readonly undoLevels: number;
-    /** Number of redo entries available */
-    readonly redoLevels: number;
-    /** The full history */
-    readonly history: IHistoryEntry[];
-    /** Current position in history */
-    readonly historyIndex: number;
-    /** Undo the last change */
-    undo(): void;
-    /** Redo the last undone change */
-    redo(): void;
-    /** Clear all history */
-    clear(): void;
-    /** Start grouping changes */
-    startGroup(): void;
-    /** End grouping changes */
-    endGroup(): void;
-    /** Execute a function without recording history */
-    withoutUndo<T>(fn: () => T): T;
-    /** Stop tracking changes */
-    dispose(): void;
-}
-/**
- * Create an undo manager for a state tree
- */
-declare function createUndoManager(target: unknown, options?: IUndoManagerOptions): IUndoManager;
-interface ITimeTravelManager {
-    /** Current snapshot index */
-    readonly currentIndex: number;
-    /** Total number of snapshots */
-    readonly snapshotCount: number;
-    /** Whether we can go back */
-    readonly canGoBack: boolean;
-    /** Whether we can go forward */
-    readonly canGoForward: boolean;
-    /** Record the current snapshot */
-    record(): void;
-    /** Go back to previous snapshot */
-    goBack(): void;
-    /** Go forward to next snapshot */
-    goForward(): void;
-    /** Go to a specific snapshot index */
-    goTo(index: number): void;
-    /** Get snapshot at index */
-    getSnapshot(index: number): unknown;
-    /** Clear all snapshots */
-    clear(): void;
-    /** Dispose and clean up */
-    dispose(): void;
-}
-/**
- * Create a time travel manager for snapshot-based history
- */
-declare function createTimeTravelManager(target: unknown, options?: {
-    maxSnapshots?: number;
-    autoRecord?: boolean;
-}): ITimeTravelManager;
-interface IActionRecording {
-    /** Name of the action */
-    name: string;
-    /** Path to the node where action was called */
-    path: string;
-    /** Arguments passed to the action */
-    args: unknown[];
-    /** Timestamp */
-    timestamp: number;
-}
-interface IActionRecorder {
-    /** Whether currently recording */
-    readonly isRecording: boolean;
-    /** All recorded actions */
-    readonly actions: IActionRecording[];
-    /** Start recording */
-    start(): void;
-    /** Stop recording */
-    stop(): void;
-    /** Clear recorded actions */
-    clear(): void;
-    /** Replay actions on a target */
-    replay(target: unknown): void;
-    /** Export actions as JSON */
-    export(): string;
-    /** Import actions from JSON */
-    import(json: string): void;
-    /** Dispose and clean up */
-    dispose(): void;
-}
-/**
- * Create an action recorder for debugging and testing
- */
-declare function createActionRecorder(target: unknown): IActionRecorder;
-
 /**
  * The `types` namespace contains all type constructors.
  * This matches the MobX-State-Tree API.
@@ -711,4 +592,4 @@ declare function typecheck<T>(type: {
     is(v: unknown): v is T;
 }, value: unknown): void;
 
-export { DatePrimitive as Date, type DynamicReferenceOptions, type IActionRecorder, type IActionRecording, IAnyModelType, IAnyType, IArrayType, IDisposer, IEnumerationType, IFrozenType, type IHistoryEntry, IIdentifierNumberType, IIdentifierType, ILateType, ILiteralType, IMapType, IMaybeNullType, IMaybeType, type IMiddlewareEvent, type IMiddlewareHandler, IMixin, IModelType, IOptionalType, IReferenceType, IRefinementType, IReversibleJsonPatch, ISafeReferenceType, type ISerializedActionCall, ISimpleType, type ITimeTravelManager, IType, type IUndoManager, type IUndoManagerOptions, IUnionType, Instance, MixinConfig, ModelProperties, ReferenceOptions, SnapshotIn, UnionOptions, addMiddleware, applyAction, array, boolean, cast, castToReferenceSnapshot, castToSnapshot, clearModelRegistry, cloneFrozen, compose, createActionRecorder, createTimeTravelManager, createUndoManager, createWithDefaults, custom, types as default, dynamicReference, enumeration, escapeJsonPath, finite, float, flow, frozen, getDebugInfo, getIdentifierAttribute, getModelMetadata, getOrCreate, getRegisteredModelNames, getTypeName, getValidationError, hasIdentifier, identifier, identifierNumber, integer, isArrayType, isFrozenType, isIdentifierType, isInstanceOf, isLateType, isLiteralType, isMapType, isModelRegistered, isModelType, isOptionalType, isPrimitiveType, isProtected, isReferenceType, isType, isUnionType, isValidSnapshot, joinJsonPath, late, lateModel, literal, map, maybe, maybeNull, mixin, model, nullType, nullable, number, onModelRegistered, optional, printTree, protect, recordActions, reference, refinement, registerModel, resolveModel, resolveModelAsync, safeCreate, safeDynamicReference, safeReference, snapshotProcessor, splitJsonPath, string, tryResolveModel, typecheck, types, undefinedType, unescapeJsonPath, union, unprotect, unregisterModel };
+export { DatePrimitive as Date, type DynamicReferenceOptions, IAnyModelType, IAnyType, IArrayType, IDisposer, IEnumerationType, IFrozenType, IIdentifierNumberType, IIdentifierType, ILateType, ILiteralType, IMapType, IMaybeNullType, IMaybeType, type IMiddlewareEvent, type IMiddlewareHandler, IMixin, IModelType, IOptionalType, IReferenceType, IRefinementType, ISafeReferenceType, type ISerializedActionCall, ISimpleType, IType, IUnionType, Instance, MixinConfig, ModelProperties, ReferenceOptions, SnapshotIn, UnionOptions, addMiddleware, applyAction, array, boolean, cast, castToReferenceSnapshot, castToSnapshot, clearModelRegistry, cloneFrozen, compose, createWithDefaults, custom, types as default, dynamicReference, enumeration, escapeJsonPath, finite, float, flow, frozen, getDebugInfo, getIdentifierAttribute, getModelMetadata, getOrCreate, getRegisteredModelNames, getTypeName, getValidationError, hasIdentifier, identifier, identifierNumber, integer, isArrayType, isFrozenType, isIdentifierType, isInstanceOf, isLateType, isLiteralType, isMapType, isModelRegistered, isModelType, isOptionalType, isPrimitiveType, isProtected, isReferenceType, isType, isUnionType, isValidSnapshot, joinJsonPath, late, lateModel, literal, map, maybe, maybeNull, mixin, model, nullType, nullable, number, onModelRegistered, optional, printTree, protect, recordActions, reference, refinement, registerModel, resolveModel, resolveModelAsync, safeCreate, safeDynamicReference, safeReference, snapshotProcessor, splitJsonPath, string, tryResolveModel, typecheck, types, undefinedType, unescapeJsonPath, union, unprotect, unregisterModel };