mobx-keystone 2.0.0 → 2.2.0

package/src/context/context.ts

@@ -162,25 +162,19 @@ class ContextClass<T> implements Context<T> {
     })
   })
 
-  set = action((node: object, value: T) => {
-    assertTweakedObject(node, "node")
-
-    this.nodeContextValue.set(node, {
-      type: "value",
-      value,
-    })
-    this.reportNodeAtomChanged(node)
-  })
-
-  private _setComputed(node: object, computedValueFn: IComputedValue<T>) {
+  private setNodeContextValue(node: object, contextValue: ContextValue<T>) {
     assertTweakedObject(node, "node")
 
-    this.nodeContextValue.set(node, { type: "computed", value: computedValueFn })
+    this.nodeContextValue.set(node, contextValue)
     this.reportNodeAtomChanged(node)
   }
 
+  set = action((node: object, value: T) => {
+    this.setNodeContextValue(node, { type: "value", value })
+  })
+
   setComputed = action((node: object, valueFn: () => T) => {
-    this._setComputed(node, computed(valueFn))
+    this.setNodeContextValue(node, { type: "computed", value: computed(valueFn) })
   })
 
   unset = action((node: object) => {
@@ -190,42 +184,27 @@ class ContextClass<T> implements Context<T> {
     this.reportNodeAtomChanged(node)
   })
 
-  apply = action(<R>(fn: () => R, value: T): R => {
+  private applyOverride<R>(fn: () => R, contextValue: ContextValue<T>): R {
     const old = this.overrideContextValue.get()
-    this.overrideContextValue.set({
-      type: "value",
-      value,
-    })
+    this.overrideContextValue.set(contextValue)
 
     try {
       const ret = fn()
       if (isTweakedObject(ret, false)) {
-        this.set(ret, value)
+        this.setNodeContextValue(ret, contextValue)
       }
       return ret
     } finally {
       this.overrideContextValue.set(old)
     }
+  }
+
+  apply = action(<R>(fn: () => R, value: T): R => {
+    return this.applyOverride(fn, { type: "value", value })
   })
 
   applyComputed = action(<R>(fn: () => R, valueFn: () => T): R => {
-    const computedValueFn = computed(valueFn)
-
-    const old = this.overrideContextValue.get()
-    this.overrideContextValue.set({
-      type: "computed",
-      value: computedValueFn,
-    })
-
-    try {
-      const ret = fn()
-      if (isTweakedObject(ret, false)) {
-        this._setComputed(ret, computedValueFn)
-      }
-      return ret
-    } finally {
-      this.overrideContextValue.set(old)
-    }
+    return this.applyOverride(fn, { type: "computed", value: computed(valueFn) })
   })
 
   constructor(defaultValue?: T) {

package/src/dataModel/utils.ts

@@ -13,37 +13,14 @@ export function isDataModel(model: unknown): model is AnyDataModel {
   return model instanceof BaseDataModel
 }
 
-/**
- * @internal
- *
- * Asserts something is actually a data model.
- *
- * @param model
- * @param argName
- */
-export function assertIsDataModel(
-  model: unknown,
-  argName: string,
-  customErrMsg = "must be a data model instance"
-): asserts model is AnyDataModel {
-  if (!isDataModel(model)) {
-    throw failure(`${argName} ${customErrMsg}`)
-  }
-}
-
 /**
  * @internal
  */
 export function isDataModelClass(modelClass: unknown): modelClass is ModelClass<AnyDataModel> {
-  if (typeof modelClass !== "function") {
-    return false
-  }
-
-  if (modelClass !== BaseDataModel && !(modelClass.prototype instanceof BaseDataModel)) {
-    return false
-  }
-
-  return true
+  return (
+    typeof modelClass === "function" &&
+    (modelClass === BaseDataModel || modelClass.prototype instanceof BaseDataModel)
+  )
 }
 
 /**
@@ -57,7 +34,7 @@ export function assertIsDataModelClass(
     throw failure(`${argName} must be a class`)
   }
 
-  if (modelClass !== BaseDataModel && !(modelClass.prototype instanceof BaseDataModel)) {
+  if (!isDataModelClass(modelClass)) {
     throw failure(`${argName} must extend DataModel`)
   }
 }

package/src/deepChange/onDeepChange.ts

@@ -209,21 +209,9 @@ function changeWithPath(change: DeepChange, path: Path): DeepChange {
  * @internal
  */
 export function emitDeepChange(obj: object, change: DeepChange): void {
-  if (!hasAnyDeepChangeListeners()) {
-    return
+  if (hasAnyDeepChangeListeners()) {
+    emitLazyDeepChange(obj, () => change)
   }
-
-  const emission = beginDeepChangeEmission()
-  try {
-    attachEmission(change)
-    emitGlobalDeepChange(obj, change)
-    if (deepChangeListenerCount > 0) {
-      emitDeepChangeToListeners(obj, change)
-    }
-  } finally {
-    currentEmission = emission.parent
-  }
-  rethrowDeepChangeListenerError(emission)
 }
 
 /**
@@ -308,98 +296,52 @@ function emitDeepChangeFromValues(
   addedValues?: unknown[],
   removedValues?: unknown[]
 ): void {
-  if (!hasAnyDeepChangeListeners()) {
-    return
-  }
-
-  const emission = beginDeepChangeEmission()
-  try {
-    emitDeepChangeFromValuesInEmission(
-      node,
-      type,
-      target,
-      keyOrIndex,
-      newValue,
-      oldValue,
-      addedValues,
-      removedValues
+  if (hasAnyDeepChangeListeners()) {
+    emitLazyDeepChange(node, () =>
+      buildDeepChange(type, target, keyOrIndex, newValue, oldValue, addedValues, removedValues)
     )
-  } finally {
-    currentEmission = emission.parent
   }
-  rethrowDeepChangeListenerError(emission)
 }
 
-function emitDeepChangeFromValuesInEmission(
-  node: object,
-  type: DeepChangeType,
-  target: object | unknown[],
-  keyOrIndex: string | number,
-  newValue: unknown,
-  oldValue: unknown,
-  addedValues?: unknown[],
-  removedValues?: unknown[]
-): void {
-  let change: DeepChange | undefined
-
-  if (globalDeepChangeListeners.length > 0) {
-    change = createDeepChange(
-      type,
-      target,
-      keyOrIndex,
-      newValue,
-      oldValue,
-      addedValues,
-      removedValues
-    )
-    emitGlobalDeepChange(node, change)
-  }
-
-  if (deepChangeListenerCount === 0) {
-    return
-  }
+/**
+ * Delivers a change to the global listeners and to the listeners of the node
+ * and its ancestors. The change is only created if some listener gets it.
+ */
+function emitLazyDeepChange(node: object, createChange: () => DeepChange): void {
+  const emission = beginDeepChangeEmission()
+  try {
+    let change: DeepChange | undefined
 
-  // Segments are pushed in child-to-root order (O(1) each) rather than unshifted
-  // at the front (O(depth) each), keeping the whole walk O(depth) instead of
-  // O(depth^2) on deep trees.
-  const reversedPrefix: WritablePath = []
-  let current: object | undefined = node
-  while (current) {
-    const listenersForObject = deepChangeListeners.get(current)
-    if (listenersForObject && listenersForObject.length > 0) {
-      change ??= createDeepChange(
-        type,
-        target,
-        keyOrIndex,
-        newValue,
-        oldValue,
-        addedValues,
-        removedValues
-      )
-      emitDeepChangeForTarget(current, change, reversedPrefix, reversedPrefix.length)
+    if (globalDeepChangeListeners.length > 0) {
+      change = attachEmission(createChange())
+      emitGlobalDeepChange(node, change)
     }
 
-    const parentPath: ParentPath<object> | undefined = fastGetParentPath(current, false)
-    if (!parentPath) {
-      break
+    if (deepChangeListenerCount > 0) {
+      // Segments are pushed in child-to-root order (O(1) each) rather than unshifted
+      // at the front (O(depth) each), keeping the whole walk O(depth) instead of
+      // O(depth^2) on deep trees.
+      const reversedPrefix: WritablePath = []
+      let current: object | undefined = node
+      while (current) {
+        const listenersForObject = deepChangeListeners.get(current)
+        if (listenersForObject && listenersForObject.length > 0) {
+          change ??= attachEmission(createChange())
+          emitDeepChangeForTarget(listenersForObject, change, reversedPrefix)
+        }
+
+        const parentPath: ParentPath<object> | undefined = fastGetParentPath(current, false)
+        if (!parentPath) {
+          break
+        }
+        reversedPrefix.push(parentPath.path)
+        current = parentPath.parent
+      }
     }
-    reversedPrefix.push(parentPath.path)
-    current = parentPath.parent
+  } finally {
+    currentEmission = emission.parent
   }
-}
-
-function createDeepChange(
-  type: DeepChangeType,
-  target: object | unknown[],
-  keyOrIndex: string | number,
-  newValue: unknown,
-  oldValue: unknown,
-  addedValues: unknown[] | undefined,
-  removedValues: unknown[] | undefined
-): DeepChange {
-  return attachEmission(
-    buildDeepChange(type, target, keyOrIndex, newValue, oldValue, addedValues, removedValues)
-  )
+  rethrowDeepChangeListenerError(emission)
 }
 
 function buildDeepChange(
@@ -489,39 +431,15 @@ function rememberDeepChangeListenerError(error: unknown): void {
   emission.error = addDelayedError(emission.error, error, "multiple deep change listeners failed")
 }
 
-function emitDeepChangeToListeners(obj: object, change: DeepChange): void {
-  // Segments are pushed in child-to-root order (O(1) each) rather than unshifted
-  // at the front (O(depth) each), keeping the whole walk O(depth) instead of
-  // O(depth^2) on deep trees.
-  const reversedPrefix: WritablePath = []
-
-  emitDeepChangeForTarget(obj, change, reversedPrefix, 0)
-
-  // and also emit subtree listeners all the way to the root
-  let parentPath = fastGetParentPath(obj, false)
-  while (parentPath) {
-    reversedPrefix.push(parentPath.path)
-    emitDeepChangeForTarget(parentPath.parent, change, reversedPrefix, reversedPrefix.length)
-
-    parentPath = fastGetParentPath(parentPath.parent, false)
-  }
-}
-
 // `reversedPrefix` holds the path segments from the changed node up to (but not
-// including) `obj`, in child-to-root order; the emitted path prepends that slice
-// reversed (root-to-child). `prefixCount` is how many leading entries apply.
+// including) the listened node, in child-to-root order; the emitted path
+// prepends it reversed (root-to-child).
 function emitDeepChangeForTarget(
-  obj: object,
+  listenersForObject: readonly ListenerSubscription<OnDeepChangeListener>[],
   change: DeepChange,
-  reversedPrefix: readonly PathElement[],
-  prefixCount: number
+  reversedPrefix: readonly PathElement[]
 ): void {
-  const listenersForObject = deepChangeListeners.get(obj)
-
-  if (!listenersForObject || listenersForObject.length === 0) {
-    return
-  }
-
+  const prefixCount = reversedPrefix.length
   const prefixedChange =
     prefixCount > 0
       ? changeWithPath(change, buildPrefixedPath(reversedPrefix, prefixCount, change.path))

package/src/model/BaseModel.ts

@@ -17,7 +17,7 @@ import type { SnapshotInOfModel, SnapshotOutOfModel } from "../snapshot/Snapshot
 import { typesModel } from "../types/objectBased/typesModel"
 import type { TypeCheckError } from "../types/TypeCheckError"
 import { typeCheck } from "../types/typeCheck"
-import { assertIsObject, failure } from "../utils"
+import { assertIsObject, failure, nodeObservableOptions } from "../utils"
 import { getModelIdPropertyName } from "./getModelMetadata"
 import type { ModelConstructorOptions } from "./ModelConstructorOptions"
 import { modelIdKey, modelTypeKey } from "./metadata"
@@ -89,7 +89,7 @@ export abstract class BaseModel<
    * By default it will use the `idProp` if available or return `undefined` otherwise.
    */
   getRefId(): string | undefined {
-    return this[modelIdKey]
+    return this[modelIdKey] as string | undefined
   }
 
   /**
@@ -150,9 +150,11 @@ export abstract class BaseModel<
       // Empty input is filled by the constructor below. Track its primitive
       // defaults directly instead of rereading observable fields for the snapshot.
       const useInitialDataSnapshot = Reflect.ownKeys(initialData).length === 0
-      const observableInitialData = observable.object(initialData as any, undefined, {
-        deep: false,
-      })
+      const observableInitialData = observable.object(
+        initialData as any,
+        undefined,
+        nodeObservableOptions
+      )
       if (useInitialDataSnapshot) {
         setModelInitialDataSnapshot(observableInitialData, {})
       }

package/src/model/utils.ts

@@ -39,15 +39,10 @@ export function assertIsModel(
  * @internal
  */
 export function isModelClass(modelClass: unknown): modelClass is ModelClass<AnyModel> {
-  if (typeof modelClass !== "function") {
-    return false
-  }
-
-  if (modelClass !== BaseModel && !(modelClass.prototype instanceof BaseModel)) {
-    return false
-  }
-
-  return true
+  return (
+    typeof modelClass === "function" &&
+    (modelClass === BaseModel || modelClass.prototype instanceof BaseModel)
+  )
 }
 
 /**
@@ -61,7 +56,7 @@ export function assertIsModelClass(
     throw failure(`${argName} must be a class`)
   }
 
-  if (modelClass !== BaseModel && !(modelClass.prototype instanceof BaseModel)) {
+  if (!isModelClass(modelClass)) {
     throw failure(`${argName} must extend Model`)
   }
 }

package/src/modelShared/modelDecorator.ts

@@ -19,6 +19,7 @@ import {
   addLateInitializationFunction,
   failure,
   getMobxVersion,
+  hasStoredMobxAnnotations,
   logWarning,
   makeObservableCompat,
   runAfterNewSymbol,
@@ -36,11 +37,17 @@ import type { AnyFunction } from "../utils/AnyFunction"
  */
 export const model =
   (name: string) =>
-  <MC extends ModelClass<AnyModel | AnyDataModel>>(
-    clazz: MC,
-    _context?: ClassDecoratorContext<MC>
-  ): MC =>
-    internalModel(name, clazz) as any
+  <MC extends ModelDecoratorTarget>(clazz: MC, _context?: ClassDecoratorContext<MC>): MC =>
+    internalModel(name, clazz as unknown as ModelClass<AnyModel | AnyDataModel>) as any
+
+// the model instance type is checked through `prototype` rather than through a typed constructor
+// signature, since comparing constructor signatures would compute the (expensive) model creation data
+// type of every decorated class
+type ModelDecoratorTarget = (new (
+  ...args: any
+) => any) & {
+  prototype: AnyModel | AnyDataModel
+}
 
 interface AfterClassInitializationData {
   needsMakeObservable: boolean | undefined
@@ -55,33 +62,12 @@ const afterClassInitializationData = new WeakMap<
 const runAfterClassInitialization = (tag: AfterClassInitializationData, instance: any) => {
   runLateInitializationFunctions(instance, runAfterNewSymbol)
 
-  // compatibility with mobx 6 and 7
+  // MobX 6 legacy decorators need makeObservable, while MobX 7 annotations (see
+  // decoratedModel) and 2022.3 decorators initialize themselves. Otherwise it
+  // would only add an empty observable administration to every instance.
+  tag.needsMakeObservable ??= getMobxVersion() === 6 && hasStoredMobxAnnotations(instance)
   if (tag.needsMakeObservable) {
-    // we know it can be done and shouldn't fail
     makeObservableCompat(instance)
-  } else if (tag.needsMakeObservable === undefined) {
-    if (getMobxVersion() >= 6) {
-      try {
-        makeObservableCompat(instance)
-        tag.needsMakeObservable = true
-      } catch (e) {
-        const err = e as Error
-        if (
-          err.message !==
-            "[MobX] No annotations were passed to makeObservable, but no decorator members have been found either" &&
-          err.message !==
-            "[MobX] No annotations were passed to makeObservable, but no decorated members have been found either"
-        ) {
-          throw err
-        }
-
-        // sadly we need to use this hack since the PR to do this the proper way
-        // was rejected on the mobx side
-        tag.needsMakeObservable = false
-      }
-    } else {
-      tag.needsMakeObservable = false
-    }
   }
 
   // the object is ready