mobx-keystone 1.25.0 → 2.0.0

package/src/patch/emitPatch.ts

@@ -5,6 +5,7 @@ import type { PathElement } from "../parent/pathTypes"
 import { freezeInternalSnapshot, getInternalSnapshot } from "../snapshot/internal"
 import { assertTweakedObject } from "../tweaker/core"
 import { assertIsFunction, deleteFromArray, isPrimitive } from "../utils"
+import { forEachWithDelayedThrow } from "../utils/forEachWithDelayedThrow"
 import type { Patch } from "./Patch"
 
 const emptyPatchArray: Patch[] = []
@@ -31,12 +32,34 @@ export class InternalPatchRecorder {
     // empty arrays and must not trigger ancestor type checking.
     this.hasChanges = this.patches.length > 0 || this.invPatches.length > 0
   }
+}
 
-  emit(obj: object) {
-    if (this.patches.length > 0) {
-      emitPatches(obj, this.patches, this.invPatches)
-    }
-    this.reset()
+const runNotification = (notify: () => void) => notify()
+
+let patchEmissionDepth = 0
+let emittingPendingPatches = false
+const pendingPatchNotifications: (() => void)[] = []
+
+/** @internal */
+export function beginPatchEmission(): void {
+  patchEmissionDepth++
+}
+
+/** @internal */
+export function endPatchEmission(): void {
+  patchEmissionDepth--
+  flushPendingPatches()
+}
+
+function flushPendingPatches(): void {
+  if (patchEmissionDepth > 0 || emittingPendingPatches || pendingPatchNotifications.length === 0)
+    return
+  emittingPendingPatches = true
+  try {
+    forEachWithDelayedThrow(pendingPatchNotifications, (notify) => notify())
+  } finally {
+    pendingPatchNotifications.length = 0
+    emittingPendingPatches = false
   }
 }
 
@@ -44,11 +67,22 @@ export class InternalPatchRecorder {
  * @internal
  */
 export function emitPatches(obj: object, patches: Patch[], invPatches: Patch[]): void {
-  if (patches.length > 0) {
-    emitGlobalPatch(obj, patches, invPatches)
+  if (patches.length > 0 && (globalPatchListeners.length > 0 || patchListenerCount > 0)) {
+    const synchronousNotifications: (() => void)[] = []
+    if (globalPatchListeners.length > 0) {
+      emitGlobalPatch(obj, patches, invPatches, synchronousNotifications)
+    }
     if (patchListenerCount > 0) {
-      emitPatch(obj, patches, invPatches)
+      emitPatch(obj, patches, invPatches, synchronousNotifications)
     }
+    // Reserve every public notification and its path before recorder callbacks
+    // can cause further mutations. Recorders must run within the mutation's
+    // action / withoutUndo scope, even while public delivery is deferred.
+    // A throwing recorder must not stop the ones registered on ancestor nodes,
+    // nor swallow the deferred public delivery, so the flush is just one more
+    // step of the same delayed-throw delivery.
+    synchronousNotifications.push(flushPendingPatches)
+    forEachWithDelayedThrow(synchronousNotifications, runNotification)
   }
 }
 
@@ -71,8 +105,14 @@ export type OnGlobalPatchesListener = (
  */
 export type OnPatchesDisposer = () => void
 
-const patchListeners = new WeakMap<object, OnPatchesListener[]>()
-const globalPatchListeners: OnGlobalPatchesListener[] = []
+interface PatchSubscription<Listener> {
+  listener: Listener
+  synchronous: boolean
+  active: boolean
+}
+
+const patchListeners = new WeakMap<object, PatchSubscription<OnPatchesListener>[]>()
+const globalPatchListeners: PatchSubscription<OnGlobalPatchesListener>[] = []
 let patchListenerCount = 0
 
 /**
@@ -113,6 +153,15 @@ export function hasPatchListenersFor(target: object): boolean {
  * @returns A disposer to stop listening to patches.
  */
 export function onPatches(subtreeRoot: object, listener: OnPatchesListener): OnPatchesDisposer {
+  return internalOnPatches(subtreeRoot, listener, false)
+}
+
+/** @internal */
+export function internalOnPatches(
+  subtreeRoot: object,
+  listener: OnPatchesListener,
+  synchronous: boolean
+): OnPatchesDisposer {
   assertTweakedObject(subtreeRoot, "subtreeRoot")
   assertIsFunction(listener, "listener")
 
@@ -126,10 +175,12 @@ export function onPatches(subtreeRoot: object, listener: OnPatchesListener): OnP
     patchListeners.set(subtreeRoot, listenersForObject)
   }
 
-  listenersForObject.push(listener)
+  const subscription = { listener, synchronous, active: true }
+  listenersForObject.push(subscription)
   patchListenerCount++
   return () => {
-    if (deleteFromArray(listenersForObject, listener)) {
+    subscription.active = false
+    if (deleteFromArray(listenersForObject, subscription)) {
       patchListenerCount--
     }
   }
@@ -143,25 +194,81 @@ export function onPatches(subtreeRoot: object, listener: OnPatchesListener): OnP
  * @returns A disposer to stop listening to patches.
  */
 export function onGlobalPatches(listener: OnGlobalPatchesListener): OnPatchesDisposer {
+  return internalOnGlobalPatches(listener, false)
+}
+
+/** @internal */
+export function internalOnGlobalPatches(
+  listener: OnGlobalPatchesListener,
+  synchronous: boolean
+): OnPatchesDisposer {
   assertIsFunction(listener, "listener")
 
   if (!isAction(listener)) {
     listener = action(listener.name || "onGlobalPatchesListener", listener)
   }
 
-  globalPatchListeners.push(listener)
+  const subscription = { listener, synchronous, active: true }
+  globalPatchListeners.push(subscription)
   return () => {
-    deleteFromArray(globalPatchListeners, listener)
+    subscription.active = false
+    deleteFromArray(globalPatchListeners, subscription)
   }
 }
 
-function emitGlobalPatch(obj: object, patches: Patch[], inversePatches: Patch[]): void {
-  for (let i = 0; i < globalPatchListeners.length; i++) {
-    const listener = globalPatchListeners[i]
-    listener(obj, patches, inversePatches)
+function notifyPatchSubscriptions<Args extends unknown[]>(
+  subscriptions: PatchSubscription<(...args: Args) => void>[],
+  args: Args,
+  synchronous: boolean
+): void {
+  forEachWithDelayedThrow(subscriptions, (subscription) => {
+    if (subscription.active && subscription.synchronous === synchronous) {
+      subscription.listener(...args)
+    }
+  })
+}
+
+function reservePatchNotifications<Args extends unknown[]>(
+  subscriptions: PatchSubscription<(...args: Args) => void>[],
+  args: Args,
+  synchronousNotifications: (() => void)[]
+): void {
+  let hasSynchronous = false
+  let hasDeferred = false
+  for (let i = 0; i < subscriptions.length; i++) {
+    if (subscriptions[i].synchronous) {
+      hasSynchronous = true
+    } else {
+      hasDeferred = true
+    }
+  }
+  if (!hasSynchronous && !hasDeferred) {
+    return
+  }
+
+  // A listener installed by a reentrant action must not receive earlier patches.
+  const current = subscriptions.slice()
+  if (hasDeferred) {
+    pendingPatchNotifications.push(() => notifyPatchSubscriptions(current, args, false))
+  }
+  if (hasSynchronous) {
+    synchronousNotifications.push(() => notifyPatchSubscriptions(current, args, true))
   }
 }
 
+function emitGlobalPatch(
+  obj: object,
+  patches: Patch[],
+  inversePatches: Patch[],
+  synchronousNotifications: (() => void)[]
+): void {
+  reservePatchNotifications(
+    globalPatchListeners,
+    [obj, patches, inversePatches],
+    synchronousNotifications
+  )
+}
+
 // `reversedPrefix` holds the path segments from the changed node up to (but not
 // including) the current target, in child-to-root order. The prefix to prepend to
 // a patch is that slice reversed (root-to-child); `prefixCount` is how many of the
@@ -171,7 +278,8 @@ function emitPatchForTarget(
   patches: Patch[],
   inversePatches: Patch[],
   reversedPrefix: readonly PathElement[],
-  prefixCount: number
+  prefixCount: number,
+  synchronousNotifications: (() => void)[]
 ): void {
   const listenersForObject = patchListeners.get(obj)
 
@@ -184,19 +292,26 @@ function emitPatchForTarget(
   const invPatchesWithPathPrefix =
     prefixCount > 0 ? prefixPatches(inversePatches, reversedPrefix, prefixCount) : inversePatches
 
-  for (let i = 0; i < listenersForObject.length; i++) {
-    const listener = listenersForObject[i]
-    listener(patchesWithPathPrefix, invPatchesWithPathPrefix)
-  }
+  // Capture mutation-time paths before a deep-change listener can move nodes.
+  reservePatchNotifications(
+    listenersForObject,
+    [patchesWithPathPrefix, invPatchesWithPathPrefix],
+    synchronousNotifications
+  )
 }
 
-function emitPatch(obj: object, patches: Patch[], inversePatches: Patch[]): void {
+function emitPatch(
+  obj: object,
+  patches: Patch[],
+  inversePatches: Patch[],
+  synchronousNotifications: (() => void)[]
+): void {
   // Segments are pushed in child-to-root order (O(1) each) rather than unshifted
   // at the front (O(depth) each), keeping the whole walk O(depth) instead of
   // O(depth^2) on deep trees.
   const reversedPrefix: PathElement[] = []
 
-  emitPatchForTarget(obj, patches, inversePatches, reversedPrefix, 0)
+  emitPatchForTarget(obj, patches, inversePatches, reversedPrefix, 0, synchronousNotifications)
 
   // and also emit subtree listeners all the way to the root
   let parentPath = fastGetParentPath(obj, false)
@@ -207,7 +322,8 @@ function emitPatch(obj: object, patches: Patch[], inversePatches: Patch[]): void
       patches,
       inversePatches,
       reversedPrefix,
-      reversedPrefix.length
+      reversedPrefix.length,
+      synchronousNotifications
     )
 
     parentPath = fastGetParentPath(parentPath.parent, false)

package/src/patch/jsonPatch.ts

@@ -41,6 +41,8 @@ function escapePathComponent(path: string | number): string {
   return path.replace(/~/g, "~0").replace(/\//g, "~1")
 }
 
+const invalidPointerEscape = /~(?:[^01]|$)/
+
 /**
  * Unescapes a json pointer path.
  *
@@ -48,6 +50,9 @@ function escapePathComponent(path: string | number): string {
  * @return The unescaped path
  */
 function unescapePathComponent(path: string): string {
+  if (invalidPointerEscape.test(path)) {
+    throw failure("invalid JSON pointer escape: expected ~0 or ~1")
+  }
   return path.replace(/~1/g, "/").replace(/~0/g, "~")
 }
 

package/src/patch/patchRecorder.ts

@@ -1,10 +1,10 @@
 import { observable } from "mobx"
 import { assertTweakedObject } from "../tweaker/core"
 import {
+  internalOnGlobalPatches,
+  internalOnPatches,
   type OnPatchesDisposer,
   type OnPatchesListener,
-  onGlobalPatches,
-  onPatches,
 } from "./emitPatch"
 import type { Patch } from "./Patch"
 
@@ -111,18 +111,22 @@ export function internalPatchRecorder(
   let onPatchesDisposer: OnPatchesDisposer
 
   if (subtreeRoot) {
-    onPatchesDisposer = onPatches(subtreeRoot, (p, invP) => {
-      if (recording && filter(p, invP)) {
-        events.push({
-          target: subtreeRoot,
-          patches: p,
-          inversePatches: invP,
-        })
-        opts?.onPatches?.(p, invP)
-      }
-    })
+    onPatchesDisposer = internalOnPatches(
+      subtreeRoot,
+      (p, invP) => {
+        if (recording && filter(p, invP)) {
+          events.push({
+            target: subtreeRoot,
+            patches: p,
+            inversePatches: invP,
+          })
+          opts?.onPatches?.(p, invP)
+        }
+      },
+      true
+    )
   } else {
-    onPatchesDisposer = onGlobalPatches((target, p, invP) => {
+    onPatchesDisposer = internalOnGlobalPatches((target, p, invP) => {
       if (recording && filter(p, invP)) {
         events.push({
           target,
@@ -131,7 +135,7 @@ export function internalPatchRecorder(
         })
         opts?.onPatches?.(p, invP)
       }
-    })
+    }, true)
   }
 
   return {

package/src/redux/connectReduxDevTools.ts

@@ -33,6 +33,7 @@ export interface ConnectReduxDevToolsOptions {
  * @param remotedevConnection The result of a connect method from the remotedev package (usually the result of `remoteDev.connectViaExtension(...)`).
  * @param target Object to use as root.
  * @param [options] Optional options object.
+ * @returns An idempotent disposer that stops logging and unsubscribes from monitor messages.
  */
 export function connectReduxDevTools(
   remotedevPackage: any,
@@ -42,37 +43,35 @@ export function connectReduxDevTools(
 ) {
   assertTweakedObject(target, "target")
 
-  const opts = {
-    logArgsNearName: true,
-    logChildActions: true,
-    ...options,
-  }
+  const { logArgsNearName = true, logChildActions = true } = options ?? {}
 
+  let disposed = false
   let handlingMonitorAction = 0
 
+  let initialState = getSnapshot(target)
+  let lastLoggedSnapshot = initialState
+  remotedevConnection.init(initialState)
+
   // subscribe to change state (if need more than just logging)
-  remotedevConnection.subscribe((message: any) => {
-    if (message.type === "DISPATCH") {
+  const unsubscribe = remotedevConnection.subscribe((message: any) => {
+    if (!disposed && message.type === "DISPATCH") {
       handleMonitorActions(remotedevConnection, target, message)
     }
   })
 
-  const initialState = getSnapshot(target)
-  remotedevConnection.init(initialState)
-
   let currentActionId = 0
   const actionIdSymbol = Symbol("actionId")
 
-  actionTrackingMiddleware(target, {
+  const disposeMiddleware = actionTrackingMiddleware(target, {
     filter(ctx) {
-      return opts.logChildActions || !hasDevToolsTrackedParentContext(ctx)
+      return logChildActions || !hasDevToolsTrackedParentContext(ctx)
     },
     onStart(ctx) {
       ctx.data[actionIdSymbol] = currentActionId++
     },
     onResume(ctx) {
       // give a chance to the parent to log its own changes before the child starts
-      if (opts.logChildActions && ctx.parentContext) {
+      if (logChildActions && ctx.parentContext) {
         log(ctx.parentContext, undefined)
       }
       log(ctx, undefined)
@@ -85,6 +84,13 @@ export function connectReduxDevTools(
     },
   })
 
+  return () => {
+    if (disposed) return
+    disposed = true
+    disposeMiddleware()
+    if (typeof unsubscribe === "function") unsubscribe()
+  }
+
   function handleMonitorActions(remotedev2: any, target2: any, message: any) {
     try {
       handlingMonitorAction++
@@ -96,7 +102,8 @@ export function connectReduxDevTools(
         }
 
         case "COMMIT":
-          return remotedev2.init(getSnapshot(target2))
+          initialState = getSnapshot(target2)
+          return remotedev2.init(initialState)
 
         case "ROLLBACK": {
           const state = remotedevPackage.extractState(message)
@@ -122,13 +129,12 @@ export function connectReduxDevTools(
       }
     } finally {
       handlingMonitorAction--
+      lastLoggedSnapshot = getSnapshot(target2)
     }
   }
 
-  let lastLoggedSnapshot = initialState
-
   function log(ctx: SimpleActionContext, result: ActionTrackingResult | undefined) {
-    if (handlingMonitorAction) {
+    if (disposed || handlingMonitorAction) {
       return
     }
 
@@ -160,7 +166,7 @@ export function connectReduxDevTools(
     const pathStr = "[/" + rootPath.path.join("/") + "] "
     let name = pathStr + ctx.actionName
 
-    if (opts.logArgsNearName) {
+    if (logArgsNearName) {
       let args = ctx.args
         .map((a) => {
           try {

package/src/redux/redux.ts

@@ -83,7 +83,7 @@ export function asReduxStore<T extends object>(
       return getSnapshot(target)
     },
     dispatch(action) {
-      return runMiddlewares(action, runners, defaultDispatch)
+      return dispatch(action)
     },
     subscribe(listener) {
       return onSnapshot(target, listener)
@@ -91,25 +91,9 @@ export function asReduxStore<T extends object>(
   }
 
   const runners = middlewares.map((mw) => mw(store))
-
-  return store
-}
-
-function runMiddlewares<T>(
-  initialAction: ReduxAction,
-  runners: ReadonlyArray<ReduxRunner<T>>,
-  next: ReduxStore<T>["dispatch"]
-): ReduxAction {
-  let i = 0
-
-  function runNextMiddleware(action: ReduxAction): ReduxAction {
-    if (i < runners.length) {
-      const runner = runners[i]
-      i++
-      return runner(runNextMiddleware)(action)
-    }
-    return next(action)
+  let dispatch = defaultDispatch
+  for (let i = runners.length - 1; i >= 0; i--) {
+    dispatch = runners[i](dispatch)
   }
-
-  return runNextMiddleware(initialAction)
+  return store
 }

package/src/ref/core.ts

@@ -88,10 +88,26 @@ export function internalCustomRef<T extends object>(
       trackedRefs.add(this as Ref<object>)
       this.internalForceUpdateBackRefs(initialTarget)
 
+      // MobX 4/5 do not pass the previous value to reaction effects.
+      // The reaction is usually created inside an action, so its first tracking run is deferred
+      // to the end of the batch and `initialTarget` may be stale by then; capture the value of
+      // that first run instead, since that is the one the effect will be compared against.
+      let previousTarget = initialTarget
+      let firstTrackingRun = true
       // according to mwestrate this won't leak as long as we don't keep the disposer around
       reaction(
-        () => this.maybeCurrent,
-        (newTarget, oldTarget) => {
+        () => {
+          const target = this.maybeCurrent
+          if (firstTrackingRun) {
+            firstTrackingRun = false
+            previousTarget = target
+            this.internalForceUpdateBackRefs(target)
+          }
+          return target
+        },
+        (newTarget) => {
+          const oldTarget = previousTarget
+          previousTarget = newTarget
           this.internalForceUpdateBackRefs(newTarget)
 
           if (onResolvedValueChange && newTarget !== oldTarget) {

package/src/rootStore/attachDetach.ts

@@ -4,9 +4,10 @@ import { HookAction } from "../action/hookActions"
 import { wrapInAction, wrapModelMethodInActionIfNeeded } from "../action/wrapInAction"
 import { type AnyModel, BaseModel } from "../model/BaseModel"
 import { WalkTreeMode, walkTree } from "../parent/walkTree"
+import { forEachWithDelayedThrow } from "../utils/forEachWithDelayedThrow"
 
 const onAttachedDisposers = new WeakMap<object, () => void>()
-const attachedToRootStore = new WeakSet<object>()
+const attachedToRootStore = new WeakMap<object, object>()
 
 /**
  * @internal
@@ -16,6 +17,7 @@ export const attachToRootStore = action(
   (rootStore: object, child: object): void => {
     // we use an array to ensure they will get called even if the actual hook modifies the tree
     const childrenToCall: AnyModel[] = []
+    const attachment = {}
 
     walkTree(
       child,
@@ -25,7 +27,7 @@ export const attachToRootStore = action(
         if (attachedToRootStore.has(ch)) {
           return
         }
-        attachedToRootStore.add(ch)
+        attachedToRootStore.set(ch, attachment)
 
         if (ch instanceof BaseModel && (ch as any).onAttachedToRootStore) {
           wrapModelMethodInActionIfNeeded(
@@ -40,15 +42,23 @@ export const attachToRootStore = action(
       WalkTreeMode.ParentFirst
     )
 
-    const childrenToCallLen = childrenToCall.length
-    for (let i = 0; i < childrenToCallLen; i++) {
-      const ch = childrenToCall[i]
+    forEachWithDelayedThrow(childrenToCall, (ch) => {
+      // An earlier hook may have detached or reattached this node already.
+      if (attachedToRootStore.get(ch) !== attachment) {
+        return
+      }
 
       const disposer = (ch as any).onAttachedToRootStore(rootStore)
       if (disposer) {
-        onAttachedDisposers.set(ch, disposer)
+        if (attachedToRootStore.get(ch) === attachment) {
+          onAttachedDisposers.set(ch, disposer)
+        } else {
+          // The hook detached or reattached this node before returning its cleanup.
+          // Dispose this attachment without overwriting a newer attachment's cleanup.
+          wrapDisposer(ch, disposer)()
+        }
       }
-    }
+    })
   }
 )
 
@@ -69,11 +79,7 @@ export const detachFromRootStore = action("detachFromRootStore", (child: object)
       const disposer = onAttachedDisposers.get(ch)
       if (disposer) {
         // wrap disposer in action
-        const disposerAction = wrapInAction({
-          nameOrNameFn: HookAction.OnAttachedToRootStoreDisposer,
-          fn: disposer,
-          actionType: ActionContextActionType.Sync,
-        }).bind(ch)
+        const disposerAction = wrapDisposer(ch, disposer)
         onAttachedDisposers.delete(ch)
 
         disposersToCall.push(disposerAction)
@@ -82,8 +88,13 @@ export const detachFromRootStore = action("detachFromRootStore", (child: object)
     WalkTreeMode.ChildrenFirst
   )
 
-  const disposersToCallLen = disposersToCall.length
-  for (let i = 0; i < disposersToCallLen; i++) {
-    disposersToCall[i]()
-  }
+  forEachWithDelayedThrow(disposersToCall, (dispose) => dispose())
 })
+
+function wrapDisposer(node: object, disposer: () => void): () => void {
+  return wrapInAction({
+    nameOrNameFn: HookAction.OnAttachedToRootStoreDisposer,
+    fn: disposer,
+    actionType: ActionContextActionType.Sync,
+  }).bind(node)
+}

package/src/rootStore/rootStore.ts

@@ -45,9 +45,11 @@ export const registerRootStore: <T extends object>(node: T) => T = action(
 
     entry.is = true
 
-    attachToRootStore(node, node)
-
-    entry.atom?.reportChanged()
+    try {
+      attachToRootStore(node, node)
+    } finally {
+      entry.atom?.reportChanged()
+    }
     return node
   }
 )
@@ -65,9 +67,11 @@ export const unregisterRootStore: (node: object) => void = action("unregisterRoo
   const entry = getOrCreateRootStoreEntry(node)
   entry.is = false
 
-  detachFromRootStore(node)
-
-  entry.atom?.reportChanged()
+  try {
+    detachFromRootStore(node)
+  } finally {
+    entry.atom?.reportChanged()
+  }
 })
 
 /**

package/src/snapshot/SnapshotOf.ts

@@ -69,13 +69,13 @@ export type SnapshotInOfModel<M extends AnyModel> = ModelFromSnapshot<M>
 export interface SnapshotInOfFrozen<F extends Frozen<any>> extends FrozenData<F["data"]> {}
 
 export interface SnapshotInOfObjectMap<V> {
-  items?: { [k: string]: SnapshotOutOf<V> }
+  items?: { [k: string]: SnapshotInOf<V> }
   [modelTypeKey]?: string
   [modelIdKey]: string
 }
 
 export interface SnapshotInOfArraySet<V> {
-  items?: SnapshotOutOf<V>[]
+  items?: SnapshotInOf<V>[]
   [modelTypeKey]?: string
   [modelIdKey]: string
 }

package/src/snapshot/applySnapshot.ts

@@ -129,7 +129,7 @@ export function internalApplySnapshot<T extends object>(
     }
 
     const modelIdPropertyName = getModelIdPropertyName(modelInfo.class as ModelClass<AnyModel>)
-    if (modelIdPropertyName) {
+    if (modelIdPropertyName !== undefined) {
       const id = (sn as any)[modelIdPropertyName]
       if (obj[modelIdKey] !== id) {
         // different id, no reconciliation possible

package/src/snapshot/clone.ts

@@ -24,8 +24,7 @@ export function clone<T extends object>(node: T, options?: Partial<CloneOptions>
   assertTweakedObject(node, "node")
 
   const opts = {
-    generateNewIds: true,
-    ...options,
+    generateNewIds: options?.generateNewIds ?? true,
   }
 
   const sn = getSnapshot(node)

package/src/snapshot/cloneTreeValue.ts

@@ -10,8 +10,7 @@ import { fromSnapshot } from "./fromSnapshot"
  */
 export function cloneTreeValue<T>(value: T, options?: Partial<CloneOptions>): T {
   const cloneOptions: CloneOptions = {
-    generateNewIds: true,
-    ...options,
+    generateNewIds: options?.generateNewIds ?? true,
   }
 
   if (isPrimitive(value)) {