mobx-keystone 1.24.1 → 2.0.0

package/src/modelShared/modelDecorator.ts

@@ -1,6 +1,7 @@
 import { HookAction } from "../action/hookActions"
 import { wrapModelMethodInActionIfNeeded } from "../action/wrapInAction"
 import type { AnyDataModel } from "../dataModel/BaseDataModel"
+import { dataModelInstanceCache } from "../dataModel/dataModelInstanceCache"
 import { isDataModelClass } from "../dataModel/utils"
 import { enterInitPhase, exitInitPhase } from "../deepChange/onDeepChange"
 import { getGlobalConfig } from "../globalConfig"
@@ -41,22 +42,19 @@ export const model =
   ): MC =>
     internalModel(name, clazz) as any
 
+interface AfterClassInitializationData {
+  needsMakeObservable: boolean | undefined
+  type: "class" | "data"
+}
+
 const afterClassInitializationData = new WeakMap<
   ModelClass<AnyModel | AnyDataModel>,
-  {
-    needsMakeObservable: boolean | undefined
-    type: "class" | "data"
-  }
+  AfterClassInitializationData
 >()
 
-const runAfterClassInitialization = (
-  target: ModelClass<AnyModel | AnyDataModel>,
-  instance: any
-) => {
+const runAfterClassInitialization = (tag: AfterClassInitializationData, instance: any) => {
   runLateInitializationFunctions(instance, runAfterNewSymbol)
 
-  const tag = afterClassInitializationData.get(target)!
-
   // compatibility with mobx 6 and 7
   if (tag.needsMakeObservable) {
     // we know it can be done and shouldn't fail
@@ -112,11 +110,33 @@ const runAfterClassInitialization = (
 
 const proxyClassHandler: ProxyHandler<ModelClass<AnyModel | AnyDataModel>> = {
   construct(clazz, args) {
-    const instance = new (clazz as any)(...args)
+    const tag = afterClassInitializationData.get(clazz)!
 
-    runAfterClassInitialization(clazz, instance)
+    if (tag.type !== "data") {
+      const instance = new (clazz as any)(...args)
+      runAfterClassInitialization(tag, instance)
+      return instance
+    }
+
+    // Data models are cached by their backing data, so constructing one over data that
+    // already has an instance must not rerun its class fields nor its lazy initializer.
+    const modelClass = args[1]?.modelClass ?? modelInfoByClass.get(clazz)!.class
+    const cached = dataModelInstanceCache.get(modelClass)?.get(args[0])
+    if (cached) {
+      return cached
+    }
 
-    return instance
+    let instance: any
+    try {
+      instance = new (clazz as any)(...args)
+      runAfterClassInitialization(tag, instance)
+      return instance
+    } catch (error) {
+      // The base constructor cleans up after itself, but class fields and late
+      // initialization run after it returns, so discard those instances too.
+      dataModelInstanceCache.get(modelClass)?.delete(instance ? instance.$ : args[0])
+      throw error
+    }
   },
 }
 
@@ -245,7 +265,7 @@ export function decoratedModel<M, MC extends abstract new (...ags: any) => M>(
     })
   }
 
-  return (name ? model(name)(clazz as unknown as ModelClass<AnyModel>) : clazz) as MC
+  return (name !== undefined ? model(name)(clazz as unknown as ModelClass<AnyModel>) : clazz) as MC
 }
 
 type MobxAnnotation = {

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/findParent.ts

@@ -19,8 +19,7 @@ export function findParent<T extends object = any>(
   predicate: (parentNode: object) => boolean,
   maxDepth = 0
 ): T | undefined {
-  const foundParentPath = findParentPath(child, predicate, maxDepth)
-  return foundParentPath ? foundParentPath.parent : undefined
+  return findParentInternal<T>(child, predicate, maxDepth)
 }
 
 /**
@@ -56,22 +55,28 @@ export function findParentPath<T extends object = any>(
   predicate: (parentNode: object) => boolean,
   maxDepth = 0
 ): FoundParentPath<T> | undefined {
-  assertTweakedObject(child, "child")
-
   const path: WritablePath = []
+  const parent = findParentInternal<T>(child, predicate, maxDepth, path)
+  return parent ? { parent, path: path.reverse() } : undefined
+}
+
+function findParentInternal<T extends object>(
+  child: object,
+  predicate: (parentNode: object) => boolean,
+  maxDepth: number,
+  path?: WritablePath
+): T | undefined {
+  assertTweakedObject(child, "child")
 
   let current: any = child
   let depth = 0
 
   let parentPath: ParentPath<any> | undefined
   while ((parentPath = fastGetParentPath(current, true))) {
-    path.unshift(parentPath.path)
+    path?.push(parentPath.path)
     current = parentPath.parent
     if (predicate(current)) {
-      return {
-        parent: current,
-        path,
-      }
+      return current
     }
 
     depth++

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,32 +47,38 @@ 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()")
 
-    const children = getChildrenObjects(t, getChildrenObjectOpts)
-
-    const set = new Set<object>()
-
-    const iter = children.values()
-    let cur = iter.next()
-    while (!cur.done) {
-      set.add(cur.value)
-      cur = iter.next()
-    }
-
-    return set
+    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(),
@@ -95,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

@@ -175,10 +175,12 @@ export function fastGetRootPath<T extends object = any>(
   let parentPath: ParentPath<any> | undefined
   while ((parentPath = fastGetParentPath(root, useAtom))) {
     root = parentPath.parent
-    path.unshift(parentPath.path)
-    pathObjects.unshift(parentPath.parent)
+    path.push(parentPath.path)
+    pathObjects.push(parentPath.parent)
   }
 
+  path.reverse()
+  pathObjects.reverse()
   return { root, path, pathObjects } as RootPath<any>
 }
 
@@ -265,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]
   }
 
@@ -321,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)) {
@@ -376,11 +380,11 @@ export function fastGetParentToChildPath(
   let current = toChild
   let parentPath: ParentPath<any> | undefined
   while ((parentPath = fastGetParentPath(current, useAtom))) {
-    path.unshift(parentPath.path)
+    path.push(parentPath.path)
 
     current = parentPath.parent
     if (current === fromParent) {
-      return path
+      return path.reverse()
     }
   }
   return undefined

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"
@@ -19,6 +20,31 @@ import {
 import { addObjectChild, removeObjectChild } from "./coreObjectChildren"
 import { fastGetParentPath, fastGetRoot, type ParentPath } from "./path"
 
+/**
+ * Updates the unchanged tail of an array before a splice is applied. These
+ * children keep their parent, so neither attachment nor child-index work is
+ * needed. One action batches path notifications for the entire tail.
+ * @internal
+ */
+export const reindexArrayChildren = action(
+  "reindexArrayChildren",
+  (array: readonly unknown[], oldStart: number, newStart: number): void => {
+    for (let i = oldStart, j = newStart; i < array.length; i++, j++) {
+      const value = array[i]
+      if (isPrimitive(value)) {
+        continue
+      }
+      const metadata = treeNodeMetadata.get(value as object)
+      if (inDevMode && metadata?.parentPath?.parent !== array) {
+        throw failure("assertion failed: reindexed child must already belong to the array")
+      }
+      // Replace the path object: callers may have retained the previous path.
+      metadata!.parentPath = { parent: array, path: j }
+      reportParentPathChanged(value as object)
+    }
+  }
+)
+
 /**
  * @internal
  */
@@ -27,7 +53,6 @@ export const setParent = action(
   (
     value: any,
     parentPath: ParentPath<any> | undefined,
-    indexChangeAllowed: boolean,
     isDataObject: boolean,
     cloneIfApplicable: boolean
   ): any => {
@@ -36,11 +61,6 @@ export const setParent = action(
     }
 
     if (inDevMode) {
-      if (indexChangeAllowed && cloneIfApplicable) {
-        throw failure(
-          "assertion failed: 'indexChangeAllowed' and 'cloneIfApplicable' cannot be set at the same time"
-        )
-      }
       if (typeof value === "function" || typeof value === "symbol") {
         throw failure(`assertion failed: value cannot be a function or a symbol`)
       }
@@ -67,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)
@@ -92,14 +118,7 @@ export const setParent = action(
     }
 
     if (oldParentPath && parentPath) {
-      if (oldParentPath.parent === parentPath.parent && indexChangeAllowed) {
-        // just changing the index
-        treeNodeMetadata.get(value)!.parentPath = parentPath
-        reportParentPathChanged(value)
-        return value
-      } else {
-        throw failure("an object cannot be assigned a new parent when it already has one")
-      }
+      throw failure("an object cannot be assigned a new parent when it already has one")
     }
 
     const postUntweaker = parentPath ? undefined : tryUntweak(value)

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