mobx-keystone 1.25.0 → 2.1.0

package/src/actionMiddlewares/undoMiddleware.ts

@@ -1,12 +1,15 @@
 import type { ActionMiddlewareDisposer } from "../action/middleware"
 import { modelAction } from "../action/modelAction"
+import { type Frozen, FrozenCheckMode, frozen, isFrozenSnapshot, toFrozenSnapshot } from "../frozen"
 import { Model } from "../model/Model"
 import { model } from "../modelShared/modelDecorator"
 import { fastGetRootPath } from "../parent/path"
 import type { Path } from "../parent/pathTypes"
 import { applyPatches, type Patch, type PatchRecorder, patchRecorder } from "../patch"
+import type { FrozenData } from "../snapshot"
 import { assertTweakedObject } from "../tweaker/core"
 import { typesArray } from "../types/arrayBased/typesArray"
+import { typesFrozen } from "../types/objectBased/typesObject"
 import { tProp } from "../types/tProp"
 import { typesUnchecked } from "../types/utility/typesUnchecked"
 import {
@@ -19,6 +22,16 @@ import {
 } from "../utils"
 import { actionTrackingMiddleware, type SimpleActionContext } from "./actionTrackingMiddleware"
 
+function checkMaxLevels(value: number | undefined, name: string): void {
+  if (
+    value !== undefined &&
+    value !== Number.POSITIVE_INFINITY &&
+    (!Number.isInteger(value) || value < 0)
+  ) {
+    throw failure(`${name} must be a non-negative integer or Infinity`)
+  }
+}
+
 /**
  * An undo/redo event without attached state.
  */
@@ -111,16 +124,45 @@ function toSingleEvents(
   return array
 }
 
+// snapshots from before events were frozen have them as plain objects
+function toFrozenEventSnapshots(
+  events: ReadonlyArray<UndoEvent | FrozenData<UndoEvent>> | undefined
+): FrozenData<UndoEvent>[] | undefined {
+  return events?.map((e) => (isFrozenSnapshot<UndoEvent>(e) ? e : toFrozenSnapshot(e)))
+}
+
+function freezeEvent(event: UndoEvent): Frozen<UndoEvent> {
+  // events are only read once recorded, so they are not checked or deeply
+  // frozen (that would also freeze the attached states given by the user)
+  return frozen(event, FrozenCheckMode.Off)
+}
+
 /**
  * Store model instance for undo/redo actions.
- * Do not manipulate directly, other that creating it.
+ * Do not manipulate directly, other than creating it.
+ *
+ * Events are stored as frozen data, since they never change once recorded.
  */
 @model(`${namespace}/UndoStore`)
-export class UndoStore extends Model({
-  // TODO: add proper type checking to undo store
-  undoEvents: tProp(typesArray(typesUnchecked<UndoEvent>()), () => []),
-  redoEvents: tProp(typesArray(typesUnchecked<UndoEvent>()), () => []),
-}) {
+export class UndoStore extends Model(
+  {
+    // TODO: add proper type checking to undo store
+    undoEvents: tProp(typesArray(typesFrozen(typesUnchecked<UndoEvent>())), () => []),
+    redoEvents: tProp(typesArray(typesFrozen(typesUnchecked<UndoEvent>())), () => []),
+  },
+  {
+    fromSnapshotProcessor(sn: {
+      undoEvents?: ReadonlyArray<UndoEvent | FrozenData<UndoEvent>>
+      redoEvents?: ReadonlyArray<UndoEvent | FrozenData<UndoEvent>>
+    }) {
+      return {
+        ...sn,
+        undoEvents: toFrozenEventSnapshots(sn.undoEvents),
+        redoEvents: toFrozenEventSnapshots(sn.redoEvents),
+      }
+    },
+  }
+) {
   /**
    * @ignore
    */
@@ -151,15 +193,13 @@ export class UndoStore extends Model({
     maxUndoLevels?: number
     maxRedoLevels?: number
   }) {
-    if (maxUndoLevels !== undefined) {
-      while (this.undoEvents.length > maxUndoLevels) {
-        this.undoEvents.shift()
-      }
+    checkMaxLevels(maxUndoLevels, "maxUndoLevels")
+    checkMaxLevels(maxRedoLevels, "maxRedoLevels")
+    if (maxUndoLevels !== undefined && this.undoEvents.length > maxUndoLevels) {
+      this.undoEvents.splice(0, this.undoEvents.length - maxUndoLevels)
     }
-    if (maxRedoLevels !== undefined) {
-      while (this.redoEvents.length > maxRedoLevels) {
-        this.redoEvents.shift()
-      }
+    if (maxRedoLevels !== undefined && this.redoEvents.length > maxRedoLevels) {
+      this.redoEvents.splice(0, this.redoEvents.length - maxRedoLevels)
     }
   }
 
@@ -193,7 +233,7 @@ export class UndoStore extends Model({
   @modelAction
   _addUndo({ event, maxUndoLevels }: { event: UndoEvent; maxUndoLevels: number | undefined }) {
     withoutUndo(() => {
-      this.undoEvents.push(event)
+      this.undoEvents.push(freezeEvent(event))
       // once an undo event is added redo queue is no longer valid
       this.redoEvents.length = 0
       this.enforceMaxLevels({ maxUndoLevels })
@@ -261,10 +301,16 @@ export class UndoStore extends Model({
         running = true
       },
       end: () => {
+        if (ended) {
+          throw failure("cannot end a group when it is already ended")
+        }
         if (running) {
           api.pause()
         }
         ended = true
+        if (group.events.length === 0) {
+          return
+        }
         if (parentGroup) {
           this._addUndoToParentGroup(parentGroup, group)
         } else {
@@ -309,7 +355,7 @@ export class UndoManager {
    */
   @mobxComputed
   get undoQueue(): ReadonlyArray<UndoEvent> {
-    return this.store.undoEvents
+    return this.store.undoEvents.map((e) => e.data)
   }
 
   /**
@@ -318,7 +364,7 @@ export class UndoManager {
    */
   @mobxComputed
   get redoQueue(): ReadonlyArray<UndoEvent> {
-    return this.store.redoEvents
+    return this.store.redoEvents.map((e) => e.data)
   }
 
   /**
@@ -326,7 +372,7 @@ export class UndoManager {
    */
   @mobxComputed
   get undoLevels() {
-    return this.undoQueue.length
+    return this.store.undoEvents.length
   }
 
   /**
@@ -350,7 +396,7 @@ export class UndoManager {
    */
   @mobxComputed
   get redoLevels() {
-    return this.redoQueue.length
+    return this.store.redoEvents.length
   }
 
   /**
@@ -378,7 +424,8 @@ export class UndoManager {
     if (!this.canUndo) {
       throw failure("nothing to undo")
     }
-    const event = this.undoQueue[this.undoQueue.length - 1]
+    const events = this.store.undoEvents
+    const event = events[events.length - 1].data
 
     withoutUndo(() => {
       toSingleEvents(event)
@@ -388,7 +435,7 @@ export class UndoManager {
         })
 
       // restore the attached state before the operation was made
-      if (event.attachedState?.beforeEvent) {
+      if (event.attachedState) {
         this.options?.attachedState?.restore(event.attachedState.beforeEvent)
       }
     })
@@ -405,7 +452,8 @@ export class UndoManager {
     if (!this.canRedo) {
       throw failure("nothing to redo")
     }
-    const event = this.redoQueue[this.redoQueue.length - 1]
+    const events = this.store.redoEvents
+    const event = events[events.length - 1].data
 
     withoutUndo(() => {
       toSingleEvents(event).forEach((e) => {
@@ -413,7 +461,7 @@ export class UndoManager {
       })
 
       // restore the attached state after the operation was made
-      if (event.attachedState?.afterEvent) {
+      if (event.attachedState) {
         this.options?.attachedState?.restore(event.attachedState.afterEvent)
       }
     })
@@ -586,14 +634,14 @@ export class UndoManager {
       function next(ret: any): void {
         if (ret && typeof ret.then === "function") {
           // an async iterator
-          ret.then(next, reject)
+          Promise.resolve(ret).then(next, reject).catch(reject)
         } else if (ret.done) {
           // done
           group.end()
           resolve(ret.value)
         } else {
           // continue
-          Promise.resolve(ret.value).then(onFulfilled, onRejected)
+          Promise.resolve(ret.value).then(onFulfilled, onRejected).catch(reject)
         }
       }
 
@@ -675,6 +723,8 @@ export function undoMiddleware<S>(
   options?: UndoMiddlewareOptions<S>
 ): UndoManager {
   assertTweakedObject(subtreeRoot, "subtreeRoot")
+  checkMaxLevels(options?.maxUndoLevels, "maxUndoLevels")
+  checkMaxLevels(options?.maxRedoLevels, "maxRedoLevels")
 
   let manager: UndoManager
 
@@ -691,6 +741,7 @@ export function undoMiddleware<S>(
   function initPatchRecorder(ctx: SimpleActionContext) {
     const group = manager.store._currentGroup
 
+    const attachedStateBeforeEvent = options?.attachedState?.save()
     const patchRecorderData: PatchRecorderData = {
       recorder: patchRecorder(subtreeRoot, {
         recording: false,
@@ -702,7 +753,7 @@ export function undoMiddleware<S>(
       undoRootContext: ctx,
       group,
 
-      attachedStateBeforeEvent: options?.attachedState?.save(),
+      attachedStateBeforeEvent,
     }
 
     ctx.rootContext.data[patchRecorderSymbol] = patchRecorderData
@@ -733,42 +784,44 @@ export function undoMiddleware<S>(
       if (patchRecorderData && patchRecorderData.undoRootContext === ctx) {
         const patchRecorder = patchRecorderData.recorder
 
-        if (patchRecorder.events.length > 0) {
-          const patches: Patch[] = []
-          const inversePatches: Patch[] = []
-
-          for (const event of patchRecorder.events) {
-            patches.push(...event.patches)
-            inversePatches.push(...event.inversePatches)
-          }
-
-          const event = {
-            type: UndoEventType.Single,
-            targetPath: fastGetRootPath(ctx.target, false).path,
-            actionName: ctx.actionName,
-            patches,
-            inversePatches,
-          } as const
-
-          const parentGroup = patchRecorderData.group
-
-          if (parentGroup) {
-            manager.store._addUndoToParentGroup(parentGroup, event)
-          } else {
-            manager.store._addUndo({
-              event: {
-                ...event,
-                attachedState: {
-                  beforeEvent: patchRecorderData.attachedStateBeforeEvent,
-                  afterEvent: options?.attachedState?.save(),
+        try {
+          if (patchRecorder.events.length > 0) {
+            const patches: Patch[] = []
+            const inversePatches: Patch[] = []
+
+            for (const event of patchRecorder.events) {
+              for (const patch of event.patches) patches.push(patch)
+              for (const patch of event.inversePatches) inversePatches.push(patch)
+            }
+
+            const event = {
+              type: UndoEventType.Single,
+              targetPath: fastGetRootPath(ctx.target, false).path,
+              actionName: ctx.actionName,
+              patches,
+              inversePatches,
+            } as const
+
+            const parentGroup = patchRecorderData.group
+
+            if (parentGroup) {
+              manager.store._addUndoToParentGroup(parentGroup, event)
+            } else {
+              manager.store._addUndo({
+                event: {
+                  ...event,
+                  attachedState: {
+                    beforeEvent: patchRecorderData.attachedStateBeforeEvent,
+                    afterEvent: options?.attachedState?.save(),
+                  },
                 },
-              },
-              maxUndoLevels: options?.maxUndoLevels,
-            })
+                maxUndoLevels: options?.maxUndoLevels,
+              })
+            }
           }
+        } finally {
+          patchRecorder.dispose()
         }
-
-        patchRecorder.dispose()
       }
     },
   })

package/src/actionMiddlewares/utils.ts

@@ -1,5 +1,6 @@
 import { modelIdKey } from "../model/metadata"
 import { isModel } from "../model/utils"
+import { modelToDataNode } from "../parent/core"
 import type { RootPath } from "../parent/path"
 import type { Path } from "../parent/pathTypes"
 
@@ -26,7 +27,7 @@ export function pathToTargetPathIds(root: any, path: Path): (string | null)[] {
   let current = root // we don't care about the root ID
 
   for (let i = 0; i < path.length; i++) {
-    current = current[path[i]]
+    current = modelToDataNode(current)[path[i]]
     const targetObjId = isModel(current) ? (current[modelIdKey] ?? null) : null
     targetPathIds.push(targetObjId)
   }

package/src/computedTree/computedTree.ts

@@ -5,7 +5,12 @@ import { isDataModelClass } from "../dataModel/utils"
 import { isModelClass } from "../model/utils"
 import { isTreeNode } from "../tweaker/core"
 import { tweak } from "../tweaker/tweak"
-import { addLateInitializationFunction, failure, runBeforeOnInitSymbol } from "../utils"
+import {
+  addLateInitializationFunction,
+  failure,
+  isEqualOrBothNaN,
+  runBeforeOnInitSymbol,
+} from "../utils"
 import { checkDecoratorContext, copyFunctionMetadata } from "../utils/decorators"
 import { getOrCreate } from "../utils/mapUtils"
 
@@ -54,14 +59,20 @@ export function computedTree(...args: any[]): any {
       const oldValue = entry.value
       const newValue = entry.computed.get()
 
-      if (oldValue === newValue) {
+      if (isEqualOrBothNaN(oldValue, newValue)) {
         return entry.tweakedValue
       }
 
       const oldTweakedValue = entry.tweakedValue
       tweak(oldTweakedValue, undefined)
 
-      const tweakedValue = tweakComputedTreeNode(newValue, this, propertyKey)
+      let tweakedValue: unknown
+      try {
+        tweakedValue = tweakComputedTreeNode(newValue, this, propertyKey)
+      } catch (error) {
+        entry.tweakedValue = tweakComputedTreeNode(oldTweakedValue, this, propertyKey)
+        throw error
+      }
       entry.value = newValue
       entry.tweakedValue = tweakedValue
       return tweakedValue

package/src/context/context.ts

@@ -120,56 +120,28 @@ class ContextClass<T> implements Context<T> {
     this.nodeAtom.get(node)?.reportChanged()
   }
 
-  private fastGet(node: object, useAtom: boolean): T {
-    if (useAtom) {
-      this.reportNodeAtomObserved(node)
+  get(node: object): T {
+    const provider = this.getProviderNode(node)
+    if (provider) {
+      return resolveContextValue(this.nodeContextValue.get(provider)!)
     }
 
-    const obsForNode = this.nodeContextValue.get(node)
-    if (obsForNode) {
-      return resolveContextValue(obsForNode)
-    }
-
-    const parent = fastGetParent(node, useAtom)
-    if (!parent) {
-      const overrideValue = this.overrideContextValue.get()
-      if (overrideValue) {
-        return resolveContextValue(overrideValue)
-      }
-      return this.getDefault()
-    }
-
-    return this.fastGet(parent, useAtom)
-  }
-
-  get(node: object) {
-    assertTweakedObject(node, "node")
-
-    return this.fastGet(node, true)
-  }
-
-  private fastGetProviderNode(node: object, useAtom: boolean): object | undefined {
-    if (useAtom) {
-      this.reportNodeAtomObserved(node)
-    }
-
-    const obsForNode = this.nodeContextValue.get(node)
-    if (obsForNode) {
-      return node
-    }
-
-    const parent = fastGetParent(node, useAtom)
-    if (!parent) {
-      return undefined
-    }
-
-    return this.fastGetProviderNode(parent, useAtom)
+    const overrideValue = this.overrideContextValue.get()
+    return overrideValue ? resolveContextValue(overrideValue) : this.getDefault()
   }
 
   getProviderNode(node: object): object | undefined {
     assertTweakedObject(node, "node")
 
-    return this.fastGetProviderNode(node, true)
+    let current: object | undefined = node
+    while (current) {
+      this.reportNodeAtomObserved(current)
+      if (this.nodeContextValue.has(current)) {
+        return current
+      }
+      current = fastGetParent(current, true)
+    }
+    return undefined
   }
 
   getDefault(): T {
@@ -227,7 +199,7 @@ class ContextClass<T> implements Context<T> {
 
     try {
       const ret = fn()
-      if (isTweakedObject(ret, true)) {
+      if (isTweakedObject(ret, false)) {
         this.set(ret, value)
       }
       return ret
@@ -247,7 +219,7 @@ class ContextClass<T> implements Context<T> {
 
     try {
       const ret = fn()
-      if (isTweakedObject(ret, true)) {
+      if (isTweakedObject(ret, false)) {
         this._setComputed(ret, computedValueFn)
       }
       return ret

package/src/dataModel/BaseDataModel.ts

@@ -1,4 +1,4 @@
-import { type ModelClass, propsTypeSymbol } from "../modelShared/BaseModelShared"
+import { propsTypeSymbol } from "../modelShared/BaseModelShared"
 import { modelInfoByClass } from "../modelShared/modelInfo"
 import { getInternalModelClassPropsInfo } from "../modelShared/modelPropsInfo"
 import {
@@ -15,14 +15,13 @@ import { toTreeNode } from "../tweaker/tweak"
 import { typesDataModelData } from "../types/objectBased/typesDataModelData"
 import type { TypeCheckError } from "../types/TypeCheckError"
 import { typeCheck } from "../types/typeCheck"
-import { clonePlainObject, failure, isObject } from "../utils"
+import { clonePlainObject, failure, hasOwnProp, isObject, setProtoProp } from "../utils"
 import { getOrCreate } from "../utils/mapUtils"
 import type { DataModelConstructorOptions } from "./DataModelConstructorOptions"
+import { dataModelInstanceCache } from "./dataModelInstanceCache"
 import { getDataModelMetadata } from "./getDataModelMetadata"
 import { internalNewDataModel } from "./newDataModel"
 
-const dataModelInstanceCache = new WeakMap<ModelClass<AnyDataModel>, WeakMap<any, AnyDataModel>>()
-
 /**
  * Base abstract class for data models. Use `DataModel` instead when extending.
  *
@@ -101,7 +100,8 @@ export abstract class BaseDataModel<TProps extends ModelProps> {
         const k = modelPropsKeys[i]
         const propData = modelProps[k]
 
-        let newValue = initialData[k]
+        const hasInitialValue = hasOwnProp(initialData, k)
+        let newValue = hasInitialValue ? initialData[k] : undefined
         let changed = false
 
         // apply untransform (if any)
@@ -117,11 +117,15 @@ export abstract class BaseDataModel<TProps extends ModelProps> {
           if (defaultValue !== noDefaultValue) {
             changed = true
             newValue = defaultValue
+          } else if (!hasInitialValue) {
+            // for mobx4, we need to set up properties even if they are undefined
+            changed = true
           }
         }
 
         if (changed) {
-          initialData[k] = newValue
+          if (k === "__proto__") setProtoProp(initialData, newValue)
+          else initialData[k] = newValue
         }
       }
 
@@ -144,24 +148,24 @@ export abstract class BaseDataModel<TProps extends ModelProps> {
 
     Object.setPrototypeOf(this, modelClass.prototype)
 
-    internalNewDataModel(this, tweakedData as any, {
-      modelClass,
-    })
+    try {
+      internalNewDataModel(this, tweakedData as any, {
+        modelClass,
+      })
+    } catch (error) {
+      instancesForModelClass.delete(tweakedData)
+      throw error
+    }
   }
 
   toString(options?: { withData?: boolean }) {
-    const finalOptions = {
-      withData: true,
-      ...options,
-    }
+    const { withData = true } = options ?? {}
 
     const modelInfo = modelInfoByClass.get(this.constructor as any)
 
     const firstPart = `${this.constructor.name}#${modelInfo!.name}`
 
-    return finalOptions.withData
-      ? `[${firstPart} ${JSON.stringify(getSnapshot(this))}]`
-      : `[${firstPart}]`
+    return withData ? `[${firstPart} ${JSON.stringify(getSnapshot(this.$))}]` : `[${firstPart}]`
   }
 }
 

package/src/dataModel/dataModelInstanceCache.ts

@@ -0,0 +1,8 @@
+import type { ModelClass } from "../modelShared/BaseModelShared"
+import type { AnyDataModel } from "./BaseDataModel"
+
+/** @internal */
+export const dataModelInstanceCache = new WeakMap<
+  ModelClass<AnyDataModel>,
+  WeakMap<object, AnyDataModel>
+>()