mobx-keystone 2.1.0 → 2.3.0

package/src/types/utility/typesOr.ts

@@ -1,5 +1,14 @@
+import { modelTypeKey } from "../../model/metadata"
+import { getModelInfoForName } from "../../modelShared/modelInfo"
 import { failure, lazy } from "../../utils"
 import { getTypeInfo } from "../getTypeInfo"
+import {
+  findClosestModelTypeMatch,
+  findFirstMatch,
+  getModelTypeMatchingPass,
+  hasSnapshotModelType,
+  matchUnlessModelSnapshotRejected,
+} from "../modelTypeMatching"
 import {
   resolveStandardType,
   resolveStandardTypeNoThrow,
@@ -195,17 +204,34 @@ export function typesOr(
           // this is done because:
           // 1) performance (avoid checking structure if not needed)
           // 2) so we can accept untyped models when paired with undefined | null
-          return checkerForBaseType[0]
-        }
-
-        for (let i = 0; i < checkerForBaseType.length; i++) {
-          const matchingType = checkerForBaseType[i].snapshotType(value)
-          if (matchingType) {
-            return matchingType
+          const candidate = checkerForBaseType[0]
+          if (
+            getModelTypeMatchingPass() !== "none" &&
+            valueBaseType !== TypeCheckerBaseType.Primitive
+          ) {
+            // an outer union is matching its branches, so let it know whether this one matches
+            // the (possibly nested) snapshot models; if it does not because a (possibly nested)
+            // model type rejected a model snapshot (in the exact pass, also one of a subclass),
+            // or because the snapshot names a registered model this branch does not accept, the
+            // outer union has to try other branches first, else it might pick a farther branch
+            // or one that rejects the snapshot
+            const matched = matchUnlessModelSnapshotRejected(matchSnapshotType, candidate, value)
+            if (
+              matched === undefined ||
+              (!matched &&
+                hasSnapshotModelType(value) &&
+                getModelInfoForName((value as any)[modelTypeKey]))
+            ) {
+              return null
+            }
           }
+          return candidate
         }
 
-        return null
+        // prefer branches whose (possibly nested) models are the closest to the snapshot ones
+        return valueBaseType === TypeCheckerBaseType.Primitive
+          ? (findFirstMatch(checkerForBaseType, matchSnapshotType, value) ?? null)
+          : (findClosestModelTypeMatch(checkerForBaseType, matchSnapshotType, value) ?? null)
       },
 
       snapshotProcessorPlan(
@@ -272,3 +298,7 @@ export class OrTypeInfo extends TypeInfo {
     this.dispatcher = dispatcher
   }
 }
+
+function matchSnapshotType(checker: TypeChecker, value: unknown): TypeChecker | null {
+  return checker.snapshotType(value)
+}

package/src/types/utility/typesRefinement.ts

@@ -62,6 +62,11 @@ export function typesRefinement<T extends AnyType>(
       return `${refinementName}<${baseTypeName}>`
     }
 
+    const processorPlan = snapshotProcessorPlan(
+      () => [baseChecker],
+      ([processor]) => processor
+    )
+
     const thisTc: TypeChecker = new TypeChecker(
       baseChecker.baseType,
 
@@ -103,14 +108,8 @@ export function typesRefinement<T extends AnyType>(
       // we cannot check refinement here since it checks data instances, not snapshots
       (sn) => baseChecker.snapshotType(sn),
 
-      snapshotProcessorPlan(
-        () => [baseChecker],
-        ([processor]) => processor
-      ),
-      snapshotProcessorPlan(
-        () => [baseChecker],
-        ([processor]) => processor
-      )
+      processorPlan,
+      processorPlan
     )
 
     return thisTc

package/src/types/utility/typesSkipCheck.ts

@@ -42,20 +42,19 @@ export function typesSkipCheck<T extends AnyType>(baseType: T): T {
       return `skipCheck<${baseTypeName}>`
     }
 
+    const processorPlan = snapshotProcessorPlan(
+      () => [baseChecker],
+      ([processor]) => processor
+    )
+
     const thisTc: TypeChecker = new TypeChecker(
       baseChecker.baseType,
       (_data, _path, _typeCheckedValue) => null, // always passes validation
       getTypeName,
       typeInfoGen,
       (sn) => baseChecker.snapshotType(sn),
-      snapshotProcessorPlan(
-        () => [baseChecker],
-        ([processor]) => processor
-      ),
-      snapshotProcessorPlan(
-        () => [baseChecker],
-        ([processor]) => processor
-      )
+      processorPlan,
+      processorPlan
     )
     thisTc.skipCheck = true
 

package/src/types/utility/typesTag.ts

@@ -52,20 +52,19 @@ export function typesTag<T extends AnyType, A>(baseType: T, tag: A, typeName?: s
       return `${taggedName}<${baseTypeName}>`
     }
 
+    const processorPlan = snapshotProcessorPlan(
+      () => [baseChecker],
+      ([processor]) => processor
+    )
+
     const thisTc: TypeChecker = new TypeChecker(
       baseChecker.baseType,
       (data, path, typeCheckedValue) => baseChecker.check(data, path, typeCheckedValue),
       getTypeName,
       typeInfoGen,
       (sn) => baseChecker.snapshotType(sn),
-      snapshotProcessorPlan(
-        () => [baseChecker],
-        ([processor]) => processor
-      ),
-      snapshotProcessorPlan(
-        () => [baseChecker],
-        ([processor]) => processor
-      )
+      processorPlan,
+      processorPlan
     )
 
     return thisTc

package/src/utils/ModelPool.ts

@@ -1,9 +1,6 @@
 import type { AnyModel } from "../model/BaseModel"
-import { getModelIdPropertyName } from "../model/getModelMetadata"
 import { modelIdKey, modelTypeKey } from "../model/metadata"
-import { getSnapshotModelType, isModel } from "../model/utils"
-import type { ModelClass } from "../modelShared/BaseModelShared"
-import { getModelInfoForName } from "../modelShared/modelInfo"
+import { isModel } from "../model/utils"
 import { dataToModelNode } from "../parent/core"
 import {
   type DeepObjectChildrenExtensionAccessor,
@@ -46,20 +43,6 @@ export class ModelPool {
   findModelByTypeAndId(modelType: string, modelId: string | undefined): AnyModel | undefined {
     return modelId !== undefined ? this.pool.get(modelType)?.get(modelId) : undefined
   }
-
-  findModelForSnapshot(sn: any): AnyModel | undefined {
-    const modelType = getSnapshotModelType(sn)
-    if (modelType === undefined) {
-      return undefined
-    }
-
-    const modelInfo = getModelInfoForName(modelType)!
-    const modelIdPropertyName = getModelIdPropertyName(modelInfo.class as ModelClass<AnyModel>)
-
-    return modelIdPropertyName !== undefined
-      ? this.findModelByTypeAndId(modelType, (sn as any)[modelIdPropertyName])
-      : undefined
-  }
 }
 
 let deepChildrenModels: DeepObjectChildrenExtensionAccessor<DeepChildrenModels> | undefined

package/src/utils/decorators.ts

@@ -109,7 +109,7 @@ export function decorateWrapMethodOrField(
     const propertyKey: string = args[1]
     const baseDescriptor: PropertyDescriptor | undefined = args[2]
 
-    checkModelDecoratorTaget(decoratorName, target)
+    checkModelDecoratorTarget(decoratorName, target)
     checkDecoratorContext(decoratorName, propertyKey, false)
 
     const data = getActionNameAndContextOverride(target, propertyKey, true)
@@ -166,7 +166,7 @@ export function decorateWrapMethodOrField(
           inited = true
 
           const target = this
-          checkModelDecoratorTaget(decoratorName, target)
+          checkModelDecoratorTarget(decoratorName, target)
 
           // find the deepest proto that matches the value
           let proto = this
@@ -195,7 +195,7 @@ export function decorateWrapMethodOrField(
           const instance = this
 
           if (!data) {
-            checkModelDecoratorTaget(decoratorName, instance)
+            checkModelDecoratorTarget(decoratorName, instance)
             data = getActionNameAndContextOverride(instance, propertyKey, false)
           }
 
@@ -207,7 +207,7 @@ export function decorateWrapMethodOrField(
       }
 
       default:
-        throw failure(`@${decoratorName} can only be used on fields or methods}`)
+        throw failure(`@${decoratorName} can only be used on fields or methods`)
     }
   }
 }
@@ -270,7 +270,7 @@ function getActionNameAndContextOverride(
   }
 }
 
-function checkModelDecoratorTaget(decoratorName: string, target: any) {
+function checkModelDecoratorTarget(decoratorName: string, target: any) {
   if (!inDevMode) {
     return
   }

package/src/utils/index.ts

@@ -267,15 +267,6 @@ export function assertIsObject(value: unknown, argName: string): asserts value i
   }
 }
 
-/**
- * @internal
- */
-export function assertIsPlainObject(value: unknown, argName: string): asserts value is object {
-  if (!isPlainObject(value)) {
-    throw failure(`${argName} must be a plain object`)
-  }
-}
-
 /**
  * @internal
  */
@@ -342,15 +333,6 @@ export function assertIsPrimitive(
   }
 }
 
-/**
- * @internal
- */
-export function assertIsString(value: unknown, argName: string): asserts value is string {
-  if (typeof value !== "string") {
-    throw failure(`${argName} must be a string`)
-  }
-}
-
 /**
  * @internal
  */
@@ -372,8 +354,7 @@ export function addLateInitializationFunction(
   fn: (instance: any) => void
 ) {
   let array: LateInitializationFunctionsArray | undefined = target[symbol]
-  // biome-ignore lint/suspicious/noPrototypeBuiltins: support old browsers
-  if (!(array && Object.prototype.hasOwnProperty.call(target, symbol))) {
+  if (!(array && hasOwnProp(target, symbol))) {
     // leave base array unmodified, create new array in the derived class
     array = array ? array.slice() : []
     addHiddenProp(target, symbol, array)

package/src/utils/types.ts

@@ -46,3 +46,8 @@ export type IsNeverType<T, IfNever, IfNotNever> = [T] extends [never] ? IfNever
  * @ignore
  */
 export type Flatten<T> = T extends Record<any, any> ? { [P in keyof T]: T[P] } : T
+
+/**
+ * @ignore
+ */
+export type SimplifyObject<T> = { [P in keyof T]: T[P] } & {}

package/src/wrappers/ArraySet.ts

@@ -8,6 +8,15 @@ import { typesArray } from "../types/arrayBased/typesArray"
 import { tProp } from "../types/tProp"
 import { typesUnchecked } from "../types/utility/typesUnchecked"
 import { namespace } from "../utils"
+import {
+  isSetLikeDisjointFrom,
+  isSetLikeSubsetOf,
+  isSetLikeSupersetOf,
+  setLikeDifference,
+  setLikeIntersection,
+  setLikeSymmetricDifference,
+  setLikeUnion,
+} from "../utils/setLike"
 
 const arraySetBase = Model({
   [modelIdKey]: idProp,
@@ -96,39 +105,43 @@ export class ArraySet<V> extends arraySetBase implements Set<V> {
 
   readonly [Symbol.toStringTag] = "ArraySet"
 
+  // `has` scans the items, so the set operations look values up in a set built
+  // on the first lookup instead (not before, since many of them never look up)
+  private toSetLike(): ReadonlySetLike<V> {
+    let lookup: Set<V> | undefined
+    return {
+      size: this.items.length,
+      has: (value) => (lookup ??= new Set(this.items)).has(value),
+      keys: () => this.values(),
+    }
+  }
+
   union<U>(other: ReadonlySetLike<U>): Set<V | U> {
-    const s = new Set(this)
-    return s.union(other)
+    return setLikeUnion(this.toSetLike(), other)
   }
 
   intersection<U>(other: ReadonlySetLike<U>): Set<V & U> {
-    const s = new Set(this)
-    return s.intersection(other)
+    return setLikeIntersection(this.toSetLike(), other)
   }
 
   difference<U>(other: ReadonlySetLike<U>): Set<V> {
-    const s = new Set(this)
-    return s.difference(other)
+    return setLikeDifference(this.toSetLike(), other)
   }
 
   symmetricDifference<U>(other: ReadonlySetLike<U>): Set<V | U> {
-    const s = new Set(this)
-    return s.symmetricDifference(other)
+    return setLikeSymmetricDifference(this.toSetLike(), other)
   }
 
   isSubsetOf(other: ReadonlySetLike<unknown>): boolean {
-    const s = new Set(this)
-    return s.isSubsetOf(other)
+    return isSetLikeSubsetOf(this.toSetLike(), other)
   }
 
   isSupersetOf(other: ReadonlySetLike<unknown>): boolean {
-    const s = new Set(this)
-    return s.isSupersetOf(other)
+    return isSetLikeSupersetOf(this.toSetLike(), other)
   }
 
   isDisjointFrom(other: ReadonlySetLike<unknown>): boolean {
-    const s = new Set(this)
-    return s.isDisjointFrom(other)
+    return isSetLikeDisjointFrom(this.toSetLike(), other)
   }
 }
 

package/src/wrappers/ObjectMap.ts

@@ -70,12 +70,7 @@ export class ObjectMap<V> extends objectMapBase implements Map<string, V> {
   }
 
   getOrInsert(key: string, defaultValue: V): V {
-    if (this.has(key)) {
-      return this.get(key) as V
-    }
-
-    this.set(key, defaultValue)
-    return this.get(key) as V
+    return this.getOrInsertComputed(key, () => defaultValue)
   }
 
   getOrInsertComputed(key: string, callback: (key: string) => V): V {

package/src/wrappers/asMap.ts

@@ -4,8 +4,6 @@ import {
   type IObjectDidChange,
   type IObservableArray,
   intercept,
-  isObservableArray,
-  isObservableObject,
   type ObservableMap,
   observable,
   observe,
@@ -21,7 +19,6 @@ import {
   failure,
   getMobxVersion,
   hasOwnProp,
-  inDevMode,
   isArray,
   isEqualOrBothNaN,
   setProtoProp,
@@ -44,12 +41,7 @@ function addTs6MapExtras<K, V>(map: ObservableMap<K, V>): ObservableMap<K, V> &
 
   if (!mapWithExtras.getOrInsert) {
     mapWithExtras.getOrInsert = function (key: K, defaultValue: V): V {
-      if (this.has(key)) {
-        return this.get(key) as V
-      }
-
-      this.set(key, defaultValue)
-      return this.get(key) as V
+      return this.getOrInsertComputed(key, () => defaultValue)
     }
   }
 
@@ -70,12 +62,6 @@ function addTs6MapExtras<K, V>(map: ObservableMap<K, V>): ObservableMap<K, V> &
 
 const observableMapBackedByObservableObject = action(
   <T>(obj: object): ObservableMapWithDataObject<string, T, typeof obj> => {
-    if (inDevMode) {
-      if (!isObservableObject(obj)) {
-        throw failure("assertion failed: expected an observable object")
-      }
-    }
-
     const map = transaction(() =>
       untracked(() => {
         const map = observable.map<string, T>(undefined, { deep: false })
@@ -175,12 +161,6 @@ const observableMapBackedByObservableObject = action(
 const observableMapBackedByObservableArray = <K, T>(
   array: IObservableArray<[K, T]>
 ): ObservableMapWithDataObject<K, T, typeof array> => {
-  if (inDevMode) {
-    if (!isObservableArray(array)) {
-      throw failure("assertion failed: expected an observable array")
-    }
-  }
-
   const map: ObservableMap<K, T> = untracked(() => {
     if (getMobxVersion() >= 6) {
       return observable.map<K, T>(array, { deep: false })

package/src/wrappers/asSet.ts

@@ -3,7 +3,6 @@ import {
   type IObservableArray,
   type ISetWillChange,
   intercept,
-  isObservableArray,
   type ObservableSet,
   observable,
   observe,
@@ -16,7 +15,6 @@ import {
   assertIsSet,
   failure,
   getMobxVersion,
-  inDevMode,
   isEqualOrBothNaN,
 } from "../utils"
 import { tag } from "../utils/tag"
@@ -24,12 +22,6 @@ import { tag } from "../utils/tag"
 const observableSetBackedByObservableArray = <T>(
   array: IObservableArray<T>
 ): ObservableSet<T> & { dataObject: typeof array } => {
-  if (inDevMode) {
-    if (!isObservableArray(array)) {
-      throw failure("assertion failed: expected an observable array")
-    }
-  }
-
   const set = transaction(() =>
     untracked(() => {
       if (getMobxVersion() >= 6) {