jotai-state-tree 1.4.0 → 1.4.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.js CHANGED
@@ -1883,6 +1883,9 @@ var ModelType = class _ModelType {
1883
1883
  }
1884
1884
  return descriptor.value;
1885
1885
  }
1886
+ if (propStr === "toggle") {
1887
+ console.log("PROXY GET toggle:", propStr, "in allActions:", propStr in allActions, "keys:", Object.keys(allActions), "node alive:", node.$isAlive);
1888
+ }
1886
1889
  if (propStr in allActions) {
1887
1890
  return allActions[propStr];
1888
1891
  }
package/dist/index.mjs CHANGED
@@ -895,6 +895,9 @@ var ModelType = class _ModelType {
895
895
  }
896
896
  return descriptor.value;
897
897
  }
898
+ if (propStr === "toggle") {
899
+ console.log("PROXY GET toggle:", propStr, "in allActions:", propStr in allActions, "keys:", Object.keys(allActions), "node alive:", node.$isAlive);
900
+ }
898
901
  if (propStr in allActions) {
899
902
  return allActions[propStr];
900
903
  }
package/dist/react.js CHANGED
@@ -1249,11 +1249,14 @@ function useHydrateStore(target, snapshot, options) {
1249
1249
  (0, import_utils.useHydrateAtoms)(pairs, { store: options?.store ?? getGlobalStore() });
1250
1250
  }
1251
1251
  }
1252
+ var undoManagersCache = /* @__PURE__ */ new WeakMap();
1253
+ var timeTravelManagersCache = /* @__PURE__ */ new WeakMap();
1252
1254
  function useUndoManager(target, options) {
1253
- const managerRef = (0, import_react.useRef)(null);
1254
1255
  const [, forceUpdate] = (0, import_react.useState)(0);
1255
- if (!managerRef.current) {
1256
- managerRef.current = createUndoManager(target, options);
1256
+ let manager = target && typeof target === "object" ? undoManagersCache.get(target) : void 0;
1257
+ if (!manager && target && typeof target === "object") {
1258
+ manager = createUndoManager(target, options);
1259
+ undoManagersCache.set(target, manager);
1257
1260
  }
1258
1261
  (0, import_react.useEffect)(() => {
1259
1262
  const disposer = onPatch(target, () => {
@@ -1261,19 +1264,16 @@ function useUndoManager(target, options) {
1261
1264
  });
1262
1265
  return () => {
1263
1266
  disposer();
1264
- if (managerRef.current) {
1265
- managerRef.current.dispose();
1266
- managerRef.current = null;
1267
- }
1268
1267
  };
1269
1268
  }, [target]);
1270
- return managerRef.current;
1269
+ return manager;
1271
1270
  }
1272
1271
  function useTimeTravelManager(target, options) {
1273
- const managerRef = (0, import_react.useRef)(null);
1274
1272
  const [, forceUpdate] = (0, import_react.useState)(0);
1275
- if (!managerRef.current) {
1276
- managerRef.current = createTimeTravelManager(target, options);
1273
+ let manager = target && typeof target === "object" ? timeTravelManagersCache.get(target) : void 0;
1274
+ if (!manager && target && typeof target === "object") {
1275
+ manager = createTimeTravelManager(target, options);
1276
+ timeTravelManagersCache.set(target, manager);
1277
1277
  }
1278
1278
  (0, import_react.useEffect)(() => {
1279
1279
  const disposer = onPatch(target, () => {
@@ -1281,13 +1281,9 @@ function useTimeTravelManager(target, options) {
1281
1281
  });
1282
1282
  return () => {
1283
1283
  disposer();
1284
- if (managerRef.current) {
1285
- managerRef.current.dispose();
1286
- managerRef.current = null;
1287
- }
1288
1284
  };
1289
1285
  }, [target]);
1290
- return managerRef.current;
1286
+ return manager;
1291
1287
  }
1292
1288
  // Annotate the CommonJS export names for ESM import in node:
1293
1289
  0 && (module.exports = {
package/dist/react.mjs CHANGED
@@ -389,11 +389,14 @@ function useHydrateStore(target, snapshot, options) {
389
389
  useHydrateAtoms(pairs, { store: options?.store ?? getGlobalStore() });
390
390
  }
391
391
  }
392
+ var undoManagersCache = /* @__PURE__ */ new WeakMap();
393
+ var timeTravelManagersCache = /* @__PURE__ */ new WeakMap();
392
394
  function useUndoManager(target, options) {
393
- const managerRef = useRef(null);
394
395
  const [, forceUpdate] = useState(0);
395
- if (!managerRef.current) {
396
- managerRef.current = createUndoManager(target, options);
396
+ let manager = target && typeof target === "object" ? undoManagersCache.get(target) : void 0;
397
+ if (!manager && target && typeof target === "object") {
398
+ manager = createUndoManager(target, options);
399
+ undoManagersCache.set(target, manager);
397
400
  }
398
401
  useEffect(() => {
399
402
  const disposer = onPatch(target, () => {
@@ -401,19 +404,16 @@ function useUndoManager(target, options) {
401
404
  });
402
405
  return () => {
403
406
  disposer();
404
- if (managerRef.current) {
405
- managerRef.current.dispose();
406
- managerRef.current = null;
407
- }
408
407
  };
409
408
  }, [target]);
410
- return managerRef.current;
409
+ return manager;
411
410
  }
412
411
  function useTimeTravelManager(target, options) {
413
- const managerRef = useRef(null);
414
412
  const [, forceUpdate] = useState(0);
415
- if (!managerRef.current) {
416
- managerRef.current = createTimeTravelManager(target, options);
413
+ let manager = target && typeof target === "object" ? timeTravelManagersCache.get(target) : void 0;
414
+ if (!manager && target && typeof target === "object") {
415
+ manager = createTimeTravelManager(target, options);
416
+ timeTravelManagersCache.set(target, manager);
417
417
  }
418
418
  useEffect(() => {
419
419
  const disposer = onPatch(target, () => {
@@ -421,13 +421,9 @@ function useTimeTravelManager(target, options) {
421
421
  });
422
422
  return () => {
423
423
  disposer();
424
- if (managerRef.current) {
425
- managerRef.current.dispose();
426
- managerRef.current = null;
427
- }
428
424
  };
429
425
  }, [target]);
430
- return managerRef.current;
426
+ return manager;
431
427
  }
432
428
  export {
433
429
  Observer,
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "jotai-state-tree",
3
- "version": "1.4.0",
3
+ "version": "1.4.1",
4
4
  "description": "MobX-State-Tree API compatible library powered by Jotai",
5
5
  "main": "dist/index.js",
6
6
  "module": "dist/index.mjs",
package/src/model.ts CHANGED
@@ -359,6 +359,9 @@ class ModelType<
359
359
  }
360
360
 
361
361
  // Check actions
362
+ if (propStr === "toggle") {
363
+ console.log("PROXY GET toggle:", propStr, "in allActions:", propStr in allActions, "keys:", Object.keys(allActions), "node alive:", node.$isAlive);
364
+ }
362
365
  if (propStr in allActions) {
363
366
  return allActions[propStr];
364
367
  }
package/src/react.ts CHANGED
@@ -702,6 +702,9 @@ export { hasStateTreeNode };
702
702
  // Undo/Redo & Time Travel Hooks
703
703
  // ============================================================================
704
704
 
705
+ const undoManagersCache = new WeakMap<any, IUndoManager>();
706
+ const timeTravelManagersCache = new WeakMap<any, ITimeTravelManager>();
707
+
705
708
  /**
706
709
  * Hook to create and use an UndoManager.
707
710
  * Automatically handles the subscription lifecycle and triggers re-renders on changes.
@@ -710,11 +713,12 @@ export function useUndoManager(
710
713
  target: unknown,
711
714
  options?: IUndoManagerOptions,
712
715
  ): IUndoManager {
713
- const managerRef = useRef<IUndoManager | null>(null);
714
716
  const [, forceUpdate] = useState(0);
715
717
 
716
- if (!managerRef.current) {
717
- managerRef.current = createUndoManager(target, options);
718
+ let manager = (target && typeof target === "object") ? undoManagersCache.get(target) : undefined;
719
+ if (!manager && target && typeof target === "object") {
720
+ manager = createUndoManager(target, options);
721
+ undoManagersCache.set(target, manager);
718
722
  }
719
723
 
720
724
  useEffect(() => {
@@ -723,14 +727,10 @@ export function useUndoManager(
723
727
  });
724
728
  return () => {
725
729
  disposer();
726
- if (managerRef.current) {
727
- managerRef.current.dispose();
728
- managerRef.current = null;
729
- }
730
730
  };
731
731
  }, [target]);
732
732
 
733
- return managerRef.current;
733
+ return manager!;
734
734
  }
735
735
 
736
736
  /**
@@ -744,11 +744,12 @@ export function useTimeTravelManager(
744
744
  autoRecord?: boolean;
745
745
  },
746
746
  ): ITimeTravelManager {
747
- const managerRef = useRef<ITimeTravelManager | null>(null);
748
747
  const [, forceUpdate] = useState(0);
749
748
 
750
- if (!managerRef.current) {
751
- managerRef.current = createTimeTravelManager(target, options);
749
+ let manager = (target && typeof target === "object") ? timeTravelManagersCache.get(target) : undefined;
750
+ if (!manager && target && typeof target === "object") {
751
+ manager = createTimeTravelManager(target, options);
752
+ timeTravelManagersCache.set(target, manager);
752
753
  }
753
754
 
754
755
  useEffect(() => {
@@ -757,14 +758,10 @@ export function useTimeTravelManager(
757
758
  });
758
759
  return () => {
759
760
  disposer();
760
- if (managerRef.current) {
761
- managerRef.current.dispose();
762
- managerRef.current = null;
763
- }
764
761
  };
765
762
  }, [target]);
766
763
 
767
- return managerRef.current;
764
+ return manager!;
768
765
  }
769
766
 
770
767
  // ============================================================================