mobx-keystone 1.25.0 → 2.0.0

package/src/modelShared/modelInfo.ts

@@ -15,7 +15,7 @@ export interface ModelInfo {
  */
 export const modelInfoByName: {
   [name: string]: ModelInfo
-} = {}
+} = Object.create(null)
 
 /**
  * @internal

package/src/modelShared/prop.ts

@@ -1,6 +1,6 @@
 import type { SnapshotInOf, SnapshotOutOf } from "../snapshot/SnapshotOf"
 import type { AnyStandardType } from "../types/schemas"
-import { lazy } from "../utils"
+import { isEqualOrBothNaN, lazy } from "../utils"
 import { runWithErrorDiagnosticsContext, withErrorPathSegment } from "../utils/errorDiagnostics"
 import { getOrCreate } from "../utils/mapUtils"
 import type { Flatten, IsNeverType, IsOptionalValue } from "../utils/types"
@@ -618,11 +618,6 @@ function parseSetterConfig(
 
 const propCache = new Map<unknown, AnyModelProp>()
 
-let cacheTransformResult = false
-const cacheTransformedValueFn = () => {
-  cacheTransformResult = true
-}
-
 /** @internal */
 export function toFullModelPropTransform(
   transformObject: ModelPropTransform<unknown, unknown>
@@ -651,7 +646,7 @@ export function toFullModelPropTransform(
       const modelCache = getOrCreate(cache, model, () => new Map())
 
       let propCache = modelCache.get(propName)
-      if (propCache?.originalValue !== originalValue) {
+      if (!propCache || !isEqualOrBothNaN(propCache.originalValue, originalValue)) {
         // original changed, invalidate cache
         modelCache.delete(propName)
         propCache = undefined
@@ -674,10 +669,12 @@ export function toFullModelPropTransform(
     untransform(transformedValue: unknown, model: object, propName: PropertyKey) {
       const modelCache = getOrCreate(cache, model, () => new Map())
 
-      cacheTransformResult = false
+      let cacheTransformResult = false
       const originalValue = untransform({
         transformedValue,
-        cacheTransformedValue: cacheTransformedValueFn,
+        cacheTransformedValue: () => {
+          cacheTransformResult = true
+        },
       })
       if (cacheTransformResult) {
         modelCache.set(propName, { originalValue, transformedValue })

package/src/modelShared/sharedInternalModel.ts

@@ -19,7 +19,14 @@ import type { AnyType } from "../types/schemas"
 import { tProp } from "../types/tProp"
 import { resolveStoredType } from "../types/utility/typesCodec"
 import { typesUnchecked } from "../types/utility/typesUnchecked"
-import { addHiddenProp, assertIsObject, failure, propNameToSetterName } from "../utils"
+import {
+  addHiddenProp,
+  assertIsObject,
+  failure,
+  hasOwnProp,
+  propNameToSetterName,
+  setProtoProp,
+} from "../utils"
 import { chainFns } from "../utils/chainFns"
 import { withErrorPathSegment } from "../utils/errorDiagnostics"
 import { type ModelClass, modelInitializedSymbol } from "./BaseModelShared"
@@ -275,7 +282,9 @@ export function sharedInternalModel<
     dataTypeChecker = typesObject(() => {
       const typeCheckerObj: Record<string, AnyType> = {}
       for (const [k, mp] of Object.entries(composedModelProps)) {
-        typeCheckerObj[k] = mp._typeChecker ? resolveStoredType(mp._typeChecker) : typesUnchecked()
+        const typeChecker = mp._typeChecker ? resolveStoredType(mp._typeChecker) : typesUnchecked()
+        if (k === "__proto__") setProtoProp(typeCheckerObj, typeChecker)
+        else typeCheckerObj[k] = typeChecker
       }
       return typeCheckerObj
     })
@@ -451,7 +460,11 @@ function getModelPropsSnapshotProcessor(
   return (sn) => {
     const newSn = { ...sn }
     for (const [propName, processor] of propsWithProcessor) {
-      newSn[propName] = withErrorPathSegment(propName, () => processor(sn[propName]))
+      const value = withErrorPathSegment(propName, () =>
+        processor(hasOwnProp(sn, propName) ? sn[propName] : undefined)
+      )
+      if (propName === "__proto__") setProtoProp(newSn, value)
+      else newSn[propName] = value
     }
     return newSn
   }

package/src/parent/detach.ts

@@ -10,7 +10,7 @@ import { fastGetParentPathIncludingDataObjects } from "./path"
  * Detaches a given object from a tree.
  * If the parent is an object / model, detaching will delete the property.
  * If the parent is an array detaching will remove the node by splicing it.
- * If there's no parent it will throw.
+ * If there's no parent it does nothing.
  *
  * @param node Object to be detached.
  */

package/src/parent/findChildren.ts

@@ -8,7 +8,7 @@ import { getChildrenObjects } from "./getChildrenObjects"
  * @param predicate Function that will be run for every child of the root object.
  * @param [options] An optional object with the `deep` option (defaults to `false`) set to `true` to
  * get the children deeply or `false` to get them shallowly.
- * @returns A readonly observable set with the matching children.
+ * @returns A readonly set with the matching children.
  */
 export function findChildren<T extends object = any>(
   root: object,
@@ -21,13 +21,10 @@ export function findChildren<T extends object = any>(
 
   const set = new Set<any>()
 
-  const iter = children.values()
-  let cur = iter.next()
-  while (!cur.done) {
-    if (predicate(cur.value)) {
-      set.add(cur.value)
+  for (const child of children) {
+    if (predicate(child)) {
+      set.add(child)
     }
-    cur = iter.next()
   }
 
   return set

package/src/parent/onChildAttachedTo.ts

@@ -32,11 +32,10 @@ export function onChildAttachedTo(
   assertIsFunction(target, "target")
   assertIsFunction(fn, "fn")
 
-  const opts = {
-    deep: false,
-    fireForCurrentChildren: true,
-    ...options,
-  }
+  const { deep = false, fireForCurrentChildren = true } = options ?? {}
+
+  let disposed = false
+  let runCleanupAfterDispose = false
 
   const detachDisposers = new WeakMap<object, () => void>()
 
@@ -48,13 +47,30 @@ export function onChildAttachedTo(
     }
   }
 
+  const runDetachDisposers = (nodes: object[]) => {
+    let firstError: { value: unknown } | undefined
+    for (let i = nodes.length - 1; i >= 0; i--) {
+      try {
+        runDetachDisposer(nodes[i])
+      } catch (value) {
+        firstError ??= { value }
+      }
+    }
+    return firstError
+  }
+
   const addDetachDisposer = (n: object, disposer: (() => void) | void) => {
     if (disposer) {
-      detachDisposers.set(n, action(disposer))
+      const detach = action(disposer)
+      if (disposed) {
+        if (runCleanupAfterDispose) detach()
+      } else {
+        detachDisposers.set(n, detach)
+      }
     }
   }
 
-  const getChildrenObjectOpts = { deep: opts.deep }
+  const getChildrenObjectOpts = { deep }
   const getCurrentChildren = () => {
     const t = target()
     assertTweakedObject(t, "target()")
@@ -62,7 +78,7 @@ export function onChildAttachedTo(
     return new Set(getChildrenObjects(t, getChildrenObjectOpts))
   }
 
-  const currentChildren = opts.fireForCurrentChildren ? new Set<object>() : getCurrentChildren()
+  const currentChildren = fireForCurrentChildren ? new Set<object>() : getCurrentChildren()
 
   const disposer = reaction(
     () => getCurrentChildren(),
@@ -84,45 +100,45 @@ export function onChildAttachedTo(
         currentChildrenCur = currentChildrenIter.next()
       }
 
-      if (disposersToRun.length > 0) {
-        for (let i = disposersToRun.length - 1; i >= 0; i--) {
-          runDetachDisposer(disposersToRun[i])
-        }
-      }
+      let firstError = runDetachDisposers(disposersToRun)
 
       // find new
       const newChildrenIter = newChildren.values()
       let newChildrenCur = newChildrenIter.next()
-      while (!newChildrenCur.done) {
+      while (!disposed && !newChildrenCur.done) {
         const n = newChildrenCur.value
         if (!currentChildren.has(n)) {
           currentChildren.add(n)
 
-          const detachAction = runInAction(() => fn(n))
-          addDetachDisposer(n, detachAction)
+          try {
+            const detachAction = runInAction(() => fn(n))
+            addDetachDisposer(n, detachAction)
+          } catch (value) {
+            firstError ??= { value }
+          }
         }
 
         newChildrenCur = newChildrenIter.next()
       }
+      if (firstError) {
+        throw firstError.value
+      }
     },
     {
       fireImmediately: true,
     }
   )
 
-  return (runDetachDisposers: boolean) => {
+  return (runPendingDetachDisposers: boolean) => {
+    if (disposed) return
+    disposed = true
+    runCleanupAfterDispose = runPendingDetachDisposers
     disposer()
-
-    if (runDetachDisposers) {
-      const currentChildrenIter = currentChildren.values()
-      let currentChildrenCur = currentChildrenIter.next()
-      while (!currentChildrenCur.done) {
-        const n = currentChildrenCur.value
-        runDetachDisposer(n)
-
-        currentChildrenCur = currentChildrenIter.next()
-      }
-    }
+    const pendingChildren = runPendingDetachDisposers ? Array.from(currentChildren) : []
     currentChildren.clear()
+    const firstError = runDetachDisposers(pendingChildren)
+    if (firstError) {
+      throw firstError.value
+    }
   }
 }

package/src/parent/path.ts

@@ -267,11 +267,13 @@ export function resolvePath<T = any>(
       const dataNode = modelToDataNode(current)
       if (p in dataNode) {
         current = dataNode
-      } else if (!(p in current)) {
-        return unresolved
       }
     }
 
+    if (!(p in current)) {
+      return unresolved
+    }
+
     current = current[p]
   }
 
@@ -323,7 +325,7 @@ export function resolvePathCheckingIds<T = any>(
 
     // check just to avoid mobx warnings about trying to access out of bounds index
     if (isArray(current)) {
-      if (+p >= current.length) {
+      if (+p >= current.length || !(p in current)) {
         return { resolved: false }
       }
     } else if (!hasOwnProp(current, p)) {

package/src/parent/setParent.ts

@@ -6,6 +6,7 @@ import { isModel } from "../model/utils"
 import { attachToRootStore, detachFromRootStore } from "../rootStore/attachDetach"
 import { fastIsRootStoreNoAtom } from "../rootStore/rootStore"
 import { clone } from "../snapshot/clone"
+import { flushInternalSnapshot } from "../snapshot/internal"
 import { isTweakedObject } from "../tweaker/core"
 import { treeNodeMetadata } from "../tweaker/treeNodeMetadata"
 import { tryUntweak } from "../tweaker/tweak"
@@ -86,6 +87,12 @@ export const setParent = action(
       return value
     }
 
+    // The new parent captures this node's snapshot during attachment. Flush
+    // descendant edits made while detached before that snapshot is copied.
+    if (parentPath && !oldParentPath) {
+      flushInternalSnapshot(value, false)
+    }
+
     // make sure the new parent actually points to models when we give model data objs
     if (parentPath) {
       const actualParent = dataToModelNode(parentPath.parent)

package/src/parent/walkTree.ts

@@ -75,19 +75,19 @@ function walkTreeChildrenFirst<T = void>(
   root: object,
   visit: (node: object) => T | undefined
 ): T | undefined {
-  const childrenIter = getObjectChildren(root).values()
-  let ch = childrenIter.next()
-  while (!ch.done) {
-    const ret = walkTreeChildrenFirst(ch.value, visit)
-    if (ret !== undefined) {
-      return ret
+  const stack = [{ node: root, children: getObjectChildren(root).values() }]
+  while (stack.length > 0) {
+    const frame = stack[stack.length - 1]
+    const child = frame.children.next()
+    if (!child.done) {
+      stack.push({ node: child.value, children: getObjectChildren(child.value).values() })
+    } else {
+      stack.pop()
+      const ret = visit(frame.node)
+      if (ret !== undefined) {
+        return ret
+      }
     }
-    ch = childrenIter.next()
-  }
-
-  const ret = visit(root)
-  if (ret !== undefined) {
-    return ret
   }
 
   return undefined
@@ -136,37 +136,21 @@ function walkTreeAggregate<R>(
   let map: Map<R, object> | undefined
   const rootVal = visit(target)
 
-  const childrenMap = getObjectChildren(target)
-  const childrenIter = childrenMap.values()
-  let ch = childrenIter.next()
+  const children = getObjectChildren(target)
 
-  // small optimization, if there is only one child and this
-  // object provides no value we can just reuse the child ones
-  if (rootVal === undefined && childrenMap.size === 1) {
-    return recurse(ch.value!)
+  // With one child and no local value, the child's map can be reused.
+  if (rootVal === undefined && children.size === 1) {
+    return recurse(children.values().next().value!)
   }
 
-  while (!ch.done) {
-    const childMap = recurse(ch.value)
-
+  for (const child of children) {
+    const childMap = recurse(child)
     if (childMap) {
-      if (!map) {
-        map = new Map()
-      }
-
-      // add child map keys/values to own map
-      const mapIter = childMap.keys()
-
-      let mapCur = mapIter.next()
-      while (!mapCur.done) {
-        const key = mapCur.value
-        const val = childMap.get(key)!
-        map.set(key, val)
-        mapCur = mapIter.next()
+      map ??= new Map()
+      for (const [key, value] of childMap) {
+        map.set(key, value)
       }
     }
-
-    ch = childrenIter.next()
   }
 
   // add it at the end so parent resolutions have higher

package/src/patch/applyPatches.ts

@@ -4,8 +4,10 @@ import { ActionContextActionType } from "../action/context"
 import { wrapInAction } from "../action/wrapInAction"
 import { modelToDataNode } from "../parent/core"
 import type { Patch } from "../patch/Patch"
+import { internalApplySnapshot } from "../snapshot/applySnapshot"
 import { reconcileSnapshot } from "../snapshot/reconcileSnapshot"
 import { assertTweakedObject } from "../tweaker/core"
+import { withTypeCheckingBatch } from "../tweaker/typeChecking"
 import { failure, inDevMode, isArray, lazy } from "../utils"
 import { runWithErrorDiagnosticsContext, withErrorPathSegments } from "../utils/errorDiagnostics"
 import { ModelPool } from "../utils/ModelPool"
@@ -13,6 +15,8 @@ import { setIfDifferent } from "../utils/setIfDifferent"
 
 /**
  * Applies the given patches to the given target object.
+ * Automatic type checking validates the completed batch, including nested lists.
+ * A rejected batch is rolled back with compensating patches.
  *
  * @param node Target object.
  * @param patches List of patches to apply.
@@ -44,33 +48,35 @@ export function internalApplyPatches(
     const obj = this
     const modelPool = new ModelPool(obj)
 
-    if (reverse) {
-      let i = patches.length
-      while (i--) {
-        const p = patches[i]
-        if (isArray(p)) {
-          let j = p.length
-          while (j--) {
-            applySinglePatchWithPath(obj, p[j], modelPool)
+    withTypeCheckingBatch(() => {
+      if (reverse) {
+        let i = patches.length
+        while (i--) {
+          const p = patches[i]
+          if (isArray(p)) {
+            let j = p.length
+            while (j--) {
+              applySinglePatchWithPath(obj, p[j], modelPool)
+            }
+          } else {
+            applySinglePatchWithPath(obj, p as Patch, modelPool)
           }
-        } else {
-          applySinglePatchWithPath(obj, p as Patch, modelPool)
         }
-      }
-    } else {
-      const len = patches.length
-      for (let i = 0; i < len; i++) {
-        const p = patches[i]
-        if (isArray(p)) {
-          const len2 = p.length
-          for (let j = 0; j < len2; j++) {
-            applySinglePatchWithPath(obj, p[j], modelPool)
+      } else {
+        const len = patches.length
+        for (let i = 0; i < len; i++) {
+          const p = patches[i]
+          if (isArray(p)) {
+            const len2 = p.length
+            for (let j = 0; j < len2; j++) {
+              applySinglePatchWithPath(obj, p[j], modelPool)
+            }
+          } else {
+            applySinglePatchWithPath(obj, p as Patch, modelPool)
           }
-        } else {
-          applySinglePatchWithPath(obj, p as Patch, modelPool)
         }
       }
-    }
+    })
   })
 }
 
@@ -88,20 +94,33 @@ function applySinglePatch(obj: object, patch: Patch, modelPool: ModelPool): void
     throw failure(`invalid path: ${path}`)
   }
 
+  if (path.length === 0) {
+    if (patch.op === "add" || patch.op === "replace") {
+      internalApplySnapshot.call(obj, patch.value)
+      return
+    }
+    throw failure("a patch cannot remove the root node")
+  }
+
   let target: any = modelToDataNode(obj)
   for (let i = 0; i < path.length - 1; i++) {
     target = modelToDataNode(target[path[i]])
   }
-  const prop = path.length > 0 ? path[path.length - 1] : undefined
+  const prop = path[path.length - 1]
 
   if (isArray(target)) {
+    if (patch.op === "replace" && prop === "length") {
+      target.length = patch.value
+      return
+    }
+
+    const index = getPatchArrayIndex(prop, target.length, patch.op)
     switch (patch.op) {
       case "add": {
-        const index = +prop!
         // reconcile from the pool if possible
         const newValue = reconcileSnapshot(undefined, patch.value, modelPool, target)
         if (index < 0) {
-          // extension needed by mobx-keystone-yjs
+          // non-standard extension: a negative index appends, just like "-"
           target.push(newValue)
         } else {
           target.splice(index, 0, newValue)
@@ -110,21 +129,15 @@ function applySinglePatch(obj: object, patch: Patch, modelPool: ModelPool): void
       }
 
       case "remove": {
-        const index = +prop!
         // no reconciliation, removing
         target.splice(index, 1)
         break
       }
 
       case "replace": {
-        if (prop === "length") {
-          target.length = patch.value
-        } else {
-          const index = +prop!
-          // try to reconcile
-          const newValue = reconcileSnapshot(target[index], patch.value, modelPool, target)
-          setIfDifferent(target, index as any, newValue)
-        }
+        // try to reconcile
+        const newValue = reconcileSnapshot(target[index], patch.value, modelPool, target)
+        setIfDifferent(target, index as any, newValue)
         break
       }
 
@@ -160,6 +173,28 @@ function applySinglePatch(obj: object, patch: Patch, modelPool: ModelPool): void
   }
 }
 
+// canonical decimal integers only, so "01", "1.0" or "1e0" are not mistaken for indexes
+const patchArrayIndexPattern = /^(?:0|-?[1-9]\d*)$/
+
+function getPatchArrayIndex(prop: string | number, length: number, op: Patch["op"]): number {
+  // JSON Patch spells "at the end of the array" as "-", which only makes sense when adding
+  if (prop === "-" && op === "add") {
+    return length
+  }
+
+  const index =
+    typeof prop === "string" && !patchArrayIndexPattern.test(prop) ? Number.NaN : Number(prop)
+
+  // additions may also target the end of the array, plus negative indexes as an append extension
+  const valid =
+    Number.isInteger(index) && (op === "add" ? index <= length : index >= 0 && index < length)
+  if (!valid) {
+    throw failure(`invalid array index '${String(prop)}' for '${op}' patch`)
+  }
+
+  return index
+}
+
 function applySinglePatchWithPath(obj: object, patch: Patch, modelPool: ModelPool): void {
   withErrorPathSegments(patch.path, () => {
     applySinglePatch(obj, patch, modelPool)