mobx-keystone 2.0.0 → 2.1.0

package/src/parent/onChildAttachedTo.ts

@@ -1,7 +1,13 @@
-import { action, reaction, runInAction } from "mobx"
+import { action, createAtom, reaction, runInAction } from "mobx"
 import { assertTweakedObject } from "../tweaker/core"
 import { assertIsFunction } from "../utils"
+import {
+  addObjectChildrenListener,
+  type ObjectChildrenListener,
+  removeObjectChildrenListener,
+} from "./coreObjectChildren"
 import { getChildrenObjects } from "./getChildrenObjects"
+import { compareTreePaths, getPathFromAncestor } from "./treeOrder"
 
 /**
  * Runs a callback everytime a new object is attached to a given node.
@@ -47,7 +53,7 @@ export function onChildAttachedTo(
     }
   }
 
-  const runDetachDisposers = (nodes: object[]) => {
+  const runDetachDisposers = (nodes: readonly object[]) => {
     let firstError: { value: unknown } | undefined
     for (let i = nodes.length - 1; i >= 0; i--) {
       try {
@@ -71,58 +77,137 @@ export function onChildAttachedTo(
   }
 
   const getChildrenObjectOpts = { deep }
-  const getCurrentChildren = () => {
+  const getTarget = () => {
     const t = target()
     assertTweakedObject(t, "target()")
-
-    return new Set(getChildrenObjects(t, getChildrenObjectOpts))
+    return t
   }
 
-  const currentChildren = fireForCurrentChildren ? new Set<object>() : getCurrentChildren()
+  /** Children the callback ran for, with increasing numbers in the order it did. */
+  const currentChildren = new Map<object, number>()
+  let lastChildOrder = 0
 
-  const disposer = reaction(
-    () => getCurrentChildren(),
-    (newChildren) => {
-      const disposersToRun: object[] = []
-
-      // find dead
-      const currentChildrenIter = currentChildren.values()
-      let currentChildrenCur = currentChildrenIter.next()
-      while (!currentChildrenCur.done) {
-        const n = currentChildrenCur.value
-        if (!newChildren.has(n)) {
-          currentChildren.delete(n)
-
-          // we should run it in inverse order
-          disposersToRun.push(n)
-        }
+  const updateChildren = (dead: readonly object[], born: Iterable<object>) => {
+    for (const n of dead) {
+      currentChildren.delete(n)
+    }
+    // we should run them in inverse order
+    let firstError = runDetachDisposers(dead)
 
-        currentChildrenCur = currentChildrenIter.next()
+    for (const n of born) {
+      if (disposed) {
+        break
       }
+      currentChildren.set(n, ++lastChildOrder)
 
-      let firstError = runDetachDisposers(disposersToRun)
-
-      // find new
-      const newChildrenIter = newChildren.values()
-      let newChildrenCur = newChildrenIter.next()
-      while (!disposed && !newChildrenCur.done) {
-        const n = newChildrenCur.value
-        if (!currentChildren.has(n)) {
-          currentChildren.add(n)
-
-          try {
-            const detachAction = runInAction(() => fn(n))
-            addDetachDisposer(n, detachAction)
-          } catch (value) {
-            firstError ??= { value }
-          }
-        }
+      try {
+        const detachAction = runInAction(() => fn(n))
+        addDetachDisposer(n, detachAction)
+      } catch (value) {
+        firstError ??= { value }
+      }
+    }
+    if (firstError) {
+      throw firstError.value
+    }
+  }
 
-        newChildrenCur = newChildrenIter.next()
+  const updateChildrenByDiff = (newChildren: ReadonlySet<object>) => {
+    const dead: object[] = []
+    for (const n of currentChildren.keys()) {
+      if (!newChildren.has(n)) {
+        dead.push(n)
+      }
+    }
+    const born: object[] = []
+    for (const n of newChildren) {
+      if (!currentChildren.has(n)) {
+        born.push(n)
       }
-      if (firstError) {
-        throw firstError.value
+    }
+    updateChildren(dead, born)
+  }
+
+  /** Updates the children given the only nodes that may have been attached or detached. */
+  const updateChildrenIncrementally = (t: object, nodes: ReadonlySet<object>) => {
+    const dead: object[] = []
+    const born: { node: object; path: object[] }[] = []
+    for (const node of nodes) {
+      const path = getPathFromAncestor(t, node, false)
+      const isChild = path !== undefined && (deep || path.length === 1)
+      if (currentChildren.has(node)) {
+        if (!isChild) {
+          dead.push(node)
+        }
+      } else if (isChild) {
+        born.push({ node, path })
       }
+    }
+    // same orders as a diff: the old children in the order they were added,
+    // and the new ones in the order of the children set
+    dead.sort((a, b) => currentChildren.get(a)! - currentChildren.get(b)!)
+    born.sort((a, b) => compareTreePaths(a.path, b.path, true))
+    updateChildren(
+      dead,
+      born.map((b) => b.node)
+    )
+  }
+
+  // nodes that may have been attached to or detached from the target since
+  // the last update
+  let touched = new Set<object>()
+  const touchedAtom = createAtom("onChildAttachedTo")
+  const listener: ObjectChildrenListener = {
+    deep,
+    onChildrenChanged(nodes) {
+      for (const n of nodes) {
+        touched.add(n)
+      }
+      touchedAtom.reportChanged()
+    },
+  }
+  let listenedTarget: object | undefined
+
+  const stopListening = () => {
+    if (listenedTarget) {
+      removeObjectChildrenListener(listenedTarget, listener)
+      listenedTarget = undefined
+    }
+    touched = new Set()
+  }
+
+  const update = (t: object) => {
+    if (t !== listenedTarget) {
+      stopListening()
+      addObjectChildrenListener(t, listener)
+      listenedTarget = t
+      updateChildrenByDiff(getChildrenObjects(t, getChildrenObjectOpts))
+      return
+    }
+
+    const nodes = touched
+    touched = new Set()
+    // (even when most children changed, this is about as fast as a diff)
+    if (nodes.size > 0) {
+      updateChildrenIncrementally(t, nodes)
+    }
+  }
+
+  if (!fireForCurrentChildren) {
+    for (const n of getChildrenObjects(getTarget(), getChildrenObjectOpts)) {
+      currentChildren.set(n, ++lastChildOrder)
+    }
+  }
+
+  const disposer = reaction(
+    () => {
+      const t = getTarget()
+      touchedAtom.reportObserved()
+      // a new object, so every change runs the effect
+      return { t }
+    },
+    ({ t }) => {
+      update(t)
     },
     {
       fireImmediately: true,
@@ -134,7 +219,8 @@ export function onChildAttachedTo(
     disposed = true
     runCleanupAfterDispose = runPendingDetachDisposers
     disposer()
-    const pendingChildren = runPendingDetachDisposers ? Array.from(currentChildren) : []
+    stopListening()
+    const pendingChildren = runPendingDetachDisposers ? Array.from(currentChildren.keys()) : []
     currentChildren.clear()
     const firstError = runDetachDisposers(pendingChildren)
     if (firstError) {

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
 }
 
 /**

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()
+    }
   })
 }