mobx-keystone 1.24.1 → 2.0.0

package/src/treeUtils/deepEquals.ts

@@ -29,21 +29,23 @@ export function deepEquals(a: any, b: any): boolean {
     return true
   }
 
-  // use snapshots to compare if possible
-  // since snapshots use structural sharing it is more likely
-  // to speed up comparisons
-  if (isTreeNode(a)) {
-    a = getSnapshot(a)
-  } else if (isObservable(a)) {
-    a = toJS(a, toJSOptions)
-  }
-  if (isTreeNode(b)) {
-    b = getSnapshot(b)
-  } else if (isObservable(b)) {
-    b = toJS(b, toJSOptions)
+  const aIsObject = a !== null && typeof a === "object"
+  const bIsObject = b !== null && typeof b === "object"
+  if (!aIsObject && !bIsObject) {
+    // Strict equality already handled all equal primitives except NaN.
+    return Number.isNaN(a) && Number.isNaN(b)
   }
 
-  return fastDeepEqual(a, b)
+  return fastDeepEqual(aIsObject ? comparisonValue(a) : a, bIsObject ? comparisonValue(b) : b)
+}
+
+function comparisonValue(value: object): unknown {
+  if (isTreeNode(value)) {
+    // Snapshots preserve structural sharing. Model $ objects are deliberately
+    // handled as observable objects rather than standalone tree nodes.
+    return getSnapshot(value)
+  }
+  return isObservable(value) ? toJS(value, toJSOptions) : value
 }
 
 const toJSOptions =

package/src/treeUtils/draft.ts

@@ -38,6 +38,10 @@ export class Draft<T extends object> {
    */
   @mobxAction
   commitByPath(path: Path): void {
+    if (path.length === 0) {
+      this.commit()
+      return
+    }
     const draftTarget = resolvePath(this.data, path)
     if (!draftTarget.resolved) {
       throw failure(`path ${JSON.stringify(path)} could not be resolved in draft object`)
@@ -76,6 +80,10 @@ export class Draft<T extends object> {
    */
   @mobxAction
   resetByPath(path: Path): void {
+    if (path.length === 0) {
+      this.reset()
+      return
+    }
     const originalTarget = resolvePath(this.originalData, path)
     if (!originalTarget.resolved) {
       throw failure(`path ${JSON.stringify(path)} could not be resolved in original object`)

package/src/treeUtils/sandbox.ts

@@ -7,7 +7,6 @@ import { createContext } from "../context"
 import { getParentToChildPath, resolvePath } from "../parent/path"
 import { applyPatches } from "../patch/applyPatches"
 import { onPatches } from "../patch/emitPatch"
-import type { Patch } from "../patch/Patch"
 import { type PatchRecorder, patchRecorder } from "../patch/patchRecorder"
 import {
   fastIsRootStoreNoAtom,
@@ -78,11 +77,6 @@ export class SandboxManager {
    */
   private allowWrite: ReadonlyMiddlewareReturn["allowWrite"]
 
-  /**
-   * Whether changes made in the sandbox are currently being committed to the original subtree.
-   */
-  private isCommitting = false
-
   private readonly subtreeRoot: object
 
   /**
@@ -127,11 +121,9 @@ export class SandboxManager {
       if (this.withSandboxPatchRecorder) {
         throw failure("original subtree must not change while 'withSandbox' executes")
       }
-      if (!this.isCommitting) {
-        this.allowWrite(() => {
-          applyPatches(this.subtreeRootClone, patches)
-        })
-      }
+      this.allowWrite(() => {
+        applyPatches(this.subtreeRootClone, patches)
+      })
     })
 
     const { allowWrite, dispose: disposeReadonlyMW } = readonlyMiddleware(this.subtreeRootClone)
@@ -232,26 +224,38 @@ export class SandboxManager {
       }
       if (commit) {
         if (!isNestedWithSandboxCall) {
-          const patches: Patch[] = []
-          const len = recorder.events.length
-          for (let i = 0; i < len; i++) {
-            patches.push(...recorder.events[i].patches)
-          }
-
-          const isCommitting = this.isCommitting
-          this.isCommitting = true
-          try {
-            applyPatches(this.subtreeRoot, patches)
-          } finally {
-            this.isCommitting = isCommitting
-          }
+          const events = recorder.events
+          // The clone already holds these changes, so revert them and let the regular
+          // patch sync mirror the original's final state back in. That way anything a
+          // listener changes on the original during the commit reaches the clone too,
+          // at a cost proportional to the changes rather than to the tree size.
+          // Both halves run in a single action so that observers of the sandbox never
+          // see the reverted intermediate state.
+          runInAction(() => {
+            this.allowWrite(() => {
+              for (let i = events.length - 1; i >= 0; i--) {
+                applyPatches(this.subtreeRootClone, events[i].inversePatches, true)
+              }
+            })
+            applyPatches(
+              this.subtreeRoot,
+              events.map((event) => event.patches)
+            )
+          })
         }
       } else {
         this.allowWrite(() => {
           runInAction(() => {
-            let i = recorder.events.length
-            while (i-- > numRecorderEvents) {
-              applyPatches(this.subtreeRootClone, recorder.events[i].inversePatches, true)
+            const wasRecording = recorder.recording
+            recorder.recording = false
+            try {
+              let i = recorder.events.length
+              while (i-- > numRecorderEvents) {
+                applyPatches(this.subtreeRootClone, recorder.events[i].inversePatches, true)
+              }
+              recorder.events.splice(numRecorderEvents)
+            } finally {
+              recorder.recording = wasRecording
             }
           })
         })

package/src/tweaker/core.ts

@@ -28,10 +28,8 @@ export function setTweakedObjectUntweakers(
  * @internal
  */
 export function isTweakedObject(value: unknown, canBeDataObject: boolean): value is object {
-  if (!canBeDataObject && hasDataObjectParent(value as object)) {
-    return false
-  }
-  return treeNodeMetadata.get(value as object)?.tweaked === true
+  const metadata = treeNodeMetadata.get(value as object)
+  return metadata?.tweaked === true && (canBeDataObject || metadata.dataObjectParent === undefined)
 }
 
 /**

package/src/tweaker/tweak.ts

@@ -8,6 +8,7 @@ import { unsetInternalSnapshot } from "../snapshot/internal"
 import type { AnyStandardType, TypeToData } from "../types/schemas"
 import { typeCheck } from "../types/typeCheck"
 import { failure, inDevMode, isMap, isObject, isPrimitive, isSet } from "../utils"
+import { getSafeErrorValuePreview } from "../utils/errorDiagnostics"
 import { isTweakedObject, runTweakedObjectUntweakers } from "./core"
 import { registerDefaultTweakers } from "./registerDefaultTweakers"
 import { treeNodeMetadata } from "./treeNodeMetadata"
@@ -86,16 +87,11 @@ export function registerTweaker<T>(priority: number, tweaker: Tweaker<T>): void
 }
 
 function internalTweak<T>(value: T, parentPath: ParentPath<any> | undefined): T {
-  if (isPrimitive(value)) {
-    return value
-  }
-
   // already tweaked
   if (isTweakedObject(value, true)) {
     value = setParent(
       value,
       parentPath,
-      false, // indexChangeAllowed
       false, // isDataObject
       true // cloneIfApplicable
     )
@@ -131,14 +127,19 @@ function internalTweak<T>(value: T, parentPath: ParentPath<any> | undefined): T
   }
 
   throw failure(
-    `tweak can only work over models, observable objects/arrays, or primitives, but got ${value} instead`
+    `tweak can only work over models, observable objects/arrays, or primitives, but got ${getSafeErrorValuePreview(value)} instead`
   )
 }
 
+const tweakNonPrimitive = action("tweak", internalTweak)
+
 /**
  * @internal
  */
-export const tweak = action("tweak", internalTweak)
+export function tweak<T>(value: T, parentPath: ParentPath<any> | undefined): T {
+  // Primitives need no tree bookkeeping or MobX action boundary.
+  return isPrimitive(value) ? value : tweakNonPrimitive(value, parentPath)
+}
 
 /**
  * @internal
@@ -169,7 +170,6 @@ export function tryUntweak(value: any): (() => void) | undefined {
     setParent(
       children[i], // value
       undefined, // parentPath
-      false, // indexChangeAllowed
       false, // isDataObject
       // no need to clone if unsetting the parent
       false // cloneIfApplicable

package/src/tweaker/tweakArray.ts

@@ -12,8 +12,14 @@ import { assertCanWrite } from "../action/protection"
 import { emitArraySpliceDeepChange, emitArrayUpdateDeepChange } from "../deepChange/onDeepChange"
 import { getGlobalConfig } from "../globalConfig"
 import type { ParentPath } from "../parent/path"
-import { setParent } from "../parent/setParent"
-import { hasPatchListenersFor, InternalPatchRecorder } from "../patch/emitPatch"
+import { reindexArrayChildren, setParent } from "../parent/setParent"
+import {
+  beginPatchEmission,
+  emitPatches,
+  endPatchEmission,
+  hasPatchListenersFor,
+  InternalPatchRecorder,
+} from "../patch/emitPatch"
 import type { Patch } from "../patch/Patch"
 import {
   flushInternalSnapshot,
@@ -23,11 +29,20 @@ import {
   updateInternalSnapshot,
 } from "../snapshot/internal"
 import { failure, inDevMode, isArray, isPrimitive } from "../utils"
+import {
+  addDelayedError,
+  type DelayedError,
+  throwDelayedError,
+} from "../utils/forEachWithDelayedThrow"
 import { runningWithoutSnapshotOrPatches, setTweakedObjectUntweakers } from "./core"
 import { TweakerPriority } from "./TweakerPriority"
 import { markAsTweakedObject } from "./treeNodeMetadata"
 import { registerTweaker, tweak } from "./tweak"
-import { isTypeCheckingAfterChangeEnabled, runTypeCheckingAfterChange } from "./typeChecking"
+import {
+  isTypeCheckingAfterChangeEnabled,
+  recordTypeCheckingBatchChange,
+  runTypeCheckingAfterChange,
+} from "./typeChecking"
 
 /**
  * @internal
@@ -62,7 +77,6 @@ export function tweakArray<T extends any[]>(
   setParent(
     tweakedArr, // value
     parentPath,
-    false, // indexChangeAllowed
     false, // isDataObject
     // arrays shouldn't be cloned anyway
     false // cloneIfApplicable
@@ -97,7 +111,6 @@ export function tweakArray<T extends any[]>(
         setParent(
           tweakedValue, // value
           path, // parentPath
-          false, // indexChangeAllowed
           false, // isDataObject
           // the value is already a new value (the result of a fromSnapshot)
           false // cloneIfApplicable
@@ -140,8 +153,23 @@ function mutateSet(k: number, v: unknown, sn: unknown[]) {
   sn[k] = v
 }
 
+// Conservative bound below every engine's argument-count limit for spread calls.
+const maxSpreadableItems = 8192
+
 function mutateSplice(index: number, removedCount: number, addedItems: any[], sn: any[]) {
-  sn.splice(index, removedCount, ...addedItems)
+  if (addedItems.length < maxSpreadableItems) {
+    sn.splice(index, removedCount, ...addedItems)
+    return
+  }
+
+  // Splice the tail in a single pass instead of spreading the added items as
+  // arguments, which would overflow the engine's limit. copyWithin handles overlap.
+  const oldLength = sn.length
+  const newLength = oldLength - removedCount + addedItems.length
+  if (newLength > oldLength) sn.length = newLength
+  sn.copyWithin(index + addedItems.length, index + removedCount, oldLength)
+  for (let i = 0; i < addedItems.length; i++) sn[index + i] = addedItems[i]
+  sn.length = newLength
 }
 
 const patchRecorder = new InternalPatchRecorder()
@@ -151,24 +179,12 @@ function arrayDidChange(change: IArrayDidChange) {
 
   patchRecorder.reset()
 
-  switch (change.type) {
-    case "splice":
-      emitArraySpliceDeepChange(arr, arr, change.index as number, change.added, change.removed)
-      break
-
-    case "update":
-      emitArrayUpdateDeepChange(arr, arr, change.index as number, change.newValue, change.oldValue)
-
-      break
-
-    default:
-      break
-  }
-
   if (runningWithoutSnapshotOrPatches) {
     return
   }
 
+  recordTypeCheckingBatchChange(change)
+
   const oldSnapshot = getInternalSnapshot(arr as Array<unknown>)!.untransformed
   const shouldEmitPatches = hasPatchListenersFor(arr)
   const shouldBuildInversePatches = shouldEmitPatches || isTypeCheckingAfterChangeEnabled()
@@ -198,8 +214,53 @@ function arrayDidChange(change: IArrayDidChange) {
   runTypeCheckingAfterChange(arr, patchRecorder)
   if (mutate) {
     updateInternalSnapshot(arr, mutate)
-    patchRecorder.emit(arr)
   }
+  // Listeners may mutate another node and reuse the shared recorder.
+  // Keep this change's patches before publishing the validated deep change.
+  const { patches, invPatches } = patchRecorder
+  patchRecorder.reset()
+
+  // Reserve chronological patch notifications, then finish deep-change delivery
+  // before publishing them. Reentrant edits append behind this mutation.
+  // Every step below runs even when an earlier one throws, so a failing patch recorder
+  // cannot keep the mutation from reaching the deep change and public patch listeners,
+  // and no failure is lost to a later one.
+  beginPatchEmission()
+  let delayedError: DelayedError
+  try {
+    emitPatches(arr, patches, invPatches)
+  } catch (error) {
+    delayedError = addDelayedError(delayedError, error)
+  }
+  try {
+    switch (change.type) {
+      case "splice":
+        emitArraySpliceDeepChange(arr, arr, change.index as number, change.added, change.removed)
+        break
+
+      case "update":
+        emitArrayUpdateDeepChange(
+          arr,
+          arr,
+          change.index as number,
+          change.newValue,
+          change.oldValue
+        )
+
+        break
+
+      default:
+        break
+    }
+  } catch (error) {
+    delayedError = addDelayedError(delayedError, error)
+  }
+  try {
+    endPatchEmission()
+  } catch (error) {
+    delayedError = addDelayedError(delayedError, error)
+  }
+  throwDelayedError(delayedError)
 }
 
 const undefinedInsideArrayErrorMsg =
@@ -319,10 +380,10 @@ function arrayDidChangeSplice(
     }
 
     if (patches && readdPatches && readdPatches.length > 0) {
-      patches.push(...readdPatches)
+      for (const patch of readdPatches) patches.push(patch)
     }
     if (invPatches && readdInvPatches && readdInvPatches.length > 0) {
-      invPatches.push(...readdInvPatches)
+      for (const patch of readdInvPatches) invPatches.push(patch)
     }
     // We need to reverse once since inverse patches are applied in reverse.
     // Repeated unshift calls here would make a large splice quadratic.
@@ -482,20 +543,8 @@ function interceptArrayMutationSplice(change: IArrayWillSplice) {
   const oldNextIndex = change.index + change.removedCount
   const newNextIndex = change.index + change.added.length
 
-  if (oldNextIndex !== newNextIndex) {
-    for (let i = oldNextIndex, j = newNextIndex; i < change.object.length; i++, j++) {
-      setParent(
-        change.object[i], // value
-        {
-          parent: change.object,
-          path: j,
-        }, // parentPath
-        true, // indexChangeAllowed
-        false, // isDataObject
-        // just re-indexing
-        false // cloneIfApplicable
-      )
-    }
+  if (oldNextIndex !== newNextIndex && oldNextIndex < change.object.length) {
+    reindexArrayChildren(change.object, oldNextIndex, newNextIndex)
   }
 }
 

package/src/tweaker/tweakFrozen.ts

@@ -17,7 +17,6 @@ export function tweakFrozen<T extends Frozen<any>>(
   setParent(
     frozenObj, // value
     parentPath,
-    false, // indexChangeAllowed
     false, // isDataObject
     // a frozen is not a value-type
     false // cloneIfApplicable

package/src/tweaker/tweakModel.ts

@@ -13,7 +13,6 @@ export function tweakModel<T extends object>(value: T, parentPath: ParentPath<an
   setParent(
     value,
     parentPath,
-    false, // indexChangeAllowed
     false, // isDataObject
     true // cloneIfApplicable
   )

package/src/tweaker/tweakPlainObject.ts

@@ -19,7 +19,13 @@ import { getModelInfoForName, getModelNotRegisteredErrorMessage } from "../model
 import { dataToModelNode } from "../parent/core"
 import type { ParentPath } from "../parent/path"
 import { setParent } from "../parent/setParent"
-import { hasPatchListenersFor, InternalPatchRecorder } from "../patch/emitPatch"
+import {
+  beginPatchEmission,
+  emitPatches,
+  endPatchEmission,
+  hasPatchListenersFor,
+  InternalPatchRecorder,
+} from "../patch/emitPatch"
 import {
   flushInternalSnapshot,
   freezeInternalSnapshot,
@@ -29,13 +35,23 @@ import {
   updateInternalSnapshot,
 } from "../snapshot/internal"
 import { takeModelInitialDataSnapshot } from "../snapshot/modelInitialData"
+import { withoutCachedTypeChecking } from "../types/createCachedTypeCheck"
 import { failure, isPlainObject, isPrimitive, setProtoProp } from "../utils"
+import {
+  addDelayedError,
+  type DelayedError,
+  throwDelayedError,
+} from "../utils/forEachWithDelayedThrow"
 import { setIfDifferent } from "../utils/setIfDifferent"
 import { runningWithoutSnapshotOrPatches, setTweakedObjectUntweakers } from "./core"
 import { TweakerPriority } from "./TweakerPriority"
 import { markAsTweakedObject } from "./treeNodeMetadata"
 import { registerTweaker, tweak } from "./tweak"
-import { isTypeCheckingAfterChangeEnabled, runTypeCheckingAfterChange } from "./typeChecking"
+import {
+  isTypeCheckingAfterChangeEnabled,
+  recordTypeCheckingBatchChange,
+  runTypeCheckingAfterChange,
+} from "./typeChecking"
 
 /**
  * @internal
@@ -59,20 +75,19 @@ export function tweakPlainObject<T extends Record<string, any>>(
   setParent(
     tweakedObj, // value
     parentPath,
-    false, // indexChangeAllowed
     isDataObject,
     // an object shouldn't be cloned
     false // cloneIfApplicable
   )
 
   const initialDataSnapshot =
-    isDataObject && snapshotModelType ? takeModelInitialDataSnapshot(tweakedObj) : undefined
-  const reuseInitialDataSnapshot =
-    !!initialDataSnapshot?.reusable && initialDataSnapshot.allValuesPrimitive
-  const untransformedSn: any = reuseInitialDataSnapshot ? initialDataSnapshot.snapshot : {}
+    isDataObject && snapshotModelType !== undefined
+      ? takeModelInitialDataSnapshot(tweakedObj)
+      : undefined
+  const untransformedSn: any = initialDataSnapshot ?? {}
 
   // substitute initial values by tweaked values
-  const originalObjKeys = reuseInitialDataSnapshot ? [] : Object.keys(originalObj)
+  const originalObjKeys = initialDataSnapshot ? [] : Object.keys(originalObj)
   const originalObjKeysLen = originalObjKeys.length
   for (let i = 0; i < originalObjKeysLen; i++) {
     const k = originalObjKeys[i]
@@ -96,7 +111,6 @@ export function tweakPlainObject<T extends Record<string, any>>(
         setParent(
           tweakedValue, // value
           path, // parentPath
-          false, // indexChangeAllowed
           false, // isDataObject
           // the value is already a new value (the result of a fromSnapshot)
           false // cloneIfApplicable
@@ -116,7 +130,7 @@ export function tweakPlainObject<T extends Record<string, any>>(
   }
 
   let transformFn: SnapshotTransformFn | undefined
-  if (snapshotModelType) {
+  if (snapshotModelType !== undefined) {
     untransformedSn[modelTypeKey] = snapshotModelType
 
     const modelInfo = getModelInfoForName(snapshotModelType)
@@ -171,27 +185,12 @@ function objectDidChange(change: IObjectDidChange): void {
 
   patchRecorder.reset()
 
-  switch (change.type) {
-    case "add":
-      emitObjectAddDeepChange(actualNode, obj, change.name, change.newValue)
-      break
-
-    case "update":
-      emitObjectUpdateDeepChange(actualNode, obj, change.name, change.newValue, change.oldValue)
-      break
-
-    case "remove":
-      emitObjectRemoveDeepChange(actualNode, obj, change.name, change.oldValue)
-      break
-
-    default:
-      throw failure("assertion error: unsupported object change type")
-  }
-
   if (runningWithoutSnapshotOrPatches) {
     return
   }
 
+  recordTypeCheckingBatchChange(change)
+
   const oldUntransformedSn = getInternalSnapshot(actualNode)!.untransformed
   const shouldEmitPatches = hasPatchListenersFor(actualNode)
   const shouldBuildInversePatches = shouldEmitPatches || isTypeCheckingAfterChangeEnabled()
@@ -219,9 +218,59 @@ function objectDidChange(change: IObjectDidChange): void {
       throw failure("assertion error: unsupported object change type")
   }
 
-  runTypeCheckingAfterChange(obj, patchRecorder)
+  if (change.type !== "update" && isTypeCheckingAfterChangeEnabled()) {
+    // MobX notifies object observers before invalidating dependencies on missing
+    // keys (and removed keys in MobX 4). Cached ancestor checks may still
+    // describe the previous shape.
+    withoutCachedTypeChecking(obj, () => runTypeCheckingAfterChange(obj, patchRecorder))
+  } else {
+    runTypeCheckingAfterChange(obj, patchRecorder)
+  }
   updateInternalSnapshot(actualNode, mutate)
-  patchRecorder.emit(actualNode)
+
+  // Listeners may mutate another node and reuse the shared recorder.
+  // Keep this change's patches before publishing the validated deep change.
+  const { patches, invPatches } = patchRecorder
+  patchRecorder.reset()
+
+  // Reserve chronological patch notifications, then finish deep-change delivery
+  // before publishing them. Reentrant edits append behind this mutation.
+  // Every step below runs even when an earlier one throws, so a failing patch recorder
+  // cannot keep the mutation from reaching the deep change and public patch listeners,
+  // and no failure is lost to a later one.
+  beginPatchEmission()
+  let delayedError: DelayedError
+  try {
+    emitPatches(actualNode, patches, invPatches)
+  } catch (error) {
+    delayedError = addDelayedError(delayedError, error)
+  }
+  try {
+    switch (change.type) {
+      case "add":
+        emitObjectAddDeepChange(actualNode, obj, change.name, change.newValue)
+        break
+
+      case "update":
+        emitObjectUpdateDeepChange(actualNode, obj, change.name, change.newValue, change.oldValue)
+        break
+
+      case "remove":
+        emitObjectRemoveDeepChange(actualNode, obj, change.name, change.oldValue)
+        break
+
+      default:
+        throw failure("assertion error: unsupported object change type")
+    }
+  } catch (error) {
+    delayedError = addDelayedError(delayedError, error)
+  }
+  try {
+    endPatchEmission()
+  } catch (error) {
+    delayedError = addDelayedError(delayedError, error)
+  }
+  throwDelayedError(delayedError)
 }
 
 function objectDidChangeRemove(