mobx-keystone 1.22.0 → 1.24.0

package/src/snapshot/reconcilePlainObjectSnapshot.ts

@@ -1,5 +1,8 @@
 import { isObservableObject, remove } from "mobx"
-import { runTypeCheckingAfterChange } from "../tweaker/typeChecking"
+import {
+  isTypeCheckingAfterChangeEnabled,
+  runTypeCheckingAfterChange,
+} from "../tweaker/typeChecking"
 import { withoutTypeChecking } from "../tweaker/withoutTypeChecking"
 import { isPlainObject } from "../utils"
 import { withErrorPathSegment } from "../utils/errorDiagnostics"
@@ -23,7 +26,8 @@ function reconcilePlainObjectSnapshot(
   }
 
   const plainObj = value
-  const snapshotBeforeChanges = getSnapshot(plainObj)
+  const typeCheckingAfterChangeEnabled = isTypeCheckingAfterChangeEnabled()
+  const snapshotBeforeChanges = typeCheckingAfterChangeEnabled ? getSnapshot(plainObj) : undefined
 
   withoutTypeChecking(() => {
     // remove excess props
@@ -54,7 +58,9 @@ function reconcilePlainObjectSnapshot(
     }
   })
 
-  runTypeCheckingAfterChange(plainObj, undefined, snapshotBeforeChanges)
+  if (typeCheckingAfterChangeEnabled) {
+    runTypeCheckingAfterChange(plainObj, undefined, snapshotBeforeChanges)
+  }
 
   return plainObj
 }

package/src/treeUtils/draft.ts

@@ -1,4 +1,3 @@
-import { action, computed } from "mobx"
 import { pathToTargetPathIds } from "../actionMiddlewares/utils"
 import { resolvePath, resolvePathCheckingIds, skipIdChecking } from "../parent/path"
 import type { Path } from "../parent/pathTypes"
@@ -7,7 +6,7 @@ import { applySnapshot } from "../snapshot/applySnapshot"
 import { fromSnapshot } from "../snapshot/fromSnapshot"
 import { getSnapshot } from "../snapshot/getSnapshot"
 import { assertTweakedObject } from "../tweaker/core"
-import { failure } from "../utils"
+import { failure, mobxAction, mobxComputed } from "../utils"
 import { deepEquals } from "./deepEquals"
 
 /**
@@ -25,7 +24,7 @@ export class Draft<T extends object> {
   /**
    * Commits current draft changes to the original object.
    */
-  @action
+  @mobxAction
   commit(): void {
     applySnapshot(this.originalData, getSnapshot(this.data))
   }
@@ -37,7 +36,7 @@ export class Draft<T extends object> {
    *
    * @param path Path to commit.
    */
-  @action
+  @mobxAction
   commitByPath(path: Path): void {
     const draftTarget = resolvePath(this.data, path)
     if (!draftTarget.resolved) {
@@ -63,7 +62,7 @@ export class Draft<T extends object> {
   /**
    * Resets the draft to be an exact copy of the current state of the original object.
    */
-  @action
+  @mobxAction
   reset(): void {
     applySnapshot(this.data, this.originalSnapshot)
   }
@@ -75,7 +74,7 @@ export class Draft<T extends object> {
    *
    * @param path Path to reset.
    */
-  @action
+  @mobxAction
   resetByPath(path: Path): void {
     const originalTarget = resolvePath(this.originalData, path)
     if (!originalTarget.resolved) {
@@ -101,7 +100,7 @@ export class Draft<T extends object> {
   /**
    * Returns `true` if the draft has changed compared to the original object, `false` otherwise.
    */
-  @computed
+  @mobxComputed
   get isDirty(): boolean {
     return !deepEquals(getSnapshot(this.data), this.originalSnapshot)
   }
@@ -135,7 +134,7 @@ export class Draft<T extends object> {
    */
   readonly originalData: T
 
-  @computed
+  @mobxComputed
   private get originalSnapshot() {
     return getSnapshot(this.originalData)
   }

package/src/tweaker/core.ts

@@ -1,20 +1,45 @@
 import { runInAction } from "mobx"
-import { dataObjectParent } from "../parent/core"
+import { hasDataObjectParent } from "../parent/core"
 import { failure, isPrimitive } from "../utils"
+import { treeNodeMetadata } from "./treeNodeMetadata"
+
+type Untweaker = (() => void) & {
+  [secondaryUntweakerSymbol]?: () => void
+}
+
+const secondaryUntweakerSymbol = Symbol("secondaryUntweaker")
 
 /**
+ * Stores two existing cleanup functions without allocating a third function to
+ * close over them. The primary function is internal and never exposed.
+ *
  * @internal
  */
-export const tweakedObjects = new WeakMap<object, undefined | (() => void)>()
+export function setTweakedObjectUntweakers(
+  value: object,
+  primaryUntweaker: Untweaker,
+  secondaryUntweaker: () => void
+): void {
+  primaryUntweaker[secondaryUntweakerSymbol] = secondaryUntweaker
+  treeNodeMetadata.get(value)!.untweaker = primaryUntweaker
+}
 
 /**
  * @internal
  */
 export function isTweakedObject(value: unknown, canBeDataObject: boolean): value is object {
-  if (!canBeDataObject && dataObjectParent.has(value as object)) {
+  if (!canBeDataObject && hasDataObjectParent(value as object)) {
     return false
   }
-  return tweakedObjects.has(value as object)
+  return treeNodeMetadata.get(value as object)?.tweaked === true
+}
+
+/**
+ * @internal
+ */
+export function runTweakedObjectUntweakers(untweaker: Untweaker): void {
+  untweaker()
+  untweaker[secondaryUntweakerSymbol]?.()
 }
 
 /**
@@ -35,7 +60,7 @@ export function assertTweakedObject(
   argName: string,
   canBeDataObject = false
 ): asserts treeNode is object {
-  if (!canBeDataObject && dataObjectParent.has(treeNode as object)) {
+  if (!canBeDataObject && hasDataObjectParent(treeNode as object)) {
     throw failure(`${argName} must be the model object instance instead of the '$' sub-object`)
   }
   if (isPrimitive(treeNode) || !isTweakedObject(treeNode, true)) {

package/src/tweaker/treeNodeMetadata.ts

@@ -0,0 +1,38 @@
+import type { ObjectChildrenData } from "../parent/coreObjectChildren"
+import type { ParentPath } from "../parent/path"
+import type { SnapshotData } from "../snapshot/internal"
+
+/** @internal */
+export interface TreeNodeMetadata {
+  tweaked: boolean
+  untweaker: (() => void) | undefined
+  parentPath: ParentPath<object> | undefined
+  dataObjectParent: object | undefined
+  objectChildren: ObjectChildrenData | undefined
+  snapshot: SnapshotData | undefined
+}
+
+/** @internal */
+export const treeNodeMetadata = new WeakMap<object, TreeNodeMetadata>()
+
+/** @internal */
+export function getOrCreateTreeNodeMetadata(value: object): TreeNodeMetadata {
+  let metadata = treeNodeMetadata.get(value)
+  if (!metadata) {
+    metadata = {
+      tweaked: false,
+      untweaker: undefined,
+      parentPath: undefined,
+      dataObjectParent: undefined,
+      objectChildren: undefined,
+      snapshot: undefined,
+    }
+    treeNodeMetadata.set(value, metadata)
+  }
+  return metadata
+}
+
+/** @internal */
+export function markAsTweakedObject(value: object): void {
+  getOrCreateTreeNodeMetadata(value).tweaked = true
+}

package/src/tweaker/tweak.ts

@@ -8,8 +8,9 @@ import { unsetInternalSnapshot } from "../snapshot/internal"
 import type { AnyStandardType, TypeToData } from "../types/schemas"
 import { typeCheck } from "../types/typeCheck"
 import { failure, inDevMode, isMap, isObject, isPrimitive, isSet } from "../utils"
-import { isTweakedObject, tweakedObjects } from "./core"
+import { isTweakedObject, runTweakedObjectUntweakers } from "./core"
 import { registerDefaultTweakers } from "./registerDefaultTweakers"
+import { treeNodeMetadata } from "./treeNodeMetadata"
 
 /**
  * Turns an object (array, plain object) into a tree node,
@@ -153,7 +154,8 @@ export function tryUntweak(value: any): (() => void) | undefined {
     }
   }
 
-  const untweaker = tweakedObjects.get(value)
+  const metadata = treeNodeMetadata.get(value)
+  const untweaker = metadata?.untweaker
   if (!untweaker) {
     return undefined
   }
@@ -176,9 +178,18 @@ export function tryUntweak(value: any): (() => void) | undefined {
 
   return () => {
     // post-untweaking, call the untweaker
-    untweaker()
+    runTweakedObjectUntweakers(untweaker)
 
-    tweakedObjects.delete(value)
+    // Match the former independent-map ordering: the node stops being tweaked
+    // before its snapshot is unset, but the shared record must stay alive until
+    // snapshot cleanup has consumed it.
+    metadata.tweaked = false
+    metadata.untweaker = undefined
     unsetInternalSnapshot(value)
+    // These associations previously lived in independent WeakMaps and remain
+    // valid across untweak/retweak, so keep their shared record when present.
+    if (metadata.dataObjectParent === undefined && metadata.objectChildren === undefined) {
+      treeNodeMetadata.delete(value)
+    }
   }
 }