mobx-keystone 2.1.0 → 2.2.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

@@ -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

package/src/modelShared/prop.ts

@@ -3,7 +3,7 @@ import type { AnyStandardType } from "../types/schemas"
 import { isEqualOrBothNaN, lazy } from "../utils"
 import { runWithErrorDiagnosticsContext, withErrorPathSegment } from "../utils/errorDiagnostics"
 import { getOrCreate } from "../utils/mapUtils"
-import type { Flatten, IsNeverType, IsOptionalValue } from "../utils/types"
+import type { IsNeverType, IsOptionalValue, SimplifyObject } from "../utils/types"
 
 /**
  * @ignore
@@ -71,50 +71,18 @@ export interface ModelProp<
    * Adds a setter to the property. The setter will be named `set${CapitalizedPropName}`
    * and will be available in the model instance.
    */
-  withSetter(): ModelProp<
-    TPropValue,
-    TPropCreationValue,
-    TTransformedValue,
-    TTransformedCreationValue,
-    TIsRequired,
-    TIsId,
-    string,
-    TFromSnapshotOverride,
-    TToSnapshotOverride
-  >
+  withSetter(): ModelPropWithSetter<this>
   /**
    * Adds a setter with a transform to the property. The setter will be named `set${CapitalizedPropName}`
    * and will be available in the model instance.
    */
   withSetter(
     valueTransform: ModelPropSetterValueTransform<TTransformedValue>
-  ): ModelProp<
-    TPropValue,
-    TPropCreationValue,
-    TTransformedValue,
-    TTransformedCreationValue,
-    TIsRequired,
-    TIsId,
-    string,
-    TFromSnapshotOverride,
-    TToSnapshotOverride
-  >
+  ): ModelPropWithSetter<this>
   /**
    * @deprecated Setter methods are preferred.
    */
-  withSetter(
-    mode: "assign"
-  ): ModelProp<
-    TPropValue,
-    TPropCreationValue,
-    TTransformedValue,
-    TTransformedCreationValue,
-    TIsRequired,
-    TIsId,
-    string,
-    TFromSnapshotOverride,
-    TToSnapshotOverride
-  >
+  withSetter(mode: "assign"): ModelPropWithSetter<this>
 
   /**
    * Sets a transform for the property instance value.
@@ -130,17 +98,7 @@ export interface ModelProp<
    */
   withTransform<TTV>(
     transform: ModelPropTransform<NonNullable<TPropValue>, TTV>
-  ): ModelProp<
-    TPropValue,
-    TPropCreationValue,
-    TTV | Extract<TPropValue, null | undefined>,
-    TTV | Extract<TPropCreationValue, null | undefined>,
-    TIsRequired,
-    TIsId,
-    THasSetter,
-    TFromSnapshotOverride,
-    TToSnapshotOverride
-  >
+  ): ModelPropWithTransform<this, TTV>
 
   /**
    * Sets snapshot processors for this property.
@@ -158,18 +116,69 @@ export interface ModelProp<
   >(processor: {
     fromSnapshot?: (sn: FS) => ModelPropFromSnapshot<This>
     toSnapshot?: (sn: ModelPropToSnapshot<This>) => TS
-  }): ModelProp<
-    TPropValue,
-    TPropCreationValue,
-    TTransformedValue,
-    TTransformedCreationValue,
-    TIsRequired,
-    TIsId,
-    THasSetter,
-    FS,
-    TS
-  >
+  }): ModelPropWithSnapshotProcessor<this, FS, TS>
+}
+
+type ModelPropStoredMetadataKey = "$storedValueType" | "$storedCreationValueType"
+
+// keeps the stored value metadata that `tProp` adds (e.g. the encoded type of a codec)
+// when a model prop is derived through one of its modifiers
+type ModelPropStoredMetadata<MP, K extends PropertyKey> = MP extends {
+  $storedValueType: unknown
 }
+  ? Pick<MP, Extract<keyof MP, K>>
+  : {}
+
+// the modifier result types are exported so emitted declaration files can reference them by name
+// instead of expanding them inline in every exported model class
+
+/**
+ * The model property returned by `withSetter`.
+ */
+export type ModelPropWithSetter<MP extends AnyModelProp> = ModelProp<
+  MP["$valueType"],
+  MP["$creationValueType"],
+  MP["$transformedValueType"],
+  MP["$transformedCreationValueType"],
+  MP["$isRequired"],
+  MP["$isId"],
+  string,
+  MP["$fromSnapshotOverride"],
+  MP["$toSnapshotOverride"]
+> &
+  ModelPropStoredMetadata<MP, ModelPropStoredMetadataKey | "$typedFromSnapshotOverride">
+
+/**
+ * The model property returned by `withTransform`.
+ */
+export type ModelPropWithTransform<MP extends AnyModelProp, TTV> = ModelProp<
+  MP["$valueType"],
+  MP["$creationValueType"],
+  TTV | Extract<MP["$valueType"], null | undefined>,
+  TTV | Extract<MP["$creationValueType"], null | undefined>,
+  MP["$isRequired"],
+  MP["$isId"],
+  MP["$hasSetter"],
+  MP["$fromSnapshotOverride"],
+  MP["$toSnapshotOverride"]
+> &
+  ModelPropStoredMetadata<MP, ModelPropStoredMetadataKey | "$typedFromSnapshotOverride">
+
+/**
+ * The model property returned by `withSnapshotProcessor`.
+ */
+export type ModelPropWithSnapshotProcessor<MP extends AnyModelProp, FS, TS> = ModelProp<
+  MP["$valueType"],
+  MP["$creationValueType"],
+  MP["$transformedValueType"],
+  MP["$transformedCreationValueType"],
+  MP["$isRequired"],
+  MP["$isId"],
+  MP["$hasSetter"],
+  FS,
+  TS
+> &
+  ModelPropStoredMetadata<MP, ModelPropStoredMetadataKey>
 
 /**
  * The snapshot in type of a model property.
@@ -189,23 +198,19 @@ export type ModelPropToSnapshot<MP extends AnyModelProp> = IsNeverType<
   MP["$toSnapshotOverride"]
 >
 
-export type ModelPropStoredValue<MP extends AnyModelProp> = MP extends {
-  $storedValueType: infer TStoredValue
-}
-  ? TStoredValue
+export type ModelPropStoredValue<MP extends AnyModelProp> = "$storedValueType" extends keyof MP
+  ? MP["$storedValueType" & keyof MP]
   : MP["$valueType"]
 
-export type ModelPropStoredCreationValue<MP extends AnyModelProp> = MP extends {
-  $storedCreationValueType: infer TStoredCreationValue
-}
-  ? TStoredCreationValue
-  : MP["$creationValueType"]
+export type ModelPropStoredCreationValue<MP extends AnyModelProp> =
+  "$storedCreationValueType" extends keyof MP
+    ? MP["$storedCreationValueType" & keyof MP]
+    : MP["$creationValueType"]
 
-export type ModelPropFromSnapshotOverride<MP extends AnyModelProp> = MP extends {
-  $typedFromSnapshotOverride: infer TFromSnapshotOverride
-}
-  ? TFromSnapshotOverride
-  : MP["$fromSnapshotOverride"]
+export type ModelPropFromSnapshotOverride<MP extends AnyModelProp> =
+  "$typedFromSnapshotOverride" extends keyof MP
+    ? MP["$typedFromSnapshotOverride" & keyof MP]
+    : MP["$fromSnapshotOverride"]
 
 /**
  * A model prop transform.
@@ -245,13 +250,13 @@ export type RequiredModelProps<MP extends ModelProps> = {
   [K in keyof MP]: MP[K]["$isRequired"] & K
 }[keyof MP]
 
-export type ModelPropsToUntransformedData<MP extends ModelProps> = Flatten<{
+export type ModelPropsToUntransformedData<MP extends ModelProps> = {
   [k in keyof MP]: ModelPropStoredValue<MP[k]>
-}>
+} & {}
 
-export type ModelPropsToSnapshotData<MP extends ModelProps> = Flatten<{
+export type ModelPropsToSnapshotData<MP extends ModelProps> = {
   [k in keyof MP]: ModelPropToSnapshot<MP[k]> extends infer R ? R : never
-}>
+} & {}
 
 // we don't use O.Optional anymore since it generates unions too heavy
 // also if we use Pick over the optional props we will loose the ability to infer generics
@@ -264,23 +269,29 @@ export type ModelPropsToUntransformedCreationData<MP extends ModelProps> = {
 
 // we don't use O.Optional anymore since it generates unions too heavy
 // also if we use Pick over the optional props we will loose the ability to infer generics
-export type ModelPropsToSnapshotCreationData<MP extends ModelProps> = Flatten<
+export type ModelPropsToSnapshotCreationData<MP extends ModelProps> = SimplifyObject<
   {
     [k in keyof MP]?: ModelPropFromSnapshot<MP[k]> extends infer R ? R : never
   } & {
-    [k in {
-      [K in keyof MP]: IsNeverType<
-        ModelPropFromSnapshotOverride<MP[K]>,
-        MP[K]["$isRequired"] & K, // no override
-        IsOptionalValue<ModelPropFromSnapshotOverride<MP[K]>, never, K> // with override
-      >
-    }[keyof MP]]: ModelPropFromSnapshot<MP[k]> extends infer R ? R : never
+    [k in SnapshotCreationRequiredKeys<MP>]: ModelPropFromSnapshot<MP[k]> extends infer R
+      ? R
+      : never
   }
 >
 
-export type ModelPropsToTransformedData<MP extends ModelProps> = Flatten<{
+// without a snapshot processor a key is required when the prop is required,
+// with one when the processor input does not accept undefined
+type SnapshotCreationRequiredKeys<MP extends ModelProps> = {
+  [K in keyof MP]: IsNeverType<
+    ModelPropFromSnapshotOverride<MP[K]>,
+    MP[K]["$isRequired"] & K,
+    IsOptionalValue<ModelPropFromSnapshotOverride<MP[K]>, never, K>
+  >
+}[keyof MP]
+
+export type ModelPropsToTransformedData<MP extends ModelProps> = {
   [k in keyof MP]: MP[k]["$transformedValueType"]
-}>
+} & {}
 
 // we don't use O.Optional anymore since it generates unions too heavy
 // also if we use Pick over the optional props we will loose the ability to infer generics
@@ -292,11 +303,11 @@ export type ModelPropsToTransformedCreationData<MP extends ModelProps> = {
   [k in RequiredModelProps<MP>]: MP[k]["$transformedCreationValueType"]
 }
 
-export type ModelPropsToSetter<MP extends ModelProps> = Flatten<{
+export type ModelPropsToSetter<MP extends ModelProps> = {
   [k in keyof MP as MP[k]["$hasSetter"] & `set${Capitalize<k & string>}`]: (
     value: MP[k]["$transformedValueType"]
   ) => void
-}>
+} & {}
 
 export type ModelIdProp<T extends string = string> = ModelProp<
   T,
@@ -307,7 +318,12 @@ export type ModelIdProp<T extends string = string> = ModelProp<
   true
 >
 
-type TypedModelIdProp<T extends string = string, THasSetter = never> = Omit<
+// exported (and publicly re-exported) so emitted declaration files can reference it by name
+// instead of expanding it inline in every exported model class, which is much slower and larger
+/**
+ * The type of `idProp`.
+ */
+export type TypedModelIdProp<T extends string = string, THasSetter = never> = Omit<
   ModelProp<T, T | undefined, T, T | undefined, never, true, THasSetter>,
   "withSetter"
 > & {
@@ -569,21 +585,17 @@ export function prop(...args: [] | [def: any]): AnyModelProp {
 
   const [def] = args
 
-  let p = propCache.get(def)
-
-  if (!p) {
-    p = Object.create(baseProp)
+  return getOrCreate(propCache, def, () => {
+    const p: AnyModelProp = Object.create(baseProp)
 
     if (typeof def === "function") {
-      p!._defaultFn = def
+      p._defaultFn = def
     } else {
-      p!._defaultValue = def
+      p._defaultValue = def
     }
 
-    propCache.set(def, p!)
-  }
-
-  return p!
+    return p
+  })
 }
 
 function parseSetterConfig(
@@ -599,19 +611,11 @@ function parseSetterConfig(
     }
   }
 
-  if (
-    modeOrValueTransform === undefined ||
-    typeof modeOrValueTransform === "boolean" ||
-    modeOrValueTransform === "assign"
-  ) {
-    return {
-      mode: modeOrValueTransform ?? true,
-      valueTransform: undefined,
-    }
-  }
-
   return {
-    mode: true,
+    mode:
+      typeof modeOrValueTransform === "boolean" || modeOrValueTransform === "assign"
+        ? modeOrValueTransform
+        : true,
     valueTransform: undefined,
   }
 }

package/src/modelShared/sharedInternalModel.ts

@@ -241,7 +241,7 @@ export function sharedInternalModel<
     const idPropGenerator = idProp._idGenerator
     const baseIdProp = baseModelProps?.[idKey]
     const baseIdPropGenerator = baseIdProp?._idGenerator
-    const isOverridingBaseIdProp = !!baseIdProp?._isId && Object.hasOwn(modelProps, idKey)
+    const isOverridingBaseIdProp = !!baseIdProp?._isId && hasOwnProp(modelProps, idKey)
     if (isOverridingBaseIdProp && baseIdPropGenerator !== idPropGenerator) {
       throw failure(
         `expected same idProp.withGenerator function when overriding a base idProp, but got different references`
@@ -315,7 +315,7 @@ export function sharedInternalModel<
     // make sure abstract classes do not override prototype props
     if (!propsToDeleteFromBase) {
       propsToDeleteFromBase = Object.keys(modelProps).filter(
-        (p) => !basePropNames.has(p as any) && Object.hasOwn(baseModel, p)
+        (p) => !basePropNames.has(p as any) && hasOwnProp(baseModel, p)
       )
     }
 

package/src/parent/arrayPaths.ts

@@ -235,8 +235,5 @@ export function getArrayPaths(
  * @internal
  */
 export function setLazyArrayParentPath(entry: LazyArrayParentPath, node: object): void {
-  const metadata = treeNodeMetadata.get(node)!
-  if (metadata.parentPath !== entry) {
-    metadata.parentPath = entry
-  }
+  treeNodeMetadata.get(node)!.parentPath = entry
 }

package/src/parent/path.ts

@@ -127,16 +127,6 @@ export function fastGetParent<T extends object = any>(
   return fastGetParentPath(value, useAtom)?.parent
 }
 
-/**
- * @internal
- */
-export function fastGetParentIncludingDataObjects<T extends object = any>(
-  value: object,
-  useAtom: boolean
-): T | undefined {
-  return fastGetParentPathIncludingDataObjects(value, useAtom)?.parent
-}
-
 /**
  * Returns if a given object is a model interim data object (`$`).
  *