mobx-keystone 2.1.0 → 2.3.0

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

@@ -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
   }
 
   /**

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

@@ -9,7 +9,7 @@ import type { AnyModel } from "../model/BaseModel"
 import { modelTypeKey } from "../model/metadata"
 import { isModelClass } from "../model/utils"
 import { type ModelClass, modelInitializedSymbol } from "../modelShared/BaseModelShared"
-import { modelInfoByClass, modelInfoByName } from "../modelShared/modelInfo"
+import { modelInfoByClass, modelInfoByName, setModelInfo } from "../modelShared/modelInfo"
 import {
   modelUnwrappedClassSymbol,
   runAfterModelDecoratorSymbol,
@@ -37,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
@@ -161,10 +167,7 @@ const internalModel = <MC extends ModelClass<AnyModel | AnyDataModel>>(
     class: decoratedClass,
   }
 
-  modelInfoByName[name] = modelInfo
-
-  modelInfoByClass.set(decoratedClass, modelInfo)
-  modelInfoByClass.set(clazz, modelInfo)
+  setModelInfo(modelInfo, clazz)
 
   runLateInitializationFunctions(clazz, runAfterModelDecoratorSymbol)
 

package/src/modelShared/modelInfo.ts

@@ -22,6 +22,81 @@ export const modelInfoByName: {
  */
 export const modelInfoByClass = new WeakMap<ModelClass<AnyModel | AnyDataModel>, ModelInfo>()
 
+// registered model prototypes (looked up rather than reading `constructor`, since that might be
+// a model prop)
+const modelInfoByPrototype = new WeakMap<object, ModelInfo>()
+
+// for each registered model, how many registered models below each of its base models
+// (including itself, at 0) it is, by name
+const ancestorDistancesByModelInfo = new WeakMap<ModelInfo, ReadonlyMap<string, number>>()
+// the same, by name for the current registration of each model name
+const ancestorDistancesByModelName = new Map<string, ReadonlyMap<string, number>>()
+
+/**
+ * Finds the info of the first registered model class in a prototype chain.
+ *
+ * @internal
+ */
+export function findModelInfoForPrototype(proto: object | null): ModelInfo | undefined {
+  for (let p = proto; p; p = Object.getPrototypeOf(p)) {
+    const modelInfo = modelInfoByPrototype.get(p)
+    if (modelInfo) {
+      return modelInfo
+    }
+  }
+  return undefined
+}
+
+/**
+ * Registers a model.
+ *
+ * @internal
+ */
+export function setModelInfo(modelInfo: ModelInfo, unwrappedClass: ModelClass<any>): void {
+  // the base classes were registered before, so their distances are already known; names are
+  // used rather than classes since with hot reloading a subclass might still extend a previous
+  // registration of a model
+  const baseModelInfo = findModelInfoForPrototype(Object.getPrototypeOf(unwrappedClass.prototype))
+  const ancestorDistances = new Map<string, number>()
+  baseModelInfo &&
+    ancestorDistancesByModelInfo.get(baseModelInfo)?.forEach((distance, name) => {
+      ancestorDistances.set(name, distance + 1)
+    })
+  ancestorDistances.set(modelInfo.name, 0)
+  ancestorDistancesByModelInfo.set(modelInfo, ancestorDistances)
+  ancestorDistancesByModelName.set(modelInfo.name, ancestorDistances)
+
+  modelInfoByName[modelInfo.name] = modelInfo
+  modelInfoByClass.set(modelInfo.class, modelInfo)
+  modelInfoByClass.set(unwrappedClass, modelInfo)
+  modelInfoByPrototype.set(unwrappedClass.prototype, modelInfo)
+}
+
+/**
+ * How many registered models a model is below a base model (0 if it is that model), or -1 if
+ * it does not extend it.
+ *
+ * @internal
+ */
+export function getModelSubclassDistance(modelInfo: ModelInfo, baseModelName: string): number {
+  return ancestorDistancesByModelInfo.get(modelInfo)?.get(baseModelName) ?? -1
+}
+
+/**
+ * How many registered models the model currently registered with a name is below a base model
+ * (0 if it is that model), -1 if it does not extend it, or `undefined` if the name is not
+ * registered.
+ *
+ * @internal
+ */
+export function getModelSubclassDistanceForName(
+  modelName: string,
+  baseModelName: string
+): number | undefined {
+  const ancestorDistances = ancestorDistancesByModelName.get(modelName)
+  return ancestorDistances ? (ancestorDistances.get(baseModelName) ?? -1) : undefined
+}
+
 /**
  * Returns the model info for a model type name, or `undefined` if not found.
  *