mobx-keystone 2.1.0 → 2.2.0

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

@@ -220,29 +220,16 @@ export function resolveId<T extends object>(
   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
 }
 
 /**

package/src/rootStore/rootStore.ts

@@ -84,9 +84,7 @@ export function isRootStore(node: object): boolean {
   assertTweakedObject(node, "node")
 
   const entry = getOrCreateRootStoreEntry(node)
-  if (!entry.atom) {
-    entry.atom = createAtom("rootStore")
-  }
+  entry.atom ??= createAtom("rootStore")
   entry.atom.reportObserved()
   return entry.is
 }

package/src/snapshot/SnapshotOf.ts

@@ -13,10 +13,8 @@ export type FrozenData<D> = {
 
 // snapshot out
 
-// infer is there just to cache type generation
-
 export type SnapshotOutOfObject<T> = {
-  [k in keyof T]: SnapshotOutOf<T[k]> extends infer R ? R : never
+  [k in keyof T]: SnapshotOutOf<T[k]>
 }
 
 export type SnapshotOutOfModel<M extends AnyModel> = ModelToSnapshot<M>
@@ -35,33 +33,22 @@ export interface SnapshotOutOfArraySet<V> {
   [modelIdKey]: string
 }
 
-export type SnapshotOutOf<T> =
-  T extends ObjectMap<infer V>
-    ? SnapshotOutOfObjectMap<V> extends infer R
-      ? R
-      : never
-    : T extends ArraySet<infer V>
-      ? SnapshotOutOfArraySet<V> extends infer R
-        ? R
-        : never
-      : T extends AnyModel
-        ? SnapshotOutOfModel<T> extends infer R
-          ? R
-          : never
-        : T extends Frozen<any>
-          ? SnapshotOutOfFrozen<T> extends infer R
-            ? R
-            : never
-          : T extends object
-            ? SnapshotOutOfObject<T> extends infer R
-              ? R
-              : never
-            : T
+export type SnapshotOutOf<T> = T extends object
+  ? T extends AnyModel
+    ? T extends ObjectMap<infer V>
+      ? SnapshotOutOfObjectMap<V>
+      : T extends ArraySet<infer V>
+        ? SnapshotOutOfArraySet<V>
+        : SnapshotOutOfModel<T>
+    : T extends Frozen<any>
+      ? SnapshotOutOfFrozen<T>
+      : SnapshotOutOfObject<T>
+  : T
 
 // snapshot in
 
 export type SnapshotInOfObject<T> = {
-  [k in keyof T]: SnapshotInOf<T[k]> extends infer R ? R : never
+  [k in keyof T]: SnapshotInOf<T[k]>
 }
 
 export type SnapshotInOfModel<M extends AnyModel> = ModelFromSnapshot<M>
@@ -80,25 +67,14 @@ export interface SnapshotInOfArraySet<V> {
   [modelIdKey]: string
 }
 
-export type SnapshotInOf<T> =
-  T extends ObjectMap<infer V>
-    ? SnapshotInOfObjectMap<V> extends infer R
-      ? R
-      : never
-    : T extends ArraySet<infer V>
-      ? SnapshotInOfArraySet<V> extends infer R
-        ? R
-        : never
-      : T extends AnyModel
-        ? SnapshotInOfModel<T> extends infer R
-          ? R
-          : never
-        : T extends Frozen<any>
-          ? SnapshotInOfFrozen<T> extends infer R
-            ? R
-            : never
-          : T extends object
-            ? SnapshotInOfObject<T> extends infer R
-              ? R
-              : never
-            : T
+export type SnapshotInOf<T> = T extends object
+  ? T extends AnyModel
+    ? T extends ObjectMap<infer V>
+      ? SnapshotInOfObjectMap<V>
+      : T extends ArraySet<infer V>
+        ? SnapshotInOfArraySet<V>
+        : SnapshotInOfModel<T>
+    : T extends Frozen<any>
+      ? SnapshotInOfFrozen<T>
+      : SnapshotInOfObject<T>
+  : T

package/src/snapshot/applySnapshot.ts

@@ -33,7 +33,7 @@ import { SnapshotProcessingError } from "./SnapshotProcessingError"
  */
 export function applySnapshot<T extends object>(
   node: T,
-  snapshot: SnapshotInOf<T> | SnapshotOutOf<T>
+  snapshot: NoInfer<SnapshotInOf<T> | SnapshotOutOf<T>>
 ): void
 
 export function applySnapshot(node: object, snapshot: unknown): void {

package/src/snapshot/fromSnapshot.ts

@@ -1,8 +1,9 @@
 import { action, observable } from "mobx"
 import type { AnyModel } from "../model/BaseModel"
 import { isReservedModelKey } from "../model/metadata"
+import { isTweakedObject } from "../tweaker/core"
 import { resolveStandardTypeNoThrow, resolveTypeChecker } from "../types/resolveTypeChecker"
-import type { AnyType, TypeToData, TypeToSnapshotIn } from "../types/schemas"
+import type { AnyType, TypeToData, TypeToSnapshotIn, TypeToSnapshotOut } from "../types/schemas"
 import { isLateTypeChecker, TypeChecker } from "../types/TypeChecker"
 import { resolveCodecSupport } from "../types/utility/typesCodec"
 import { isMap, isPrimitive, isSet, nodeObservableOptions, setProtoProp } from "../utils"
@@ -60,7 +61,7 @@ export interface FromSnapshotContext {
  */
 export function fromSnapshot<TType extends AnyType>(
   type: TType,
-  snapshot: TypeToSnapshotIn<TType>,
+  snapshot: NoInfer<TypeToSnapshotIn<TType> | TypeToSnapshotOut<TType>>,
   options?: Partial<FromSnapshotOptions>
 ): TypeToData<TType>
 
@@ -122,7 +123,6 @@ const fromSnapshotAction = action(
   ): T => {
     const opts = {
       generateNewIds: false,
-      overrideRootModelId: undefined,
       ...options,
     }
 
@@ -172,6 +172,13 @@ export function internalFromSnapshot<T>(
     })
   }
 
+  if (isTweakedObject(sn, true)) {
+    throw new SnapshotProcessingError({
+      message: "a snapshot must not contain tree nodes (use getSnapshot to get their snapshots)",
+      actualSnapshot: sn,
+    })
+  }
+
   throw new SnapshotProcessingError({
     message: "unsupported snapshot",
     actualSnapshot: sn,

package/src/snapshot/getSnapshot.ts

@@ -23,7 +23,7 @@ import type { SnapshotOutOf } from "./SnapshotOf"
  */
 export function getSnapshot<T extends AnyType>(
   type: T,
-  nodeOrPrimitive: TypeToData<T>
+  nodeOrPrimitive: NoInfer<TypeToData<T>>
 ): TypeToSnapshotOut<T>
 
 /**

package/src/snapshot/internal.ts

@@ -113,8 +113,6 @@ export const setNewInternalSnapshot = action(
     }
 
     getOrCreateTreeNodeMetadata(value).snapshot = sn
-
-    sn.atom?.reportChanged()
   }
 )
 

package/src/snapshot/reconcileModelSnapshot.ts

@@ -156,7 +156,9 @@ function reconcileModelSnapshot(
         if (!isReservedModelKey(k)) {
           const v = processedSn[k]
 
-          const oldValue = data[k]
+          // an inherited member such as `toString` is no old value (but `__proto__`
+          // still reads the prototype, which is rejected as it is no tree node)
+          const oldValue = k === "__proto__" || hasOwnProp(data, k) ? data[k] : undefined
           // Non-null primitives need neither reconciliation nor detachment.
           // Nullish values must still pass through default handling below.
           if (v != null && isPrimitive(v)) {
@@ -216,10 +218,10 @@ function snapshotSlotsAreEqual(
   for (let i = 0; i < currentKeys.length; i++) {
     const key = currentKeys[i]
     // a matching key at the same index proves the key is an own property of
-    // the incoming snapshot without an Object.hasOwn call; canonical snapshots
+    // the incoming snapshot without an own-property check; canonical snapshots
     // keep key order, so the fallback is rare (never trust inherited values,
     // e.g. a crafted __proto__ chain, without an own-property proof)
-    if (incomingKeys[i] !== key && !Object.hasOwn(incomingSnapshot, key)) {
+    if (incomingKeys[i] !== key && !hasOwnProp(incomingSnapshot, key)) {
       return false
     }
     if (currentSnapshot[key] !== incomingSnapshot[key]) {

package/src/snapshot/reconcilePlainObjectSnapshot.ts

@@ -48,7 +48,9 @@ function reconcilePlainObjectSnapshot(
       const k = snKeys[i]
       const v = sn[k]
 
-      const oldValue = plainObj[k]
+      // an inherited member such as `toString` is no old value (but `__proto__`
+      // still reads the prototype, which is rejected as it is no tree node)
+      const oldValue = k === "__proto__" || hasOwnProp(plainObj, k) ? plainObj[k] : undefined
       const newValue = withErrorPathSegment(k, () =>
         reconcileSnapshot(oldValue, v, modelPool, plainObj)
       )

package/src/treeUtils/draft.ts

@@ -6,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, mobxAction, mobxComputed } from "../utils"
+import { failure, getMobxVersion, makeObservableCompat, mobxAction, mobxComputed } from "../utils"
 import { deepEquals } from "./deepEquals"
 
 /**
@@ -157,6 +157,11 @@ export class Draft<T extends object> {
     assertTweakedObject(original, "original")
 
     this.originalData = original
+
+    if (getMobxVersion() >= 6) {
+      makeObservableCompat(this)
+    }
+
     this.data = fromSnapshot(this.originalSnapshot, { generateNewIds: false })
   }
 }

package/src/treeUtils/sandbox.ts

@@ -233,9 +233,11 @@ export class SandboxManager {
           // see the reverted intermediate state.
           runInAction(() => {
             this.allowWrite(() => {
-              for (let i = events.length - 1; i >= 0; i--) {
-                applyPatches(this.subtreeRootClone, events[i].inversePatches, true)
-              }
+              applyPatches(
+                this.subtreeRootClone,
+                events.map((event) => event.inversePatches),
+                true
+              )
             })
             applyPatches(
               this.subtreeRoot,
@@ -249,10 +251,11 @@ export class SandboxManager {
             const wasRecording = recorder.recording
             recorder.recording = false
             try {
-              let i = recorder.events.length
-              while (i-- > numRecorderEvents) {
-                applyPatches(this.subtreeRootClone, recorder.events[i].inversePatches, true)
-              }
+              applyPatches(
+                this.subtreeRootClone,
+                recorder.events.slice(numRecorderEvents).map((event) => event.inversePatches),
+                true
+              )
               recorder.events.splice(numRecorderEvents)
             } finally {
               recorder.recording = wasRecording

package/src/tweaker/tweakArray.ts

@@ -289,7 +289,6 @@ function arrayDidChangeUpdate(
 ) {
   const k = change.index
   const val = change.newValue
-  const oldVal = oldSnapshot[k]
   let newVal: any
   if (isPrimitive(val)) {
     newVal = val
@@ -299,15 +298,14 @@ function arrayDidChangeUpdate(
   }
   const mutate = mutateSet.bind(undefined, k, newVal)
 
-  if (shouldEmitPatches || shouldBuildInversePatches) {
+  if (shouldBuildInversePatches) {
     const path = [k]
     const patches = shouldEmitPatches
       ? [{ op: "replace" as const, path, value: freezeInternalSnapshot(newVal) }]
       : undefined
-    const invPatches = shouldBuildInversePatches
-      ? [{ op: "replace" as const, path, value: freezeInternalSnapshot(oldVal) }]
-      : undefined
-    patchRecorder.record(patches, invPatches)
+    patchRecorder.record(patches, [
+      { op: "replace" as const, path, value: freezeInternalSnapshot(oldSnapshot[k]) },
+    ])
   }
   return mutate
 }
@@ -335,17 +333,16 @@ function arrayDidChangeSplice(
 
   const mutate = mutateSplice.bind(undefined, index, removedCount, addedItems)
 
-  // With neither patch listeners nor type checking, there is no inverse-patch
-  // data to build. The snapshot mutation above is all the post-change work we
-  // need to retain.
-  if (!shouldEmitPatches && !shouldBuildInversePatches) {
+  // With neither patch listeners nor type checking, there is no patch data to
+  // build. The snapshot mutation above is all the post-change work we need.
+  if (!shouldBuildInversePatches) {
     return mutate
   }
 
   const oldLen = oldSnapshot.length
 
   const patches: Patch[] | undefined = shouldEmitPatches ? [] : undefined
-  const invPatches: Patch[] | undefined = shouldBuildInversePatches ? [] : undefined
+  const invPatches: Patch[] = []
 
   // optimization: if we add as many as we remove then remove/readd instead
 
@@ -357,13 +354,13 @@ function arrayDidChangeSplice(
 
   if (addedCount === removedCount) {
     const readdPatches: Patch[] | undefined = shouldEmitPatches ? [] : undefined
-    const readdInvPatches: Patch[] | undefined = shouldBuildInversePatches ? [] : undefined
+    const readdInvPatches: Patch[] = []
     let removed = 0
 
     for (let i = 0; i < addedCount; i++) {
       const realIndex = index + i
 
-      const newVal = getValueAfterSplice(oldSnapshot, realIndex, index, removedCount, addedItems)
+      const newVal = addedItems[i]
       const oldVal = oldSnapshot[realIndex]
 
       if (newVal !== oldVal) {
@@ -372,7 +369,7 @@ function arrayDidChangeSplice(
           op: "remove",
           path: removePath,
         })
-        invPatches?.push({
+        invPatches.push({
           op: "remove",
           path: removePath,
         })
@@ -386,7 +383,7 @@ function arrayDidChangeSplice(
           value: freezeInternalSnapshot(newVal),
         })
 
-        readdInvPatches?.push({
+        readdInvPatches.push({
           op: "add",
           path: readdPath,
           value: freezeInternalSnapshot(oldVal),
@@ -394,17 +391,13 @@ function arrayDidChangeSplice(
       }
     }
 
-    if (patches && readdPatches && readdPatches.length > 0) {
+    if (patches && readdPatches) {
       for (const patch of readdPatches) patches.push(patch)
     }
-    if (invPatches && readdInvPatches && readdInvPatches.length > 0) {
-      for (const patch of readdInvPatches) invPatches.push(patch)
-    }
+    for (const patch of readdInvPatches) invPatches.push(patch)
     // We need to reverse once since inverse patches are applied in reverse.
     // Repeated unshift calls here would make a large splice quadratic.
-    if (invPatches && invPatches.length > 0) {
-      invPatches.reverse()
-    }
+    invPatches.reverse()
   } else {
     const interimLen = oldLen - removedCount
 
@@ -433,7 +426,7 @@ function arrayDidChangeSplice(
         }
 
         // add 0, 1, 2... since inverse patches are applied in reverse
-        invPatches?.push({
+        invPatches.push({
           op: "add",
           path,
           value: freezeInternalSnapshot(oldSnapshot[realIndex]),
@@ -446,7 +439,7 @@ function arrayDidChangeSplice(
       // optimization, for inverse patches, when adding from the end set the length to restore instead
       const restoreUsingSetLength = index >= interimLen
       if (restoreUsingSetLength) {
-        invPatches?.push({
+        invPatches.push({
           op: "replace",
           path: ["length"],
           value: interimLen,
@@ -461,14 +454,12 @@ function arrayDidChangeSplice(
         patches?.push({
           op: "add",
           path,
-          value: freezeInternalSnapshot(
-            getValueAfterSplice(oldSnapshot, realIndex, index, removedCount, addedItems)
-          ),
+          value: freezeInternalSnapshot(addedItems[i]),
         })
 
         // remove ...2, 1, 0 since inverse patches are applied in reverse
         if (!restoreUsingSetLength) {
-          invPatches?.push({
+          invPatches.push({
             op: "remove",
             path,
           })
@@ -477,9 +468,7 @@ function arrayDidChangeSplice(
     }
   }
 
-  if (patches || invPatches) {
-    patchRecorder.record(patches, invPatches)
-  }
+  patchRecorder.record(patches, invPatches)
   return mutate
 }
 
@@ -676,22 +665,3 @@ class ObservableArrayReplacementQueue {
     }
   }
 }
-
-function getValueAfterSplice<T>(
-  array: readonly T[],
-  i: number,
-  index: number,
-  remove: number,
-  addedItems: readonly T[]
-) {
-  const base = i - index
-  if (base < 0) {
-    return array[i]
-  }
-
-  if (base < addedItems.length) {
-    return addedItems[base]
-  }
-
-  return array[i - addedItems.length + remove]
-}

package/src/tweaker/tweakPlainObject.ts

@@ -295,16 +295,14 @@ function objectDidChangeRemove(
   shouldBuildInversePatches: boolean
 ) {
   const k = change.name
-  const oldVal = oldUntransformedSn[k]
   const mutate = mutateDelete.bind(undefined, k)
 
-  if (shouldEmitPatches || shouldBuildInversePatches) {
+  if (shouldBuildInversePatches) {
     const path = [k as string]
     const patches = shouldEmitPatches ? [{ op: "remove" as const, path }] : undefined
-    const invPatches = shouldBuildInversePatches
-      ? [{ op: "add" as const, path, value: freezeInternalSnapshot(oldVal) }]
-      : undefined
-    patchRecorder.record(patches, invPatches)
+    patchRecorder.record(patches, [
+      { op: "add" as const, path, value: freezeInternalSnapshot(oldUntransformedSn[k]) },
+    ])
   }
   return mutate
 }
@@ -318,8 +316,6 @@ function objectDidChangeAddOrUpdate(
   const k = change.name
   const val = change.newValue
 
-  const oldVal = oldUntransformedSn[k]
-
   let newVal: any
   if (isPrimitive(val)) {
     newVal = val
@@ -330,22 +326,20 @@ function objectDidChangeAddOrUpdate(
 
   const mutate = mutateSet.bind(undefined, k, newVal)
 
-  if (shouldEmitPatches || shouldBuildInversePatches) {
+  if (shouldBuildInversePatches) {
     const path = [k as string]
     if (change.type === "add") {
       const patches = shouldEmitPatches
         ? [{ op: "add" as const, path, value: freezeInternalSnapshot(newVal) }]
         : undefined
-      const invPatches = shouldBuildInversePatches ? [{ op: "remove" as const, path }] : undefined
-      patchRecorder.record(patches, invPatches)
+      patchRecorder.record(patches, [{ op: "remove" as const, path }])
     } else {
       const patches = shouldEmitPatches
         ? [{ op: "replace" as const, path, value: freezeInternalSnapshot(newVal) }]
         : undefined
-      const invPatches = shouldBuildInversePatches
-        ? [{ op: "replace" as const, path, value: freezeInternalSnapshot(oldVal) }]
-        : undefined
-      patchRecorder.record(patches, invPatches)
+      patchRecorder.record(patches, [
+        { op: "replace" as const, path, value: freezeInternalSnapshot(oldUntransformedSn[k]) },
+      ])
     }
   }
 

package/src/types/arrayBased/typesArray.ts

@@ -50,6 +50,16 @@ export function typesArray<T extends AnyType>(itemType: T): ArrayType<T[]> {
       }
     )
 
+    const processorPlan = snapshotProcessorPlan(
+      () => [itemChecker],
+      ([itemProcessor]) =>
+        itemProcessor
+          ? (sn: unknown[]) => {
+              return sn.map((item, i) => withErrorPathSegment(i, () => itemProcessor(item)))
+            }
+          : undefined
+    )
+
     const thisTc: TypeChecker = new TypeChecker(
       TypeCheckerBaseType.Array,
 
@@ -89,25 +99,9 @@ export function typesArray<T extends AnyType>(itemType: T): ArrayType<T[]> {
         return thisTc
       },
 
-      snapshotProcessorPlan(
-        () => [itemChecker],
-        ([itemProcessor]) =>
-          itemProcessor
-            ? (sn: unknown[]) => {
-                return sn.map((item, i) => withErrorPathSegment(i, () => itemProcessor(item)))
-              }
-            : undefined
-      ),
-
-      snapshotProcessorPlan(
-        () => [itemChecker],
-        ([itemProcessor]) =>
-          itemProcessor
-            ? (sn: unknown[]) => {
-                return sn.map((item, i) => withErrorPathSegment(i, () => itemProcessor(item)))
-              }
-            : undefined
-      )
+      processorPlan,
+
+      processorPlan
     )
 
     return thisTc