mobx-keystone 1.25.0 → 2.1.0

package/src/tweaker/tweakArray.ts

@@ -11,10 +11,20 @@ import {
 import { assertCanWrite } from "../action/protection"
 import { emitArraySpliceDeepChange, emitArrayUpdateDeepChange } from "../deepChange/onDeepChange"
 import { getGlobalConfig } from "../globalConfig"
-import type { ParentPath } from "../parent/path"
+import { getModelMetadata } from "../model/getModelMetadata"
+import { isModel } from "../model/utils"
+import { getArrayPaths, setLazyArrayParentPath } from "../parent/arrayPaths"
+import { fastGetParentPath, type ParentPath } from "../parent/path"
 import { reindexArrayChildren, setParent } from "../parent/setParent"
-import { hasPatchListenersFor, InternalPatchRecorder } from "../patch/emitPatch"
+import {
+  beginPatchEmission,
+  emitPatches,
+  endPatchEmission,
+  hasPatchListenersFor,
+  InternalPatchRecorder,
+} from "../patch/emitPatch"
 import type { Patch } from "../patch/Patch"
+import { clone } from "../snapshot/clone"
 import {
   flushInternalSnapshot,
   freezeInternalSnapshot,
@@ -23,10 +33,19 @@ import {
   updateInternalSnapshot,
 } from "../snapshot/internal"
 import { failure, inDevMode, isArray, isPrimitive } from "../utils"
-import { runningWithoutSnapshotOrPatches, setTweakedObjectUntweakers } from "./core"
+import { addDelayedError, type DelayedError } from "../utils/forEachWithDelayedThrow"
+import { recordChangeForRollback, throwDelayedListenerError } from "./changeRollback"
+import { activateHandlers, areHandlersActive, runningWithoutSnapshotOrPatches } from "./core"
 import { TweakerPriority } from "./TweakerPriority"
 import { markAsTweakedObject } from "./treeNodeMetadata"
-import { registerTweaker, tweak } from "./tweak"
+import {
+  assertCanAttach,
+  assertCanAttachValue,
+  type IsDetachedByChange,
+  registerTweaker,
+  tweak,
+} from "./tweak"
+import { notifyTweakedChangeListeners } from "./tweakedChangeListeners"
 import { isTypeCheckingAfterChangeEnabled, runTypeCheckingAfterChange } from "./typeChecking"
 
 /**
@@ -124,45 +143,57 @@ export function tweakArray<T extends any[]>(
   }
   setNewInternalSnapshot(tweakedArr, untransformedSn, undefined)
 
-  const interceptDisposer = intercept(
-    tweakedArr,
-    interceptArrayMutation.bind(undefined, tweakedArr)
-  )
-  const observeDisposer = observe(tweakedArr, arrayDidChange)
-  setTweakedObjectUntweakers(tweakedArr, interceptDisposer, observeDisposer)
+  if (activateHandlers(tweakedArr)) {
+    intercept(tweakedArr, interceptArrayMutation.bind(undefined, tweakedArr))
+    observe(tweakedArr, arrayDidChange)
+  }
 
   return tweakedArr as any
 }
 
-function mutateSet(k: number, v: unknown, sn: unknown[]) {
+function mutateSet(k: number, v: unknown, sn: unknown[]): readonly unknown[] {
   sn[k] = v
+  return [v]
 }
 
-function mutateSplice(index: number, removedCount: number, addedItems: any[], sn: any[]) {
-  sn.splice(index, removedCount, ...addedItems)
+// 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[]
+): readonly unknown[] {
+  if (addedItems.length < maxSpreadableItems) {
+    sn.splice(index, removedCount, ...addedItems)
+    return addedItems
+  }
+
+  // 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
+  return addedItems
 }
 
 const patchRecorder = new InternalPatchRecorder()
 
 function arrayDidChange(change: IArrayDidChange) {
+  if (!areHandlersActive(change.object)) {
+    // idle handler of an untweaked array
+    return
+  }
+  notifyTweakedChangeListeners(change)
+
   const arr = change.object
 
   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
   }
@@ -171,7 +202,7 @@ function arrayDidChange(change: IArrayDidChange) {
   const shouldEmitPatches = hasPatchListenersFor(arr)
   const shouldBuildInversePatches = shouldEmitPatches || isTypeCheckingAfterChangeEnabled()
 
-  let mutate: ((sn: any[]) => void) | undefined
+  let mutate: ((sn: any[]) => readonly unknown[]) | undefined
   switch (change.type) {
     case "splice":
       mutate = arrayDidChangeSplice(
@@ -194,10 +225,57 @@ function arrayDidChange(change: IArrayDidChange) {
   }
 
   runTypeCheckingAfterChange(arr, patchRecorder)
+  // (after type checking, which undoes a rejected change, but before listeners)
+  recordChangeForRollback(change)
   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)
+  }
+  throwDelayedListenerError(delayedError)
 }
 
 const undefinedInsideArrayErrorMsg =
@@ -317,10 +395,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.
@@ -410,6 +488,10 @@ function interceptArrayMutation(
   array: IObservableArray,
   change: IArrayWillChange | IArrayWillSplice
 ) {
+  if (!areHandlersActive(array)) {
+    // idle handler of an untweaked array
+    return change
+  }
   assertCanWrite()
 
   switch (change.type) {
@@ -446,9 +528,18 @@ function validateArrayMutationUpdate(change: IArrayWillChange) {
 function interceptArrayMutationUpdate(change: IArrayWillChange, array: IObservableArray) {
   // TODO: should be change.object, but mobx is bugged and doesn't send the proxy
   const oldVal = array[change.index]
+  if (change.newValue === oldVal) {
+    return
+  }
+  assertCanAttachValue(change.newValue, (node) => node === oldVal)
   tweak(oldVal, undefined) // set old prop obj parent to undefined
 
-  change.newValue = tweak(change.newValue, { parent: array, path: change.index })
+  const paths = getArrayPaths(array, 0)
+  const entry = paths?.set(change.index, change.newValue)
+  change.newValue = tweak(change.newValue, entry ?? { parent: array, path: change.index })
+  if (entry) {
+    setLazyArrayParentPath(entry, change.newValue)
+  }
 }
 
 function validateArrayMutationSplice(change: IArrayWillSplice) {
@@ -463,12 +554,65 @@ function validateArrayMutationSplice(change: IArrayWillSplice) {
   }
 }
 
+/**
+ * Checks the added items can be attached before the splice detaches anything,
+ * so a rejected splice leaves every item as it was. Value types that are added
+ * to the array at the index they already have get cloned here, since
+ * `setParent` cannot tell they are being added again (it clones them when they
+ * are added anywhere else).
+ */
+function checkAddedItems(change: IArrayWillSplice) {
+  const array = change.object
+  const added = change.added
+  const removedEnd = change.index + change.removedCount
+  const isDetachedByChange: IsDetachedByChange = (_node, parentPath) =>
+    parentPath.parent === array &&
+    (parentPath.path as number) >= change.index &&
+    (parentPath.path as number) < removedEnd
+
+  assertCanAttach(added, isDetachedByChange, (value) => {
+    if (!isPrimitive(value) && isModel(value) && getModelMetadata(value).valueType) {
+      const parentPath = fastGetParentPath(value, false)
+      if (parentPath?.parent === array && !isDetachedByChange(value, parentPath)) {
+        return clone(value, { generateNewIds: true })
+      }
+    }
+    return value
+  })
+}
+
 function interceptArrayMutationSplice(change: IArrayWillSplice) {
+  checkAddedItems(change)
+
+  const array = change.object
+  const oldNextIndex = change.index + change.removedCount
+  const paths =
+    change.removedCount !== change.added.length
+      ? getArrayPaths(array, array.length - oldNextIndex)
+      : getArrayPaths(array, 0)
+
   for (let i = 0; i < change.removedCount; i++) {
     const removedValue = change.object[change.index + i]
     tweak(removedValue, undefined)
   }
 
+  if (paths) {
+    const addedPaths = paths.createPaths(change.index, change.added)
+    for (let i = 0; i < change.added.length; i++) {
+      const addedPath = addedPaths[i]
+      change.added[i] = tweak(
+        change.added[i],
+        addedPath ?? { parent: array, path: change.index + i }
+      )
+      if (addedPath) {
+        setLazyArrayParentPath(addedPath, change.added[i])
+      }
+    }
+    // no reindexing: the items after the splice follow their chunks
+    paths.applySplice(change.index, change.removedCount, addedPaths)
+    return
+  }
+
   for (let i = 0; i < change.added.length; i++) {
     change.added[i] = tweak(change.added[i], {
       parent: change.object,
@@ -477,7 +621,6 @@ function interceptArrayMutationSplice(change: IArrayWillSplice) {
   }
 
   // we might also need to update the parent of the next indexes
-  const oldNextIndex = change.index + change.removedCount
   const newNextIndex = change.index + change.added.length
 
   if (oldNextIndex !== newNextIndex && oldNextIndex < change.object.length) {

package/src/tweaker/tweakPlainObject.ts

@@ -13,13 +13,21 @@ import {
   emitObjectUpdateDeepChange,
 } from "../deepChange/onDeepChange"
 import type { AnyModel } from "../model/BaseModel"
+import { getModelIdPropertyName } from "../model/getModelMetadata"
 import { modelTypeKey } from "../model/metadata"
 import type { ModelClass } from "../modelShared/BaseModelShared"
 import { getModelInfoForName, getModelNotRegisteredErrorMessage } from "../modelShared/modelInfo"
 import { dataToModelNode } from "../parent/core"
+import { onModelIdChanged } from "../parent/coreObjectChildren"
 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,12 +37,16 @@ import {
   updateInternalSnapshot,
 } from "../snapshot/internal"
 import { takeModelInitialDataSnapshot } from "../snapshot/modelInitialData"
-import { failure, isPlainObject, isPrimitive, setProtoProp } from "../utils"
+import { withoutCachedTypeChecking } from "../types/createCachedTypeCheck"
+import { failure, isPlainObject, isPrimitive, nodeObservableOptions, setProtoProp } from "../utils"
+import { addDelayedError, type DelayedError } from "../utils/forEachWithDelayedThrow"
 import { setIfDifferent } from "../utils/setIfDifferent"
-import { runningWithoutSnapshotOrPatches, setTweakedObjectUntweakers } from "./core"
+import { recordChangeForRollback, throwDelayedListenerError } from "./changeRollback"
+import { activateHandlers, runningWithoutSnapshotOrPatches } from "./core"
 import { TweakerPriority } from "./TweakerPriority"
-import { markAsTweakedObject } from "./treeNodeMetadata"
-import { registerTweaker, tweak } from "./tweak"
+import { markAsTweakedObject, treeNodeMetadata } from "./treeNodeMetadata"
+import { assertCanAttachValue, registerTweaker, tweak } from "./tweak"
+import { notifyTweakedChangeListeners } from "./tweakedChangeListeners"
 import { isTypeCheckingAfterChangeEnabled, runTypeCheckingAfterChange } from "./typeChecking"
 
 /**
@@ -51,7 +63,7 @@ export function tweakPlainObject<T extends Record<string, any>>(
   const originalIsObservableObject = isObservableObject(originalObj)
   const tweakedObj = originalIsObservableObject
     ? originalObj
-    : observable.object({}, undefined, observableOptions)
+    : observable.object({}, undefined, nodeObservableOptions)
 
   // Mark it as tweaked before processing children. The cleanup functions are
   // installed after the MobX handlers have been registered.
@@ -65,7 +77,9 @@ export function tweakPlainObject<T extends Record<string, any>>(
   )
 
   const initialDataSnapshot =
-    isDataObject && snapshotModelType ? takeModelInitialDataSnapshot(tweakedObj) : undefined
+    isDataObject && snapshotModelType !== undefined
+      ? takeModelInitialDataSnapshot(tweakedObj)
+      : undefined
   const untransformedSn: any = initialDataSnapshot ?? {}
 
   // substitute initial values by tweaked values
@@ -112,7 +126,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)
@@ -132,58 +146,60 @@ export function tweakPlainObject<T extends Record<string, any>>(
     transformFn
   )
 
-  const interceptDisposer = intercept(tweakedObj, interceptObjectMutation)
-  const observeDisposer = observe(tweakedObj, objectDidChange)
-  setTweakedObjectUntweakers(tweakedObj, interceptDisposer, observeDisposer)
+  if (activateHandlers(tweakedObj)) {
+    intercept(tweakedObj, interceptObjectMutation)
+    observe(tweakedObj, objectDidChange)
+  }
 
   return tweakedObj as any
 }
 
-const observableOptions = {
-  deep: false,
-}
-
-function mutateSet(k: PropertyKey, v: unknown, sn: Record<PropertyKey, unknown>) {
+function mutateSet(
+  k: PropertyKey,
+  v: unknown,
+  sn: Record<PropertyKey, unknown>
+): readonly unknown[] {
   if (k === "__proto__") {
     setProtoProp(sn, v)
   } else {
     sn[k] = v
   }
+  return [v]
 }
 
-function mutateDelete(k: PropertyKey, sn: Record<PropertyKey, unknown>) {
+const noValues: readonly unknown[] = []
+
+function mutateDelete(k: PropertyKey, sn: Record<PropertyKey, unknown>): readonly unknown[] {
   delete sn[k]
+  return noValues
 }
 
 const patchRecorder = new InternalPatchRecorder()
 
 function objectDidChange(change: IObjectDidChange): void {
+  const obj = change.object
+  const metadata = treeNodeMetadata.get(obj)
+  if (!metadata?.handlersActive) {
+    // idle handler of an untweaked object
+    return
+  }
   if (typeof change.name !== "string") {
     throw failure("change.name is not a string")
   }
 
-  const obj = change.object
-  const actualNode = dataToModelNode(obj)
-
-  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
+  notifyTweakedChangeListeners(change)
 
-    case "remove":
-      emitObjectRemoveDeepChange(actualNode, obj, change.name, change.oldValue)
-      break
+  const actualNode = metadata.dataObjectParent ?? obj
 
-    default:
-      throw failure("assertion error: unsupported object change type")
+  if (
+    actualNode !== obj &&
+    change.name === getModelIdPropertyName(actualNode.constructor as ModelClass<AnyModel>)
+  ) {
+    onModelIdChanged(actualNode)
   }
 
+  patchRecorder.reset()
+
   if (runningWithoutSnapshotOrPatches) {
     return
   }
@@ -192,7 +208,7 @@ function objectDidChange(change: IObjectDidChange): void {
   const shouldEmitPatches = hasPatchListenersFor(actualNode)
   const shouldBuildInversePatches = shouldEmitPatches || isTypeCheckingAfterChangeEnabled()
 
-  let mutate: ((sn: any) => void) | undefined
+  let mutate: ((sn: any) => readonly unknown[]) | undefined
   switch (change.type) {
     case "add":
     case "update":
@@ -215,9 +231,61 @@ 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)
+  }
+  // (after type checking, which undoes a rejected change, but before listeners)
+  recordChangeForRollback(change)
   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)
+  }
+  throwDelayedListenerError(delayedError)
 }
 
 function objectDidChangeRemove(
@@ -284,7 +352,14 @@ function objectDidChangeAddOrUpdate(
   return mutate
 }
 
+const noneDetached = () => false
+
 function interceptObjectMutation(change: IObjectWillChange) {
+  const metadata = treeNodeMetadata.get(change.object)
+  if (!metadata?.handlersActive) {
+    // idle handler of an untweaked object
+    return change
+  }
   assertCanWrite()
 
   if (typeof change.name === "symbol") {
@@ -294,10 +369,11 @@ function interceptObjectMutation(change: IObjectWillChange) {
   // This must happen before detach/reparent work below. It keeps the old value
   // available for inverse patches and folds a departing dirty child into its
   // parent snapshot while its parent path still exists.
-  flushInternalSnapshot(dataToModelNode(change.object), false)
+  flushInternalSnapshot(metadata.dataObjectParent ?? change.object, false)
 
   switch (change.type) {
     case "add":
+      assertCanAttachValue(change.newValue, noneDetached)
       change.newValue = tweak(change.newValue, {
         parent: change.object,
         path: String(change.name),
@@ -313,6 +389,8 @@ function interceptObjectMutation(change: IObjectWillChange) {
       const oldVal = change.object[change.name]
       const newVal = change.newValue
       if (newVal !== oldVal) {
+        // (first, so a value that cannot be attached leaves the old one in place)
+        assertCanAttachValue(newVal, (node) => node === oldVal)
         tweak(oldVal, undefined)
 
         change.newValue = tweak(newVal, {

package/src/tweaker/tweakedChangeListeners.ts

@@ -0,0 +1,61 @@
+import type { IArrayDidChange, IObjectDidChange } from "mobx"
+
+type TweakedChange = IArrayDidChange | IObjectDidChange
+
+/**
+ * @internal
+ */
+export interface TweakedChangeListener<C extends TweakedChange> {
+  applyChange(change: C): void
+  /**
+   * Called when the target is tweaked again after being untweaked, since the
+   * changes made in between were not received.
+   */
+  resync(): void
+}
+
+const changeListeners = new WeakMap<object, TweakedChangeListener<any>[]>()
+
+/**
+ * Listens to the changes of a tweaked array or plain object, in order, before
+ * anything else reacts to them (including the type checks after the change).
+ * Unlike `observe`, changes made while reacting to a change (such as a
+ * type-check rollback) are received after it.
+ *
+ * @internal
+ */
+export function addTweakedChangeListener<T extends object>(
+  target: T,
+  listener: TweakedChangeListener<T extends readonly unknown[] ? IArrayDidChange : IObjectDidChange>
+): void {
+  let listeners = changeListeners.get(target)
+  if (!listeners) {
+    listeners = []
+    changeListeners.set(target, listeners)
+  }
+  listeners.push(listener)
+}
+
+/**
+ * @internal
+ */
+export function notifyTweakedChangeListeners(change: TweakedChange): void {
+  const listeners = changeListeners.get(change.object)
+  if (listeners) {
+    for (const listener of listeners) {
+      listener.applyChange(change)
+    }
+  }
+}
+
+/**
+ * @internal
+ */
+export function resyncTweakedChangeListeners(target: object): void {
+  const listeners = changeListeners.get(target)
+  if (listeners) {
+    for (const listener of listeners) {
+      listener.resync()
+    }
+  }
+}