mobx-keystone 1.25.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.
@@ -32,11 +38,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,81 +53,178 @@ export function onChildAttachedTo(
     }
   }
 
+  const runDetachDisposers = (nodes: readonly 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 getCurrentChildren = () => {
+  const getChildrenObjectOpts = { deep }
+  const getTarget = () => {
     const t = target()
     assertTweakedObject(t, "target()")
-
-    return new Set(getChildrenObjects(t, getChildrenObjectOpts))
+    return t
   }
 
-  const currentChildren = opts.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)
 
-      if (disposersToRun.length > 0) {
-        for (let i = disposersToRun.length - 1; i >= 0; i--) {
-          runDetachDisposer(disposersToRun[i])
-        }
+      try {
+        const detachAction = runInAction(() => fn(n))
+        addDetachDisposer(n, detachAction)
+      } catch (value) {
+        firstError ??= { value }
       }
+    }
+    if (firstError) {
+      throw firstError.value
+    }
+  }
 
-      // find new
-      const newChildrenIter = newChildren.values()
-      let newChildrenCur = newChildrenIter.next()
-      while (!newChildrenCur.done) {
-        const n = newChildrenCur.value
-        if (!currentChildren.has(n)) {
-          currentChildren.add(n)
+  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)
+      }
+    }
+    updateChildren(dead, born)
+  }
 
-          const detachAction = runInAction(() => fn(n))
-          addDetachDisposer(n, detachAction)
+  /** 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)
+    )
+  }
 
-        newChildrenCur = newChildrenIter.next()
+  // 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,
     }
   )
 
-  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()
-      }
-    }
+    stopListening()
+    const pendingChildren = runPendingDetachDisposers ? Array.from(currentChildren.keys()) : []
     currentChildren.clear()
+    const firstError = runDetachDisposers(pendingChildren)
+    if (firstError) {
+      throw firstError.value
+    }
   }
 }

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
 }
 
 /**
@@ -267,11 +275,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 +333,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"
@@ -16,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
@@ -28,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)
     }
   }
 )
@@ -86,6 +95,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)
@@ -116,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
     }
@@ -137,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"
 
@@ -75,108 +74,20 @@ 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
-    }
-    ch = childrenIter.next()
-  }
-
-  const ret = visit(root)
-  if (ret !== undefined) {
-    return ret
-  }
-
-  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 childrenMap = getObjectChildren(target)
-  const childrenIter = childrenMap.values()
-  let ch = childrenIter.next()
-
-  // 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!)
-  }
-
-  while (!ch.done) {
-    const childMap = recurse(ch.value)
-
-    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()
+  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()
   }
 
-  // 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
+  return undefined
 }