mobx-keystone 2.2.0 → 2.3.1

package/src/types/objectBased/typesObjectMap.ts

@@ -6,7 +6,6 @@ import { ObjectMap } from "../../wrappers/ObjectMap"
 import { getTypeInfo } from "../getTypeInfo"
 import { resolveStandardType, resolveTypeChecker } from "../resolveTypeChecker"
 import type { AnyStandardType, AnyType, ModelType, TypeToData } from "../schemas"
-import { TypeCheckError } from "../TypeCheckError"
 import {
   lateTypeChecker,
   snapshotProcessorPlan,
@@ -15,6 +14,7 @@ import {
   TypeInfo,
   type TypeInfoGen,
 } from "../TypeChecker"
+import { TypeCheckError } from "../TypeCheckError"
 import { resolveCodecSupport } from "../utility/typesCodec"
 import { typesObject } from "./typesObject"
 import { typesRecord } from "./typesRecord"

package/src/types/objectBased/typesRecord.ts

@@ -6,7 +6,6 @@ import { createChunkedRecordCachedCheck } from "../createCachedTypeCheck"
 import { getTypeInfo } from "../getTypeInfo"
 import { resolveStandardType, resolveTypeChecker } from "../resolveTypeChecker"
 import type { AnyStandardType, AnyType, RecordType } from "../schemas"
-import { TypeCheckError } from "../TypeCheckError"
 import {
   lateTypeChecker,
   snapshotProcessorPlan,
@@ -15,6 +14,7 @@ import {
   TypeInfo,
   type TypeInfoGen,
 } from "../TypeChecker"
+import { TypeCheckError } from "../TypeCheckError"
 import { prependPathElementToTypeCheckError } from "../typeCheckErrorUtils"
 
 /**

package/src/types/objectBased/typesRef.ts

@@ -1,12 +1,19 @@
 import { modelTypeKey } from "../../model/metadata"
+import { isModel } from "../../model/utils"
 import { modelInfoByClass } from "../../modelShared/modelInfo"
 import type { Ref, RefConstructor } from "../../ref/Ref"
 import { isObject } from "../../utils"
+import {
+  isModelInstanceOfModelName,
+  isUnrelatedSnapshotModelType,
+  snapshotModelTypeMatches,
+} from "../modelTypeMatching"
 import { typesString } from "../primitiveBased/typesPrimitive"
 import { resolveTypeChecker } from "../resolveTypeChecker"
 import type { ModelType } from "../schemas"
-import { TypeCheckError } from "../TypeCheckError"
+import { SnapshotTypeMismatchError } from "../SnapshotTypeMismatchError"
 import { TypeChecker, TypeCheckerBaseType, TypeInfo } from "../TypeChecker"
+import { TypeCheckError } from "../TypeCheckError"
 import { typesObject } from "./typesObject"
 
 /**
@@ -36,7 +43,10 @@ export function typesRef<O extends object>(refConstructor: RefConstructor<O>): M
     TypeCheckerBaseType.Object,
 
     (value, path, typeCheckedValue) => {
-      if (!(value instanceof refConstructor.refClass)) {
+      if (
+        !(value instanceof refConstructor.refClass) &&
+        !(isModel(value) && isModelInstanceOfModelName(value, modelInfo.name))
+      ) {
         return new TypeCheckError({
           path,
           expectedTypeName: typeName,
@@ -56,16 +66,25 @@ export function typesRef<O extends object>(refConstructor: RefConstructor<O>): M
         return null
       }
 
-      if (obj[modelTypeKey] !== undefined) {
+      const snModelType = obj[modelTypeKey]
+      if (snModelType !== undefined) {
         // fast check
-        return obj[modelTypeKey] === modelInfo.name ? thisTc : null
+        return snapshotModelTypeMatches(snModelType, modelInfo.name) ? thisTc : null
       }
 
       return refDataTypeChecker.snapshotType(obj) ? thisTc : null
     },
 
     (sn: Record<string, unknown>) => {
-      if (sn[modelTypeKey]) {
+      const snModelType = sn[modelTypeKey]
+      if (typeof snModelType === "string") {
+        // the snapshot names its own model; make sure it is this ref or a subclass of it
+        if (isUnrelatedSnapshotModelType(snModelType, modelInfo.name)) {
+          throw new SnapshotTypeMismatchError({
+            expectedTypeName: typeName,
+            actualValue: sn,
+          })
+        }
         return sn
       } else {
         return {

package/src/types/primitiveBased/typesPrimitive.ts

@@ -2,8 +2,8 @@ import { assertIsPrimitive, isEqualOrBothNaN } from "../../utils"
 import type { PrimitiveValue } from "../../utils/types"
 import { registerStandardTypeResolver, type StandardTypeResolverFn } from "../resolveTypeChecker"
 import type { AnyStandardType, IdentityType } from "../schemas"
-import { TypeCheckError } from "../TypeCheckError"
 import { TypeChecker, TypeCheckerBaseType, TypeInfo, type TypeInfoGen } from "../TypeChecker"
+import { TypeCheckError } from "../TypeCheckError"
 
 const standardTypeResolvers: StandardTypeResolverFn[] = []
 

package/src/types/schemas.ts

@@ -96,7 +96,7 @@ type ObjectSnapshotOutData<S, OK = ObjectOptionalKeys<S>> = SimplifyObject<
 export interface ObjectType<S> extends Type<"object", ObjectData<S>> {}
 
 export interface ObjectTypeFunction {
-  // biome-ignore lint/style/useShorthandFunctionType: make the type recursive
+  // oxlint-disable-next-line typescript/prefer-function-type -- make the type recursive
   (): ObjectOfTypes
 }
 

package/src/types/utility/typesCodecCore.ts

@@ -1,6 +1,7 @@
 import type { ModelPropTransform } from "../../modelShared/prop"
 import { lazy } from "../../utils"
 import { getTypeInfo } from "../getTypeInfo"
+import { runInModelTypeMatchingPass } from "../modelTypeMatching"
 import { resolveStandardType, resolveTypeChecker } from "../resolveTypeChecker"
 import type {
   AnyStandardType,
@@ -10,7 +11,6 @@ import type {
   TypeToSnapshotIn,
   TypeToSnapshotOut,
 } from "../schemas"
-import { TypeCheckError } from "../TypeCheckError"
 import {
   lateTypeChecker,
   TypeChecker,
@@ -18,6 +18,7 @@ import {
   TypeInfo,
   type TypeInfoGen,
 } from "../TypeChecker"
+import { TypeCheckError } from "../TypeCheckError"
 import type { TypeToStoredData } from "./typeToStoredData"
 
 export interface RuntimeAdapter<Stored, Runtime> {
@@ -145,7 +146,8 @@ export function createCodecType<TEncodedType extends AnyType, TRuntime>(
       () => typeName,
       typeInfoGen,
 
-      (value) => (is(value) ? thisTc : null),
+      // user code, so it must not see the model type matching pass of an outer union
+      (value) => (runInModelTypeMatchingPass("none", is, value, undefined) ? thisTc : null),
 
       (snapshot) => {
         const processedSnapshot = encodedTypeChecker.fromSnapshotProcessor(snapshot)

package/src/types/utility/typesCodecSupport.ts

@@ -5,6 +5,7 @@ import { setIfDifferent } from "../../utils/setIfDifferent"
 import { ArrayTypeInfo, typesArray } from "../arrayBased/typesArray"
 import { TupleTypeInfo, typesTuple } from "../arrayBased/typesTuple"
 import { getTypeInfo } from "../getTypeInfo"
+import { findClosestModelTypeMatch, findFirstMatch } from "../modelTypeMatching"
 import { isDataModelDataStandardType } from "../objectBased/typesDataModelData"
 import { isModelStandardType } from "../objectBased/typesModel"
 import { ObjectTypeInfo, typesObject } from "../objectBased/typesObject"
@@ -274,6 +275,7 @@ function createArrayLikeRuntimeAdapter(
       target.length = storedValues.length
       for (let i = 0; i < storedValues.length; i++) {
         if (i in storedValues) target[i] = storedValues[i]
+        // oxlint-disable-next-line typescript/no-array-delete -- keep the holes of sparse arrays
         else delete target[i]
       }
     }
@@ -512,6 +514,7 @@ function createCodecLeafRuntimeAdapter(
 
       // Declared up front (rather than initialized from the call) so that a setter invoked
       // while decoding can read it without hitting the temporal dead zone.
+      // oxlint-disable-next-line eslint/prefer-const -- see above
       let runtime: unknown
       let storedChanged = false
       runtime = transform.transform({
@@ -577,6 +580,13 @@ function createCodecLeafRuntimeAdapter(
   }
 }
 
+function matchCodecSupport(
+  support: ResolvedCodecSupport,
+  value: unknown
+): ResolvedCodecSupport | undefined {
+  return resolveTypeChecker(support.storedType).snapshotType(value) ? support : undefined
+}
+
 function createOrRuntimeAdapter(
   childTypes: ReadonlyArray<AnyStandardType>,
   getChildSupports: () => ReadonlyArray<ResolvedCodecSupport>,
@@ -607,14 +617,12 @@ function createOrRuntimeAdapter(
     }
 
     const supports = getChildSupports()
-    for (let i = 0; i < supports.length; i++) {
-      const storedTypeChecker = resolveTypeChecker(supports[i].storedType)
-      if (storedTypeChecker.snapshotType(value)) {
-        return supports[i]
-      }
-    }
+    // prefer branches whose (possibly nested) models are the closest to the snapshot ones
+    const matchingSupport = isObject(value)
+      ? findClosestModelTypeMatch(supports, matchCodecSupport, value)
+      : findFirstMatch(supports, matchCodecSupport, value)
 
-    return supports[0]
+    return matchingSupport ?? supports[0]
   }
 
   return {

package/src/types/utility/typesOr.ts

@@ -1,13 +1,21 @@
+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,
   resolveTypeChecker,
 } from "../resolveTypeChecker"
-import { SnapshotTypeMismatchError } from "../SnapshotTypeMismatchError"
 import type { AnyStandardType, AnyType } from "../schemas"
-import { TypeCheckError } from "../TypeCheckError"
+import { SnapshotTypeMismatchError } from "../SnapshotTypeMismatchError"
 import {
   getTypeCheckerBaseTypeFromValue,
   lateTypeChecker,
@@ -17,6 +25,7 @@ import {
   TypeInfo,
   type TypeInfoGen,
 } from "../TypeChecker"
+import { TypeCheckError } from "../TypeCheckError"
 import { typesUnchecked } from "./typesUnchecked"
 
 /**
@@ -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

@@ -1,7 +1,6 @@
 import { getTypeInfo } from "../getTypeInfo"
 import { resolveStandardType, resolveTypeChecker } from "../resolveTypeChecker"
 import type { AnyStandardType, AnyType, TypeToData } from "../schemas"
-import { TypeCheckError } from "../TypeCheckError"
 import {
   lateTypeChecker,
   snapshotProcessorPlan,
@@ -9,6 +8,7 @@ import {
   TypeInfo,
   type TypeInfoGen,
 } from "../TypeChecker"
+import { TypeCheckError } from "../TypeCheckError"
 
 /**
  * A refinement over a given type. This allows you to do extra checks

package/src/utils/index.ts

@@ -117,7 +117,7 @@ export let hasOwnProp: (object: object, propName: PropertyKey) => boolean = (
     typeof Object.hasOwn === "function"
       ? Object.hasOwn
       : (object, propName) => {
-          // biome-ignore lint/suspicious/noPrototypeBuiltins: legacy fallback for runtimes without Object.hasOwn.
+          // oxlint-disable-next-line eslint/no-prototype-builtins -- legacy fallback for runtimes without Object.hasOwn.
           return Object.prototype.hasOwnProperty.call(object, propName)
         }
 
@@ -133,7 +133,7 @@ export let hasOwnProp: (object: object, propName: PropertyKey) => boolean = (
  * @internal
  */
 export function isEqualOrBothNaN(a: unknown, b: unknown): boolean {
-  // biome-ignore lint/suspicious/noSelfCompare: NaN check
+  // oxlint-disable-next-line eslint/no-self-compare -- NaN check
   return a === b || (a !== a && b !== b)
 }
 
@@ -244,19 +244,26 @@ export function isArray(val: unknown): val is any[] | IObservableArray {
   return Array.isArray(val) || isObservableArray(val)
 }
 
-declare const process:
-  | {
-      env?: Record<string, string | undefined>
-    }
-  | undefined
+declare const process: {
+  env: Record<string, string | undefined>
+}
+
+function readInDevMode(): boolean {
+  // Bundlers replace the literal expression `process.env.NODE_ENV` with a string, so it must stay
+  // spelled out in full (no optional chaining, destructuring or `typeof process` guard) for dev
+  // mode to work in browser bundles. The try/catch keeps the library loadable where there is
+  // neither a bundler replacement nor a global `process`.
+  try {
+    return process.env.NODE_ENV !== undefined && process.env.NODE_ENV !== "production"
+  } catch {
+    return false
+  }
+}
 
 /**
  * @internal
  */
-export const inDevMode =
-  typeof process !== "undefined" &&
-  process?.env?.NODE_ENV !== undefined &&
-  process.env.NODE_ENV !== "production"
+export const inDevMode = readInDevMode()
 
 /**
  * @internal
@@ -390,11 +397,11 @@ export function logWarning(type: "warn" | "error", msg: string, uniqueKey?: stri
   msg = "[mobx-keystone] " + msg
   switch (type) {
     case "warn":
-      // biome-ignore lint/suspicious/noConsole: this internal helper intentionally emits user-facing warnings.
+      // oxlint-disable-next-line eslint/no-console -- this internal helper intentionally emits user-facing warnings.
       console.warn(msg)
       break
     case "error":
-      // biome-ignore lint/suspicious/noConsole: this internal helper intentionally emits user-facing errors.
+      // oxlint-disable-next-line eslint/no-console -- this internal helper intentionally emits user-facing errors.
       console.error(msg)
       break
     default:

package/src/wrappers/ArraySet.ts

@@ -1,7 +1,7 @@
 import { modelAction } from "../action/modelAction"
 import type { AnyModel } from "../model/BaseModel"
-import { Model } from "../model/Model"
 import { modelIdKey } from "../model/metadata"
+import { Model } from "../model/Model"
 import { model } from "../modelShared/modelDecorator"
 import { idProp } from "../modelShared/prop"
 import { typesArray } from "../types/arrayBased/typesArray"
@@ -21,9 +21,7 @@ import {
 const arraySetBase = Model({
   [modelIdKey]: idProp,
   items: tProp(typesArray(typesUnchecked<any>()), () => []), // will be properly checked by types.arraySet(subType)
-}) as abstract new (
-  data: any
-) => AnyModel & {
+}) as abstract new (data: any) => AnyModel & {
   readonly $: {
     items: any[]
   }
@@ -35,7 +33,7 @@ const arraySetBase = Model({
  * Use `arraySet` to create it.
  */
 @model(`${namespace}/ArraySet`)
-// biome-ignore lint/suspicious/noUnsafeDeclarationMerging: model base defines these properties at runtime.
+// oxlint-disable-next-line typescript/no-unsafe-declaration-merging -- model base defines these properties at runtime.
 export class ArraySet<V> extends arraySetBase implements Set<V> {
   @modelAction
   add(value: V): this {

package/src/wrappers/ObjectMap.ts

@@ -1,8 +1,8 @@
 import { entries, get, has, keys, remove, values } from "mobx"
 import { modelAction } from "../action/modelAction"
 import type { AnyModel } from "../model/BaseModel"
-import { Model } from "../model/Model"
 import { modelIdKey } from "../model/metadata"
+import { Model } from "../model/Model"
 import { model } from "../modelShared/modelDecorator"
 import { idProp } from "../modelShared/prop"
 import { typesRecord } from "../types/objectBased/typesRecord"
@@ -14,9 +14,7 @@ import { setIfDifferent } from "../utils/setIfDifferent"
 const objectMapBase = Model({
   [modelIdKey]: idProp,
   items: tProp(typesRecord(typesUnchecked<any>()), () => ({})), // will be properly checked by types.objectMap(subType)
-}) as abstract new (
-  data: any
-) => AnyModel & {
+}) as abstract new (data: any) => AnyModel & {
   readonly $: {
     items: Record<string, any>
   }
@@ -28,7 +26,7 @@ const objectMapBase = Model({
  * Use `objectMap` to create it.
  */
 @model(`${namespace}/ObjectMap`)
-// biome-ignore lint/suspicious/noUnsafeDeclarationMerging: model base defines these properties at runtime.
+// oxlint-disable-next-line typescript/no-unsafe-declaration-merging -- model base defines these properties at runtime.
 export class ObjectMap<V> extends objectMapBase implements Map<string, V> {
   @modelAction
   clear(): void {