jotai-state-tree 1.3.2 → 1.3.4

package/dist/{chunk-OAXK4KFM.mjs → chunk-NFJRKXCI.mjs}

@@ -858,6 +858,7 @@ export {
   $treenode,
   getStateTreeNode,
   hasStateTreeNode,
+  getSnapshotFromNode,
   applySnapshotToNode,
   resolveIdentifier,
   getRegistryStats,

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-BV2K9utF.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-BV2K9utF.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, x as IReversibleJsonPatch } from './tree-S8buyIlj.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-S8buyIlj.mjs';
 import 'jotai/vanilla/internals';
 import 'jotai';
 

package/dist/index.d.ts

@@ -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-BV2K9utF.js';
-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-BV2K9utF.js';
+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-S8buyIlj.js';
+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-S8buyIlj.js';
 import 'jotai/vanilla/internals';
 import 'jotai';
 

package/dist/index.js

@@ -2418,6 +2418,8 @@ var MSTArray = class _MSTArray extends Array {
     return [...this];
   }
   syncToNode() {
+    const oldArray = this.node.getValue() || [];
+    const newArray = [...this];
     const existingChildNodes = /* @__PURE__ */ new Set();
     for (const [, child] of this.node.getChildren()) {
       existingChildNodes.add(child);
@@ -2469,7 +2471,63 @@ var MSTArray = class _MSTArray extends Array {
     for (const [key, childNode] of newChildren) {
       this.node.addChild(key, childNode);
     }
-    this.node.setValue([...this]);
+    const patches = [];
+    const reversePatches = [];
+    if (newArray.length > oldArray.length && oldArray.every((val, idx) => val === newArray[idx])) {
+      for (let i = oldArray.length; i < newArray.length; i++) {
+        const childNode = this.node.getChild(String(i));
+        const valSnap = childNode ? getSnapshotFromNode(childNode) : newArray[i];
+        patches.push({
+          op: "add",
+          path: `${this.node.$path}/${i}`,
+          value: valSnap
+        });
+        reversePatches.push({
+          op: "remove",
+          path: `${this.node.$path}/${i}`
+        });
+      }
+    } else if (newArray.length < oldArray.length && newArray.every((val, idx) => val === oldArray[idx])) {
+      for (let i = oldArray.length - 1; i >= newArray.length; i--) {
+        const childNode = this.node.getChild(String(i));
+        const oldValSnap = childNode ? getSnapshotFromNode(childNode) : oldArray[i];
+        patches.push({
+          op: "remove",
+          path: `${this.node.$path}/${i}`
+        });
+        reversePatches.push({
+          op: "add",
+          path: `${this.node.$path}/${i}`,
+          value: oldValSnap
+        });
+      }
+    } else {
+      const oldSnap = oldArray.map((_, idx) => {
+        const childNode = this.node.getChild(String(idx));
+        return childNode ? getSnapshotFromNode(childNode) : oldArray[idx];
+      });
+      const newSnap = newArray.map((_, idx) => {
+        const childNode = this.node.getChild(String(idx));
+        return childNode ? getSnapshotFromNode(childNode) : newArray[idx];
+      });
+      patches.push({
+        op: "replace",
+        path: this.node.$path,
+        value: newSnap
+      });
+      reversePatches.push({
+        op: "replace",
+        path: this.node.$path,
+        value: oldSnap
+      });
+    }
+    const store = getGlobalStore();
+    store.set(this.node.valueAtom, newArray);
+    this.node.invalidateSnapshot();
+    patches.forEach((patch, idx) => {
+      this.node.notifyPatch(patch, reversePatches[idx]);
+    });
+    this.node.notifyVolatileChange();
   }
 };
 var ArrayType = class {

package/dist/index.mjs

@@ -27,6 +27,7 @@ import {
   getRelativePath,
   getRoot,
   getSnapshot,
+  getSnapshotFromNode,
   getStateTreeNode,
   getTreeStats,
   getType,
@@ -57,7 +58,7 @@ import {
   tryResolve,
   unfreeze,
   walk
-} from "./chunk-OAXK4KFM.mjs";
+} from "./chunk-NFJRKXCI.mjs";
 
 // src/primitives.ts
 function createSimpleType(name, validator, defaultValue) {
@@ -1479,6 +1480,8 @@ var MSTArray = class _MSTArray extends Array {
     return [...this];
   }
   syncToNode() {
+    const oldArray = this.node.getValue() || [];
+    const newArray = [...this];
     const existingChildNodes = /* @__PURE__ */ new Set();
     for (const [, child] of this.node.getChildren()) {
       existingChildNodes.add(child);
@@ -1530,7 +1533,63 @@ var MSTArray = class _MSTArray extends Array {
     for (const [key, childNode] of newChildren) {
       this.node.addChild(key, childNode);
     }
-    this.node.setValue([...this]);
+    const patches = [];
+    const reversePatches = [];
+    if (newArray.length > oldArray.length && oldArray.every((val, idx) => val === newArray[idx])) {
+      for (let i = oldArray.length; i < newArray.length; i++) {
+        const childNode = this.node.getChild(String(i));
+        const valSnap = childNode ? getSnapshotFromNode(childNode) : newArray[i];
+        patches.push({
+          op: "add",
+          path: `${this.node.$path}/${i}`,
+          value: valSnap
+        });
+        reversePatches.push({
+          op: "remove",
+          path: `${this.node.$path}/${i}`
+        });
+      }
+    } else if (newArray.length < oldArray.length && newArray.every((val, idx) => val === oldArray[idx])) {
+      for (let i = oldArray.length - 1; i >= newArray.length; i--) {
+        const childNode = this.node.getChild(String(i));
+        const oldValSnap = childNode ? getSnapshotFromNode(childNode) : oldArray[i];
+        patches.push({
+          op: "remove",
+          path: `${this.node.$path}/${i}`
+        });
+        reversePatches.push({
+          op: "add",
+          path: `${this.node.$path}/${i}`,
+          value: oldValSnap
+        });
+      }
+    } else {
+      const oldSnap = oldArray.map((_, idx) => {
+        const childNode = this.node.getChild(String(idx));
+        return childNode ? getSnapshotFromNode(childNode) : oldArray[idx];
+      });
+      const newSnap = newArray.map((_, idx) => {
+        const childNode = this.node.getChild(String(idx));
+        return childNode ? getSnapshotFromNode(childNode) : newArray[idx];
+      });
+      patches.push({
+        op: "replace",
+        path: this.node.$path,
+        value: newSnap
+      });
+      reversePatches.push({
+        op: "replace",
+        path: this.node.$path,
+        value: oldSnap
+      });
+    }
+    const store = getGlobalStore();
+    store.set(this.node.valueAtom, newArray);
+    this.node.invalidateSnapshot();
+    patches.forEach((patch, idx) => {
+      this.node.notifyPatch(patch, reversePatches[idx]);
+    });
+    this.node.notifyVolatileChange();
   }
 };
 var ArrayType = class {

package/dist/react.d.mts

@@ -1,6 +1,6 @@
 import React, { ComponentType, FC, ReactNode } from 'react';
-import { ag as getGlobalStore } from './tree-BV2K9utF.mjs';
-export { az as hasStateTreeNode } from './tree-BV2K9utF.mjs';
+import { ag as getGlobalStore } from './tree-S8buyIlj.mjs';
+export { az as hasStateTreeNode } from './tree-S8buyIlj.mjs';
 import 'jotai/vanilla/internals';
 import 'jotai';
 

package/dist/react.d.ts

@@ -1,6 +1,6 @@
 import React, { ComponentType, FC, ReactNode } from 'react';
-import { ag as getGlobalStore } from './tree-BV2K9utF.js';
-export { az as hasStateTreeNode } from './tree-BV2K9utF.js';
+import { ag as getGlobalStore } from './tree-S8buyIlj.js';
+export { az as hasStateTreeNode } from './tree-S8buyIlj.js';
 import 'jotai/vanilla/internals';
 import 'jotai';
 

package/dist/react.mjs

@@ -9,7 +9,7 @@ import {
   onPatch,
   onSnapshot,
   setActiveTrackingFn
-} from "./chunk-OAXK4KFM.mjs";
+} from "./chunk-NFJRKXCI.mjs";
 
 // src/react.ts
 import React, {

package/dist/{tree-BV2K9utF.d.mts → tree-S8buyIlj.d.mts}

@@ -375,7 +375,7 @@ declare class StateTreeNode implements IStateTreeNode {
     /** Subscribe to patches */
     onPatch(listener: (patch: IJsonPatch, reversePatch: IReversibleJsonPatch) => void): IDisposer;
     /** Notify patch listeners */
-    private notifyPatch;
+    notifyPatch(patch: IJsonPatch, reversePatch: IReversibleJsonPatch): void;
     /** Notify snapshot listeners */
     private notifySnapshotChange;
     /** Notify about a property change (for use by model proxy) */

package/dist/{tree-BV2K9utF.d.ts → tree-S8buyIlj.d.ts}

@@ -375,7 +375,7 @@ declare class StateTreeNode implements IStateTreeNode {
     /** Subscribe to patches */
     onPatch(listener: (patch: IJsonPatch, reversePatch: IReversibleJsonPatch) => void): IDisposer;
     /** Notify patch listeners */
-    private notifyPatch;
+    notifyPatch(patch: IJsonPatch, reversePatch: IReversibleJsonPatch): void;
     /** Notify snapshot listeners */
     private notifySnapshotChange;
     /** Notify about a property change (for use by model proxy) */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jotai-state-tree",
-  "version": "1.3.2",
+  "version": "1.3.4",
   "description": "MobX-State-Tree API compatible library powered by Jotai",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/src/__tests__/index.test.ts

@@ -687,6 +687,51 @@ describe("Patches", () => {
     disposer();
   });
 
+  it("should listen to complex array patches", () => {
+    const Todo = types.model("Todo", {
+      id: types.identifier,
+      title: types.string,
+      done: types.optional(types.boolean, false),
+    });
+
+    const TodoStore = types
+      .model("TodoStore", {
+        todos: types.optional(types.array(Todo), []),
+      })
+      .actions((self) => ({
+        addTodo(title: string) {
+          self.todos.push({
+            id: "1",
+            title,
+            done: false,
+          });
+        },
+      }));
+
+    const store = TodoStore.create({
+      todos: [],
+    });
+
+    const patches: any[] = [];
+    onPatch(store, (patch) => {
+      patches.push(patch);
+    });
+
+    store.addTodo("Learn jotai-state-tree");
+
+    expect(patches).toEqual([
+      {
+        op: "add",
+        path: "/todos/0",
+        value: {
+          id: "1",
+          title: "Learn jotai-state-tree",
+          done: false,
+        },
+      },
+    ]);
+  });
+
   it("should apply patches", () => {
     const Model = types.model("Model", {
       value: types.number,

package/src/array.ts

@@ -10,12 +10,15 @@ import type {
   IValidationContext,
   IValidationResult,
   IAnyType,
+  IJsonPatch,
+  IReversibleJsonPatch,
 } from "./types";
 import {
   StateTreeNode,
   $treenode,
   getStateTreeNode,
   getGlobalStore,
+  getSnapshotFromNode,
 } from "./tree";
 import { canWrite } from "./lifecycle";
 
@@ -235,6 +238,9 @@ class MSTArray<T> extends Array<T> implements IMSTArray<T> {
   }
 
   private syncToNode(): void {
+    const oldArray = (this.node.getValue() as unknown[]) || [];
+    const newArray = [...this];
+
     // Collect existing child nodes for cleanup comparison
     const existingChildNodes = new Set<StateTreeNode>();
     for (const [, child] of this.node.getChildren()) {
@@ -303,8 +309,77 @@ class MSTArray<T> extends Array<T> implements IMSTArray<T> {
       this.node.addChild(key, childNode);
     }
 
-    // Update the node's value
-    this.node.setValue([...this]);
+    // Determine diff and generate granular patches
+    const patches: IJsonPatch[] = [];
+    const reversePatches: IReversibleJsonPatch[] = [];
+
+    // Case 1: Simple push (items added at the end)
+    if (newArray.length > oldArray.length && oldArray.every((val, idx) => val === newArray[idx])) {
+      for (let i = oldArray.length; i < newArray.length; i++) {
+        const childNode = this.node.getChild(String(i));
+        const valSnap = childNode ? getSnapshotFromNode(childNode) : newArray[i];
+        patches.push({
+          op: "add",
+          path: `${this.node.$path}/${i}`,
+          value: valSnap,
+        });
+        reversePatches.push({
+          op: "remove",
+          path: `${this.node.$path}/${i}`,
+        });
+      }
+    }
+    // Case 2: Simple pop (items removed from the end)
+    else if (newArray.length < oldArray.length && newArray.every((val, idx) => val === oldArray[idx])) {
+      for (let i = oldArray.length - 1; i >= newArray.length; i--) {
+        const childNode = this.node.getChild(String(i));
+        const oldValSnap = childNode ? getSnapshotFromNode(childNode) : oldArray[i];
+        patches.push({
+          op: "remove",
+          path: `${this.node.$path}/${i}`,
+        });
+        reversePatches.push({
+          op: "add",
+          path: `${this.node.$path}/${i}`,
+          value: oldValSnap,
+        });
+      }
+    }
+    // Case 3: Other mutations (fallback to replace array)
+    else {
+      const oldSnap = oldArray.map((_, idx) => {
+        const childNode = this.node.getChild(String(idx));
+        return childNode ? getSnapshotFromNode(childNode) : oldArray[idx];
+      });
+      const newSnap = newArray.map((_, idx) => {
+        const childNode = this.node.getChild(String(idx));
+        return childNode ? getSnapshotFromNode(childNode) : newArray[idx];
+      });
+
+      patches.push({
+        op: "replace",
+        path: this.node.$path,
+        value: newSnap,
+      });
+      reversePatches.push({
+        op: "replace",
+        path: this.node.$path,
+        value: oldSnap,
+      });
+    }
+
+    // Update the node's value silently
+    const store = getGlobalStore();
+    store.set(this.node.valueAtom, newArray);
+    this.node.invalidateSnapshot();
+
+    // Notify patch listeners
+    patches.forEach((patch, idx) => {
+      this.node.notifyPatch(patch, reversePatches[idx]);
+    });
+
+    // Notify snapshot changes
+    this.node.notifyVolatileChange();
   }
 }
 

package/src/tree.ts

@@ -385,7 +385,7 @@ export class StateTreeNode implements IStateTreeNode {
   }
 
   /** Notify patch listeners */
-  private notifyPatch(patch: IJsonPatch, reversePatch: IReversibleJsonPatch) {
+  notifyPatch(patch: IJsonPatch, reversePatch: IReversibleJsonPatch) {
     this.patchListeners.forEach((listener) => listener(patch, reversePatch));
     // Bubble up to parent
     if (this.$parent) {