mobx-keystone 2.0.0 → 2.2.0

package/src/parent/path.ts

@@ -3,6 +3,7 @@ import { isModel } from "../model/utils"
 import { assertTweakedObject } from "../tweaker/core"
 import { treeNodeMetadata } from "../tweaker/treeNodeMetadata"
 import { hasOwnProp, isArray, isObject } from "../utils"
+import { LazyArrayParentPath } from "./arrayPaths"
 import {
   dataToModelNode,
   getDataObjectParent,
@@ -61,7 +62,10 @@ export interface RootPath<T extends object> {
 export function getParentPath<T extends object = any>(value: object): ParentPath<T> | undefined {
   assertTweakedObject(value, "value")
 
-  return fastGetParentPath(value, true)
+  const parentPath = fastGetParentPath<T>(value, true)
+  return parentPath instanceof LazyArrayParentPath
+    ? (parentPath.toParentPath() as ParentPath<T>)
+    : parentPath
 }
 
 /**
@@ -71,10 +75,14 @@ export function fastGetParentPath<T extends object = any>(
   value: object,
   useAtom: boolean
 ): ParentPath<T> | undefined {
+  const parentPath = treeNodeMetadata.get(value)?.parentPath
   if (useAtom) {
     reportParentPathObserved(value)
+    if (parentPath instanceof LazyArrayParentPath) {
+      parentPath.reportObserved()
+    }
   }
-  return treeNodeMetadata.get(value)?.parentPath as ParentPath<T> | undefined
+  return parentPath as ParentPath<T> | undefined
 }
 
 /**
@@ -119,16 +127,6 @@ export function fastGetParent<T extends object = any>(
   return fastGetParentPath(value, useAtom)?.parent
 }
 
-/**
- * @internal
- */
-export function fastGetParentIncludingDataObjects<T extends object = any>(
-  value: object,
-  useAtom: boolean
-): T | undefined {
-  return fastGetParentPathIncludingDataObjects(value, useAtom)?.parent
-}
-
 /**
  * Returns if a given object is a model interim data object (`$`).
  *

package/src/parent/setParent.ts

@@ -17,9 +17,11 @@ import {
   reportParentPathChanged,
   setDataObjectParent,
 } from "./core"
-import { addObjectChild, removeObjectChild } from "./coreObjectChildren"
+import { addObjectChild, hasObjectChildren, removeObjectChild } from "./coreObjectChildren"
 import { fastGetParentPath, fastGetRoot, type ParentPath } from "./path"
 
+const reindexChunkSize = 4096
+
 /**
  * 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
@@ -29,18 +31,24 @@ import { fastGetParentPath, fastGetRoot, type ParentPath } from "./path"
 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")
+    // Copy the tail in chunks: indexed reads through an observable array are
+    // much slower than a slice, and chunking bounds the temporary copy size.
+    const length = array.length
+    for (let chunkStart = oldStart; chunkStart < length; chunkStart += reindexChunkSize) {
+      const chunk = array.slice(chunkStart, chunkStart + reindexChunkSize)
+      for (let i = 0, j = newStart + chunkStart - oldStart; i < chunk.length; i++, j++) {
+        const value = chunk[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)
       }
-      // Replace the path object: callers may have retained the previous path.
-      metadata!.parentPath = { parent: array, path: j }
-      reportParentPathChanged(value as object)
     }
   }
 )
@@ -123,11 +131,15 @@ export const setParent = action(
 
     const postUntweaker = parentPath ? undefined : tryUntweak(value)
 
-    const valueIsModel = value instanceof BaseModel
+    // A model's root store hooks run when its own root changes. A plain node
+    // has none of its own, but one attached with children may bring models
+    // into a root store. (When detached, its children get detached one by one.)
+    const checkRootStore =
+      value instanceof BaseModel || (!oldParentPath && !!parentPath && hasObjectChildren(value))
 
     let oldRoot: any
     let oldRootStore: any
-    if (valueIsModel) {
+    if (checkRootStore) {
       oldRoot = fastGetRoot(value, false)
       oldRootStore = fastIsRootStoreNoAtom(oldRoot) ? oldRoot : undefined
     }
@@ -144,7 +156,7 @@ export const setParent = action(
     }
     reportParentPathChanged(value)
 
-    if (valueIsModel) {
+    if (checkRootStore) {
       const newRoot = fastGetRoot(value, false)
       const newRootStore = fastIsRootStoreNoAtom(newRoot) ? newRoot : undefined
 

package/src/parent/treeOrder.ts

@@ -0,0 +1,53 @@
+import { treeNodeMetadata } from "../tweaker/treeNodeMetadata"
+import { reportParentPathObserved } from "./core"
+
+/**
+ * Nodes from right below the ancestor down to the node, or `undefined` when the
+ * node is not below it. Optionally observes their parents.
+ *
+ * @internal
+ */
+export function getPathFromAncestor(
+  ancestor: object,
+  node: object,
+  observeParents: boolean
+): object[] | undefined {
+  const path: object[] = []
+  let current: object | undefined = node
+  while (current !== ancestor) {
+    if (!current) {
+      return undefined
+    }
+    path.push(current)
+    if (observeParents) {
+      reportParentPathObserved(current)
+    }
+    current = treeNodeMetadata.get(current)?.parentPath?.parent
+  }
+  return path.reverse()
+}
+
+/**
+ * Compares two paths from the same ancestor (see `getPathFromAncestor`) by the
+ * order a walk of the tree visits their nodes. The walk visits the children of
+ * a node in the order they were attached, and visits parents before their
+ * children when `parentsFirst`, or after them otherwise.
+ *
+ * @internal
+ */
+export function compareTreePaths(
+  a: readonly object[],
+  b: readonly object[],
+  parentsFirst: boolean
+): number {
+  const length = Math.min(a.length, b.length)
+  for (let i = 0; i < length; i++) {
+    if (a[i] !== b[i]) {
+      // siblings
+      return treeNodeMetadata.get(a[i])!.attachOrder - treeNodeMetadata.get(b[i])!.attachOrder
+    }
+  }
+  // the shorter path ends at an ancestor of the other node
+  const depthDifference = a.length - b.length
+  return parentsFirst ? depthDifference : -depthDifference
+}

package/src/parent/walkTree.ts

@@ -1,4 +1,3 @@
-import { computed, type IComputedValue } from "mobx"
 import { assertTweakedObject } from "../tweaker/core"
 import { getObjectChildren } from "./coreObjectChildren"
 
@@ -92,75 +91,3 @@ function walkTreeChildrenFirst<T = void>(
 
   return undefined
 }
-
-/**
- * @internal
- */
-export interface ComputedWalkTreeAggregate<R> {
-  walk(target: object): Map<R, object> | undefined
-}
-
-function getComputedTreeResult<R>(
-  computedFns: WeakMap<object, IComputedValue<Map<R, object> | undefined>>,
-  visit: (node: object) => R | undefined,
-  tree: object
-): Map<R, object> | undefined {
-  let cmpted = computedFns.get(tree)
-  if (!cmpted) {
-    cmpted = computed(() => {
-      return walkTreeAggregate(tree, visit, (ch) => getComputedTreeResult(computedFns, visit, ch))
-    })
-    computedFns.set(tree, cmpted)
-  }
-  return cmpted.get()
-}
-
-/**
- * @internal
- */
-export function computedWalkTreeAggregate<R>(
-  visit: (node: object) => R | undefined
-): ComputedWalkTreeAggregate<R> {
-  const computedFns = new WeakMap<object, IComputedValue<Map<R, object> | undefined>>()
-
-  return {
-    walk: (n) => getComputedTreeResult(computedFns, visit, n),
-  }
-}
-
-function walkTreeAggregate<R>(
-  target: object,
-  visit: (node: object) => R | undefined,
-  recurse: (node: object) => Map<R, object> | undefined
-): Map<R, object> | undefined {
-  let map: Map<R, object> | undefined
-  const rootVal = visit(target)
-
-  const children = getObjectChildren(target)
-
-  // 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!)
-  }
-
-  for (const child of children) {
-    const childMap = recurse(child)
-    if (childMap) {
-      map ??= new Map()
-      for (const [key, value] of childMap) {
-        map.set(key, value)
-      }
-    }
-  }
-
-  // add it at the end so parent resolutions have higher
-  // priority than child ones
-  if (rootVal !== undefined) {
-    if (!map) {
-      map = new Map()
-    }
-    map.set(rootVal, target)
-  }
-
-  return map
-}

package/src/patch/applyPatches.ts

@@ -6,8 +6,8 @@ import { modelToDataNode } from "../parent/core"
 import type { Patch } from "../patch/Patch"
 import { internalApplySnapshot } from "../snapshot/applySnapshot"
 import { reconcileSnapshot } from "../snapshot/reconcileSnapshot"
+import { withChangeBatch } from "../tweaker/changeRollback"
 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"
@@ -16,7 +16,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.
+ * A batch that throws or is rejected is rolled back with compensating patches.
+ * Errors thrown by listeners do not roll it back.
  *
  * @param node Target object.
  * @param patches List of patches to apply.
@@ -48,35 +49,39 @@ export function internalApplyPatches(
     const obj = this
     const modelPool = new ModelPool(obj)
 
-    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)
+    try {
+      withChangeBatch(() => {
+        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)
           }
         }
-      }
-    })
+      })
+    } finally {
+      modelPool.release()
+    }
   })
 }
 

package/src/patch/patchRecorder.ts

@@ -108,36 +108,21 @@ export function internalPatchRecorder(
     deep: false,
   })
 
-  let onPatchesDisposer: OnPatchesDisposer
-
-  if (subtreeRoot) {
-    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 = internalOnGlobalPatches((target, p, invP) => {
-      if (recording && filter(p, invP)) {
-        events.push({
-          target,
-          patches: p,
-          inversePatches: invP,
-        })
-        opts?.onPatches?.(p, invP)
-      }
-    }, true)
+  const record = (target: object, p: Patch[], invP: Patch[]) => {
+    if (recording && filter(p, invP)) {
+      events.push({
+        target,
+        patches: p,
+        inversePatches: invP,
+      })
+      opts?.onPatches?.(p, invP)
+    }
   }
 
+  const onPatchesDisposer: OnPatchesDisposer = subtreeRoot
+    ? internalOnPatches(subtreeRoot, (p, invP) => record(subtreeRoot, p, invP), true)
+    : internalOnGlobalPatches(record, true)
+
   return {
     get recording() {
       return recording

package/src/ref/core.ts

@@ -2,16 +2,14 @@ import { action, type ObservableSet, observable, reaction, when } from "mobx"
 import { isModel } from "../model/utils"
 import type { ModelClass } from "../modelShared/BaseModelShared"
 import { model } from "../modelShared/modelDecorator"
-import {
-  getDeepObjectChildren,
-  registerDeepObjectChildrenExtension,
-} from "../parent/coreObjectChildren"
+import { registerDeepObjectChildrenExtension } from "../parent/coreObjectChildren"
 import { fastGetRoot } from "../parent/path"
-import { type ComputedWalkTreeAggregate, computedWalkTreeAggregate } from "../parent/walkTree"
 import { assertTweakedObject } from "../tweaker/core"
 import { assertIsObject, failure, mobxAction } from "../utils"
 import { getOrCreate } from "../utils/mapUtils"
+import { modelRefIdNotIndexed, resolveModelRefId } from "./modelRefIdIndex"
 import { Ref, type RefConstructor } from "./Ref"
+import { resolveRefIdByIndex } from "./refIdIndex"
 
 interface BackRefs<T extends object> {
   all: ObservableSet<Ref<T>>
@@ -192,12 +190,6 @@ export function getModelRefId(target: object): string | undefined {
   return undefined
 }
 
-// one computed id tree per id function
-const computedIdTrees = new WeakMap<
-  (node: object) => string | undefined,
-  ComputedWalkTreeAggregate<string>
->()
-
 /**
  * Resolves a node given its ID.
  *
@@ -212,38 +204,32 @@ export function resolveId<T extends object>(
   id: string,
   getId: RefIdResolver = getModelRefId
 ): T | undefined {
-  // cache/reuse computedIdTrees for same getId function
-  const computedIdTree = getOrCreate(computedIdTrees, getId, () =>
-    computedWalkTreeAggregate<string>((node) => getId(node))
-  )
+  // parent resolutions have priority over child ones
+  if (getId(root) === id) {
+    return root as T
+  }
+
+  if (getId === getModelRefId) {
+    const found = resolveModelRefId(root, id)
+    if (found !== modelRefIdNotIndexed) {
+      return found as T | undefined
+    }
+  }
 
-  const idMap = computedIdTree.walk(root)
-  return idMap ? (idMap.get(id) as T | undefined) : undefined
+  // custom ids (or models with a custom `getRefId`)
+  return resolveRefIdByIndex(root, id, getId) as T | undefined
 }
 
+const createRefSet = () => observable.set<Ref<any>>(undefined, { deep: false })
+
+const createBackRefs = (): BackRefs<any> => ({ all: createRefSet(), byType: new WeakMap() })
+
 function getBackRefs<T extends object>(
   target: T,
   refType?: RefConstructor<T>
 ): ObservableSet<Ref<T>> {
-  let backRefs = objectBackRefs.get(target) as BackRefs<T> | undefined
-  if (!backRefs) {
-    backRefs = {
-      all: observable.set(undefined, { deep: false }),
-      byType: new WeakMap(),
-    }
-    objectBackRefs.set(target, backRefs)
-  }
-
-  if (refType) {
-    let byType = backRefs.byType.get(refType)
-    if (!byType) {
-      byType = observable.set(undefined, { deep: false })
-      backRefs.byType.set(refType, byType)
-    }
-    return byType
-  } else {
-    return backRefs.all
-  }
+  const backRefs: BackRefs<T> = getOrCreate(objectBackRefs, target, createBackRefs)
+  return refType ? getOrCreate(backRefs.byType, refType, createRefSet) : backRefs.all
 }
 
 /**
@@ -285,14 +271,25 @@ export function getRefsResolvingTo<T extends object>(
     oldBackRefs.forEach(updateRef)
   }
 
-  const refsChildrenOfRoot = getDeepChildrenRefs(getDeepObjectChildren(fastGetRoot(target, true)))
-  let refs: Set<Ref<object>> | undefined
-  if (refType) {
-    refs = refsChildrenOfRoot.byType.get(refType.refClass)
+  const refsChildrenOfRoot = getDeepChildrenRefs.get(fastGetRoot(target, true))
+  if (shouldForceUpdateTrackedRefs) {
+    const refs = refType ? refsChildrenOfRoot.byType.get(refType.refClass) : refsChildrenOfRoot.all
+    refs?.forEach(updateRef)
   } else {
-    refs = refsChildrenOfRoot.all
+    // tracked refs keep their back-references up to date by themselves
+    const untrackedRefs = refType
+      ? refsChildrenOfRoot.untrackedByType.get(refType.refClass)
+      : refsChildrenOfRoot.untracked
+    if (untrackedRefs && untrackedRefs.size > 0) {
+      // copy, since updating back-references might change the tree
+      for (const ref of Array.from(untrackedRefs)) {
+        updateRef(ref)
+        if (trackedRefs.has(ref)) {
+          deleteRef(refsChildrenOfRoot.untracked, refsChildrenOfRoot.untrackedByType, ref)
+        }
+      }
+    }
   }
-  refs?.forEach(updateRef)
 
   return getBackRefs(target, refType)
 }
@@ -332,9 +329,24 @@ function isReactionDelayed() {
   return reactionDelayed
 }
 
+type RefsByType = WeakMap<ModelClass<Ref<any>>, Set<Ref<any>>>
+
 interface DeepChildrenRefs {
   all: Set<Ref<any>>
-  byType: WeakMap<ModelClass<Ref<any>>, Set<Ref<any>>>
+  byType: RefsByType
+  /** Refs whose back-references might not be tracked yet. */
+  untracked: Set<Ref<any>>
+  untrackedByType: RefsByType
+}
+
+function addRef(all: Set<Ref<any>>, byType: RefsByType, ref: Ref<any>) {
+  all.add(ref)
+  getOrCreate(byType, ref.constructor as ModelClass<Ref<any>>, () => new Set()).add(ref)
+}
+
+function deleteRef(all: Set<Ref<any>>, byType: RefsByType, ref: Ref<any>) {
+  all.delete(ref)
+  byType.get(ref.constructor as ModelClass<Ref<any>>)?.delete(ref)
 }
 
 const getDeepChildrenRefs = registerDeepObjectChildrenExtension<DeepChildrenRefs>({
@@ -342,14 +354,25 @@ const getDeepChildrenRefs = registerDeepObjectChildrenExtension<DeepChildrenRefs
     return {
       all: new Set(),
       byType: new WeakMap(),
+      untracked: new Set(),
+      untrackedByType: new WeakMap(),
     }
   },
 
   addNode(node, data) {
     if (node instanceof Ref) {
-      data.all.add(node)
-      const refsByThisType = getOrCreate(data.byType, node.constructor, () => new Set())
-      refsByThisType.add(node)
+      addRef(data.all, data.byType, node)
+      if (!trackedRefs.has(node)) {
+        addRef(data.untracked, data.untrackedByType, node)
+      }
+    }
+  },
+
+  removeNode(node, data) {
+    if (node instanceof Ref) {
+      deleteRef(data.all, data.byType, node)
+      deleteRef(data.untracked, data.untrackedByType, node)
     }
+    return true
   },
 })