mobx-keystone 1.20.0 → 1.22.0

package/src/parent/setParent.ts

@@ -1,149 +1,149 @@
-import { action } from "mobx"
-import { enqueuePendingAction } from "../action/pendingActions"
-import { BaseModel } from "../model/BaseModel"
-import { getModelMetadata } from "../model/getModelMetadata"
-import { isModel } from "../model/utils"
-import { attachToRootStore, detachFromRootStore } from "../rootStore/attachDetach"
-import { fastIsRootStoreNoAtom } from "../rootStore/rootStore"
-import { clone } from "../snapshot/clone"
-import { isTweakedObject } from "../tweaker/core"
-import { tryUntweak } from "../tweaker/tweak"
-import { failure, inDevMode, isPrimitive } from "../utils"
-import {
-  dataObjectParent,
-  dataToModelNode,
-  objectParents,
-  parentPathEquals,
-  reportParentPathChanged,
-} from "./core"
-import { addObjectChild, removeObjectChild } from "./coreObjectChildren"
-import { ParentPath, fastGetParentPath, fastGetRoot } from "./path"
-
-/**
- * @internal
- */
-export const setParent = action(
-  "setParent",
-  (
-    value: any,
-    parentPath: ParentPath<any> | undefined,
-    indexChangeAllowed: boolean,
-    isDataObject: boolean,
-    cloneIfApplicable: boolean
-  ): any => {
-    if (isPrimitive(value)) {
-      return value
-    }
-
-    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`)
-      }
-      if (!isTweakedObject(value, true)) {
-        throw failure(`assertion failed: value is not ready to take a parent`)
-      }
-      if (parentPath && !isTweakedObject(parentPath.parent, true)) {
-        throw failure(`assertion failed: parent is not ready to take children`)
-      }
-    }
-
-    let oldParentPath = fastGetParentPath(value, false)
-    if (parentPathEquals(oldParentPath, parentPath)) {
-      return value
-    }
-
-    if (fastIsRootStoreNoAtom(value)) {
-      throw failure("root stores cannot be attached to any parents")
-    }
-
-    if (isDataObject) {
-      dataObjectParent.set(value, parentPath!.parent)
-      // data object will proxy to use the actual parent model for child/parent stuff
-      return value
-    }
-
-    // make sure the new parent actually points to models when we give model data objs
-    if (parentPath) {
-      const actualParent = dataToModelNode(parentPath.parent)
-      if (parentPath.parent !== actualParent) {
-        parentPath = {
-          parent: actualParent,
-          path: parentPath.path,
-        }
-      }
-    }
-
-    // value type models should be cloned when they are about to be assigned to a new parent
-    // and they had one previously
-    if (
-      cloneIfApplicable &&
-      parentPath?.parent &&
-      oldParentPath?.parent &&
-      isModel(value) &&
-      getModelMetadata(value).valueType
-    ) {
-      value = clone(value, { generateNewIds: true })
-      oldParentPath = fastGetParentPath(value, false)
-    }
-
-    if (oldParentPath && parentPath) {
-      if (oldParentPath.parent === parentPath.parent && indexChangeAllowed) {
-        // just changing the index
-        objectParents.set(value, parentPath)
-        reportParentPathChanged(value)
-        return value
-      } else {
-        throw failure("an object cannot be assigned a new parent when it already has one")
-      }
-    }
-
-    const postUntweaker = parentPath ? undefined : tryUntweak(value)
-
-    const valueIsModel = value instanceof BaseModel
-
-    let oldRoot: any
-    let oldRootStore: any
-    if (valueIsModel) {
-      oldRoot = fastGetRoot(value, false)
-      oldRootStore = fastIsRootStoreNoAtom(oldRoot) ? oldRoot : undefined
-    }
-
-    // detach from old
-    if (oldParentPath?.parent) {
-      removeObjectChild(oldParentPath.parent, value)
-    }
-
-    // attach to new
-    objectParents.set(value, parentPath)
-    if (parentPath?.parent) {
-      addObjectChild(parentPath.parent, value)
-    }
-    reportParentPathChanged(value)
-
-    if (valueIsModel) {
-      const newRoot = fastGetRoot(value, false)
-      const newRootStore = fastIsRootStoreNoAtom(newRoot) ? newRoot : undefined
-
-      // invoke model root store events
-      if (oldRootStore !== newRootStore && (oldRootStore || newRootStore)) {
-        enqueuePendingAction(() => {
-          if (oldRootStore) {
-            detachFromRootStore(value)
-          }
-          if (newRootStore) {
-            attachToRootStore(newRootStore, value)
-          }
-        })
-      }
-    }
-
-    postUntweaker?.()
-
-    return value
-  }
-)
+import { action } from "mobx"
+import { enqueuePendingAction } from "../action/pendingActions"
+import { BaseModel } from "../model/BaseModel"
+import { getModelMetadata } from "../model/getModelMetadata"
+import { isModel } from "../model/utils"
+import { attachToRootStore, detachFromRootStore } from "../rootStore/attachDetach"
+import { fastIsRootStoreNoAtom } from "../rootStore/rootStore"
+import { clone } from "../snapshot/clone"
+import { isTweakedObject } from "../tweaker/core"
+import { tryUntweak } from "../tweaker/tweak"
+import { failure, inDevMode, isPrimitive } from "../utils"
+import {
+  dataObjectParent,
+  dataToModelNode,
+  objectParents,
+  parentPathEquals,
+  reportParentPathChanged,
+} from "./core"
+import { addObjectChild, removeObjectChild } from "./coreObjectChildren"
+import { fastGetParentPath, fastGetRoot, type ParentPath } from "./path"
+
+/**
+ * @internal
+ */
+export const setParent = action(
+  "setParent",
+  (
+    value: any,
+    parentPath: ParentPath<any> | undefined,
+    indexChangeAllowed: boolean,
+    isDataObject: boolean,
+    cloneIfApplicable: boolean
+  ): any => {
+    if (isPrimitive(value)) {
+      return value
+    }
+
+    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`)
+      }
+      if (!isTweakedObject(value, true)) {
+        throw failure(`assertion failed: value is not ready to take a parent`)
+      }
+      if (parentPath && !isTweakedObject(parentPath.parent, true)) {
+        throw failure(`assertion failed: parent is not ready to take children`)
+      }
+    }
+
+    let oldParentPath = fastGetParentPath(value, false)
+    if (parentPathEquals(oldParentPath, parentPath)) {
+      return value
+    }
+
+    if (fastIsRootStoreNoAtom(value)) {
+      throw failure("root stores cannot be attached to any parents")
+    }
+
+    if (isDataObject) {
+      dataObjectParent.set(value, parentPath!.parent)
+      // data object will proxy to use the actual parent model for child/parent stuff
+      return value
+    }
+
+    // make sure the new parent actually points to models when we give model data objs
+    if (parentPath) {
+      const actualParent = dataToModelNode(parentPath.parent)
+      if (parentPath.parent !== actualParent) {
+        parentPath = {
+          parent: actualParent,
+          path: parentPath.path,
+        }
+      }
+    }
+
+    // value type models should be cloned when they are about to be assigned to a new parent
+    // and they had one previously
+    if (
+      cloneIfApplicable &&
+      parentPath?.parent &&
+      oldParentPath?.parent &&
+      isModel(value) &&
+      getModelMetadata(value).valueType
+    ) {
+      value = clone(value, { generateNewIds: true })
+      oldParentPath = fastGetParentPath(value, false)
+    }
+
+    if (oldParentPath && parentPath) {
+      if (oldParentPath.parent === parentPath.parent && indexChangeAllowed) {
+        // just changing the index
+        objectParents.set(value, parentPath)
+        reportParentPathChanged(value)
+        return value
+      } else {
+        throw failure("an object cannot be assigned a new parent when it already has one")
+      }
+    }
+
+    const postUntweaker = parentPath ? undefined : tryUntweak(value)
+
+    const valueIsModel = value instanceof BaseModel
+
+    let oldRoot: any
+    let oldRootStore: any
+    if (valueIsModel) {
+      oldRoot = fastGetRoot(value, false)
+      oldRootStore = fastIsRootStoreNoAtom(oldRoot) ? oldRoot : undefined
+    }
+
+    // detach from old
+    if (oldParentPath?.parent) {
+      removeObjectChild(oldParentPath.parent, value)
+    }
+
+    // attach to new
+    objectParents.set(value, parentPath)
+    if (parentPath?.parent) {
+      addObjectChild(parentPath.parent, value)
+    }
+    reportParentPathChanged(value)
+
+    if (valueIsModel) {
+      const newRoot = fastGetRoot(value, false)
+      const newRootStore = fastIsRootStoreNoAtom(newRoot) ? newRoot : undefined
+
+      // invoke model root store events
+      if (oldRootStore !== newRootStore && (oldRootStore || newRootStore)) {
+        enqueuePendingAction(() => {
+          if (oldRootStore) {
+            detachFromRootStore(value)
+          }
+          if (newRootStore) {
+            attachToRootStore(newRootStore, value)
+          }
+        })
+      }
+    }
+
+    postUntweaker?.()
+
+    return value
+  }
+)

package/src/parent/walkTree.ts

@@ -1,4 +1,4 @@
-import { computed, IComputedValue } from "mobx"
+import { computed, type IComputedValue } from "mobx"
 import { assertTweakedObject } from "../tweaker/core"
 import { getObjectChildren } from "./coreObjectChildren"
 

package/src/patch/applyPatches.ts

@@ -1,187 +1,187 @@
-import { remove } from "mobx"
-import { BuiltInAction } from "../action/builtInActions"
-import { ActionContextActionType } from "../action/context"
-import { wrapInAction } from "../action/wrapInAction"
-import { modelToDataNode } from "../parent/core"
-import type { PathElement } from "../parent/pathTypes"
-import type { Patch } from "../patch/Patch"
-import { reconcileSnapshot } from "../snapshot/reconcileSnapshot"
-import { assertTweakedObject } from "../tweaker/core"
-import { failure, inDevMode, isArray, lazy } from "../utils"
-import { runWithErrorDiagnosticsContext, withErrorPathSegments } from "../utils/errorDiagnostics"
-import { ModelPool } from "../utils/ModelPool"
-import { setIfDifferent } from "../utils/setIfDifferent"
-
-/**
- * Applies the given patches to the given target object.
- *
- * @param node Target object.
- * @param patches List of patches to apply.
- * @param reverse Whether patches are applied in reverse order.
- */
-export function applyPatches(
-  node: object,
-  patches: ReadonlyArray<Patch> | ReadonlyArray<ReadonlyArray<Patch>>,
-  reverse = false
-): void {
-  assertTweakedObject(node, "node")
-
-  if (patches.length <= 0) {
-    return
-  }
-
-  wrappedInternalApplyPatches().call(node, patches, reverse)
-}
-
-/**
- * @internal
- */
-export function internalApplyPatches(
-  this: object,
-  patches: ReadonlyArray<Patch> | ReadonlyArray<ReadonlyArray<Patch>>,
-  reverse = false
-): void {
-  runWithErrorDiagnosticsContext(() => {
-    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)
-          }
-        } 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 {
-          applySinglePatchWithPath(obj, p as Patch, modelPool)
-        }
-      }
-    }
-  })
-}
-
-const wrappedInternalApplyPatches = lazy(() =>
-  wrapInAction({
-    nameOrNameFn: BuiltInAction.ApplyPatches,
-    fn: internalApplyPatches,
-    actionType: ActionContextActionType.Sync,
-  })
-)
-
-function applySinglePatch(obj: object, patch: Patch, modelPool: ModelPool): void {
-  const { target, prop } = pathArrayToObjectAndProp(obj, patch.path)
-
-  if (isArray(target)) {
-    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
-          target.push(newValue)
-        } else {
-          target.splice(index, 0, newValue)
-        }
-        break
-      }
-
-      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)
-        }
-        break
-      }
-
-      default:
-        throw failure(`unsupported patch operation: ${(patch as any).op}`)
-    }
-  } else {
-    switch (patch.op) {
-      case "add": {
-        // reconcile from the pool if possible
-        const newValue = reconcileSnapshot(undefined, patch.value, modelPool, target)
-        setIfDifferent(target, prop!, newValue)
-        break
-      }
-
-      case "remove": {
-        // no reconciliation, removing
-        remove(target, prop)
-        break
-      }
-
-      case "replace": {
-        // try to reconcile
-        // we don't need to tweak the pool since reconcileSnapshot will do that for us
-        const newValue = reconcileSnapshot(target[prop!], patch.value, modelPool, target)
-        setIfDifferent(target, prop!, newValue)
-        break
-      }
-
-      default:
-        throw failure(`unsupported patch operation: ${(patch as any).op}`)
-    }
-  }
-}
-
-function applySinglePatchWithPath(obj: object, patch: Patch, modelPool: ModelPool): void {
-  withErrorPathSegments(patch.path, () => {
-    applySinglePatch(obj, patch, modelPool)
-  })
-}
-
-function pathArrayToObjectAndProp(
-  obj: object,
-  path: Patch["path"]
-): { target: any; prop?: PathElement } {
-  if (inDevMode) {
-    if (!isArray(path)) {
-      throw failure(`invalid path: ${path}`)
-    }
-  }
-
-  let target: any = modelToDataNode(obj)
-
-  if (path.length === 0) {
-    return {
-      target,
-    }
-  }
-
-  for (let i = 0; i <= path.length - 2; i++) {
-    target = modelToDataNode(target[path[i]])
-  }
-
-  return {
-    target,
-    prop: path[path.length - 1],
-  }
-}
+import { remove } from "mobx"
+import { BuiltInAction } from "../action/builtInActions"
+import { ActionContextActionType } from "../action/context"
+import { wrapInAction } from "../action/wrapInAction"
+import { modelToDataNode } from "../parent/core"
+import type { PathElement } from "../parent/pathTypes"
+import type { Patch } from "../patch/Patch"
+import { reconcileSnapshot } from "../snapshot/reconcileSnapshot"
+import { assertTweakedObject } from "../tweaker/core"
+import { failure, inDevMode, isArray, lazy } from "../utils"
+import { runWithErrorDiagnosticsContext, withErrorPathSegments } from "../utils/errorDiagnostics"
+import { ModelPool } from "../utils/ModelPool"
+import { setIfDifferent } from "../utils/setIfDifferent"
+
+/**
+ * Applies the given patches to the given target object.
+ *
+ * @param node Target object.
+ * @param patches List of patches to apply.
+ * @param reverse Whether patches are applied in reverse order.
+ */
+export function applyPatches(
+  node: object,
+  patches: ReadonlyArray<Patch> | ReadonlyArray<ReadonlyArray<Patch>>,
+  reverse = false
+): void {
+  assertTweakedObject(node, "node")
+
+  if (patches.length <= 0) {
+    return
+  }
+
+  wrappedInternalApplyPatches().call(node, patches, reverse)
+}
+
+/**
+ * @internal
+ */
+export function internalApplyPatches(
+  this: object,
+  patches: ReadonlyArray<Patch> | ReadonlyArray<ReadonlyArray<Patch>>,
+  reverse = false
+): void {
+  runWithErrorDiagnosticsContext(() => {
+    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)
+          }
+        } 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 {
+          applySinglePatchWithPath(obj, p as Patch, modelPool)
+        }
+      }
+    }
+  })
+}
+
+const wrappedInternalApplyPatches = lazy(() =>
+  wrapInAction({
+    nameOrNameFn: BuiltInAction.ApplyPatches,
+    fn: internalApplyPatches,
+    actionType: ActionContextActionType.Sync,
+  })
+)
+
+function applySinglePatch(obj: object, patch: Patch, modelPool: ModelPool): void {
+  const { target, prop } = pathArrayToObjectAndProp(obj, patch.path)
+
+  if (isArray(target)) {
+    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
+          target.push(newValue)
+        } else {
+          target.splice(index, 0, newValue)
+        }
+        break
+      }
+
+      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)
+        }
+        break
+      }
+
+      default:
+        throw failure(`unsupported patch operation: ${(patch as any).op}`)
+    }
+  } else {
+    switch (patch.op) {
+      case "add": {
+        // reconcile from the pool if possible
+        const newValue = reconcileSnapshot(undefined, patch.value, modelPool, target)
+        setIfDifferent(target, prop!, newValue)
+        break
+      }
+
+      case "remove": {
+        // no reconciliation, removing
+        remove(target, prop)
+        break
+      }
+
+      case "replace": {
+        // try to reconcile
+        // we don't need to tweak the pool since reconcileSnapshot will do that for us
+        const newValue = reconcileSnapshot(target[prop!], patch.value, modelPool, target)
+        setIfDifferent(target, prop!, newValue)
+        break
+      }
+
+      default:
+        throw failure(`unsupported patch operation: ${(patch as any).op}`)
+    }
+  }
+}
+
+function applySinglePatchWithPath(obj: object, patch: Patch, modelPool: ModelPool): void {
+  withErrorPathSegments(patch.path, () => {
+    applySinglePatch(obj, patch, modelPool)
+  })
+}
+
+function pathArrayToObjectAndProp(
+  obj: object,
+  path: Patch["path"]
+): { target: any; prop?: PathElement } {
+  if (inDevMode) {
+    if (!isArray(path)) {
+      throw failure(`invalid path: ${path}`)
+    }
+  }
+
+  let target: any = modelToDataNode(obj)
+
+  if (path.length === 0) {
+    return {
+      target,
+    }
+  }
+
+  for (let i = 0; i <= path.length - 2; i++) {
+    target = modelToDataNode(target[path[i]])
+  }
+
+  return {
+    target,
+    prop: path[path.length - 1],
+  }
+}