mobx-keystone 1.25.0 → 2.1.0

package/src/types/objectBased/typesDataModelData.ts

@@ -10,7 +10,7 @@ import type {
 import { modelInfoByClass } from "../../modelShared/modelInfo"
 import { getInternalModelClassPropsInfo } from "../../modelShared/modelPropsInfo"
 import { noDefaultValue } from "../../modelShared/prop"
-import { failure, lazy } from "../../utils"
+import { failure, lazy, setProtoProp } from "../../utils"
 import { getTypeInfo } from "../getTypeInfo"
 import {
   registerStandardTypeResolver,
@@ -168,12 +168,14 @@ export class DataModelDataTypeInfo extends TypeInfo {
         hasDefault = true
       }
 
-      propTypes[propName] = {
+      const propInfo = {
         type,
         typeInfo,
         hasDefault,
         default: defaultValue,
       }
+      if (propName === "__proto__") setProtoProp(propTypes, propInfo)
+      else propTypes[propName] = propInfo
     })
     return propTypes
   })

package/src/types/objectBased/typesModel.ts

@@ -7,7 +7,7 @@ import type { ModelClass } from "../../modelShared/BaseModelShared"
 import { modelInfoByClass } from "../../modelShared/modelInfo"
 import { getInternalModelClassPropsInfo } from "../../modelShared/modelPropsInfo"
 import { noDefaultValue } from "../../modelShared/prop"
-import { isObject, lazy } from "../../utils"
+import { isObject, lazy, setProtoProp } from "../../utils"
 import { getTypeInfo } from "../getTypeInfo"
 import { registerStandardTypeResolver, resolveTypeChecker } from "../resolveTypeChecker"
 import type { AnyStandardType, ModelType } from "../schemas"
@@ -178,12 +178,14 @@ export class ModelTypeInfo extends TypeInfo {
         hasDefault = true
       }
 
-      propTypes[propName] = {
+      const propInfo = {
         type,
         typeInfo,
         hasDefault,
         default: defaultValue,
       }
+      if (propName === "__proto__") setProtoProp(propTypes, propInfo)
+      else propTypes[propName] = propInfo
     })
     return propTypes
   })

package/src/types/objectBased/typesObject.ts

@@ -2,7 +2,16 @@ import { isObservableObject, keys } from "mobx"
 import type { O } from "ts-toolbelt"
 import { Frozen } from "../../frozen/Frozen"
 import type { Path } from "../../parent/pathTypes"
-import { assertIsFunction, assertIsObject, getMobxVersion, isObject, lazy } from "../../utils"
+import {
+  assertIsFunction,
+  assertIsObject,
+  copyOwnEnumerableProps,
+  getMobxVersion,
+  isArray,
+  isObject,
+  lazy,
+  setProtoProp,
+} from "../../utils"
 import { withErrorPathSegment } from "../../utils/errorDiagnostics"
 import { createIndexedPerEntryCachedCheck } from "../createCachedTypeCheck"
 import { getTypeInfo } from "../getTypeInfo"
@@ -106,27 +115,20 @@ function typesObjectHelper<S>(objFn: S, frozen: boolean, typeInfoGen: TypeInfoGe
       obj: Record<string, unknown>,
       processors: ReadonlyArray<SnapshotProcessor | undefined>
     ) => {
-      const newObj: typeof obj = {}
-
       // note: we allow excess properties when checking objects
-      const keys = Object.keys(obj)
-      for (let i = 0; i < keys.length; i++) {
-        const k = keys[i]
+      return copyOwnEnumerableProps({}, obj, (value, k) => {
         const schemaEntry = schemaEntryByPropName[k]
         if (schemaEntry) {
           const processor = processors[schemaEntry.processorIndex]
-          newObj[k] = processor ? withErrorPathSegment(k, () => processor(obj[k])) : obj[k]
-        } else {
-          // unknown prop, copy as is
-          newObj[k] = obj[k]
+          return processor ? withErrorPathSegment(k, () => processor(value)) : value
         }
-      }
-
-      return newObj
+        // unknown prop, copy as is
+        return value
+      })
     }
 
     const checkObjectType = (obj: any, path: Path, typeCheckedValue: any) => {
-      if (!isObject(obj) || (frozen && !(obj instanceof Frozen))) {
+      if (!isObject(obj) || isArray(obj) || (frozen && !(obj instanceof Frozen))) {
         return new TypeCheckError({
           path,
           expectedTypeName: getTypeName(thisTc),
@@ -187,7 +189,7 @@ function typesObjectHelper<S>(objFn: S, frozen: boolean, typeInfoGen: TypeInfoGe
       typeInfoGen,
 
       (obj) => {
-        if (!isObject(obj)) {
+        if (!isObject(obj) || isArray(obj)) {
           return null
         }
 
@@ -278,7 +280,9 @@ export class ObjectTypeInfo extends TypeInfo {
     const propTypes: O.Writable<ObjectTypeInfoProps> = {}
     Object.keys(objSchema).forEach((propName) => {
       const type = resolveStandardType(objSchema[propName])
-      propTypes[propName] = { type, typeInfo: getTypeInfo(type) }
+      const propInfo = { type, typeInfo: getTypeInfo(type) }
+      if (propName === "__proto__") setProtoProp(propTypes, propInfo)
+      else propTypes[propName] = propInfo
     })
     return propTypes
   })

package/src/types/objectBased/typesRecord.ts

@@ -1,8 +1,8 @@
 import { isObservableObject, keys } from "mobx"
 import type { Path } from "../../parent/pathTypes"
-import { failure, isObject } from "../../utils"
+import { copyOwnEnumerableProps, failure, isArray, isObject } from "../../utils"
 import { withErrorPathSegment } from "../../utils/errorDiagnostics"
-import { createAdaptiveRecordCachedCheck } from "../createCachedTypeCheck"
+import { createChunkedRecordCachedCheck } from "../createCachedTypeCheck"
 import { getTypeInfo } from "../getTypeInfo"
 import { resolveStandardType, resolveTypeChecker } from "../resolveTypeChecker"
 import type { AnyStandardType, AnyType, RecordType } from "../schemas"
@@ -48,16 +48,9 @@ export function typesRecord<T extends AnyType>(valueType: T): RecordType<T> {
         return obj
       }
 
-      const newObj: typeof obj = {}
-
-      const keys = Object.keys(obj)
-      for (let i = 0; i < keys.length; i++) {
-        const k = keys[i]
-        const v = withErrorPathSegment(k, () => processor(obj[k]))
-        newObj[k] = v
-      }
-
-      return newObj
+      return copyOwnEnumerableProps({}, obj, (value, key) =>
+        withErrorPathSegment(key, () => processor(value))
+      )
     }
 
     const iterateRecordEntries = (
@@ -88,16 +81,13 @@ export function typesRecord<T extends AnyType>(valueType: T): RecordType<T> {
       return error ? prependPathElementToTypeCheckError(error, path, key, typeCheckedValue) : null
     }
 
-    const checkRecordValues = createAdaptiveRecordCachedCheck(
-      iterateRecordEntries,
-      checkRecordEntry
-    )
+    const checkRecordValues = createChunkedRecordCachedCheck(iterateRecordEntries, checkRecordEntry)
 
     const thisTc: TypeChecker = new TypeChecker(
       TypeCheckerBaseType.Object,
 
       (obj, path, typeCheckedValue) => {
-        if (!isObject(obj)) {
+        if (!isObject(obj) || isArray(obj)) {
           return new TypeCheckError({
             path,
             expectedTypeName: getTypeName(thisTc),
@@ -117,7 +107,7 @@ export function typesRecord<T extends AnyType>(valueType: T): RecordType<T> {
       typeInfoGen,
 
       (obj) => {
-        if (!isObject(obj)) {
+        if (!isObject(obj) || isArray(obj)) {
           return null
         }
 

package/src/types/objectBased/typesRef.ts

@@ -1,6 +1,6 @@
 import { modelTypeKey } from "../../model/metadata"
 import { modelInfoByClass } from "../../modelShared/modelInfo"
-import { Ref, type RefConstructor } from "../../ref/Ref"
+import type { Ref, RefConstructor } from "../../ref/Ref"
 import { isObject } from "../../utils"
 import { typesString } from "../primitiveBased/typesPrimitive"
 import { resolveTypeChecker } from "../resolveTypeChecker"
@@ -36,7 +36,7 @@ export function typesRef<O extends object>(refConstructor: RefConstructor<O>): M
     TypeCheckerBaseType.Object,
 
     (value, path, typeCheckedValue) => {
-      if (!(value instanceof Ref)) {
+      if (!(value instanceof refConstructor.refClass)) {
         return new TypeCheckError({
           path,
           expectedTypeName: typeName,

package/src/types/primitiveBased/typesEnum.ts

@@ -1,4 +1,4 @@
-import { assertIsObject } from "../../utils"
+import { assertIsObject, isEqualOrBothNaN } from "../../utils"
 import type { IdentityType } from "../schemas"
 import { typesOr } from "../utility/typesOr"
 import { typesLiteral } from "./typesPrimitive"
@@ -17,6 +17,7 @@ export interface EnumLike {
  */
 export function enumValues(e: EnumLike): (string | number)[] {
   const vals: (string | number)[] = []
+  const seen = new Set<string | number>()
   for (const k of Object.keys(e)) {
     const v = e[k]
     // we have to do this since TS does something weird
@@ -24,7 +25,8 @@ export function enumValues(e: EnumLike): (string | number)[] {
     // Hi = 0 -> { Hi: 0, 0: "Hi" }
     // and SWC currently generates enum code inconsistent with TS/Babel
     // https://github.com/swc-project/swc/issues/3711
-    if (!vals.includes(v) && ((typeof v !== "string" && v !== +k) || e[v] !== +k)) {
+    if (!seen.has(v) && ((typeof v !== "string" && v !== +k) || !isEqualOrBothNaN(e[v], +k))) {
+      seen.add(v)
       vals.push(v)
     }
   }

package/src/types/primitiveBased/typesPrimitive.ts

@@ -1,4 +1,4 @@
-import { assertIsPrimitive } from "../../utils"
+import { assertIsPrimitive, isEqualOrBothNaN } from "../../utils"
 import type { PrimitiveValue } from "../../utils/types"
 import { registerStandardTypeResolver, type StandardTypeResolverFn } from "../resolveTypeChecker"
 import type { AnyStandardType, IdentityType } from "../schemas"
@@ -31,7 +31,12 @@ export function typesLiteral<T extends PrimitiveValue>(literal: T): IdentityType
       typeName = "null"
       break
     default:
-      typeName = JSON.stringify(literal)
+      typeName =
+        typeof literal === "bigint"
+          ? `${literal}n`
+          : typeof literal === "number" && !Number.isFinite(literal)
+            ? String(literal)
+            : JSON.stringify(literal)
       break
   }
 
@@ -41,7 +46,7 @@ export function typesLiteral<T extends PrimitiveValue>(literal: T): IdentityType
     TypeCheckerBaseType.Primitive,
 
     (value, path, typeCheckedValue) =>
-      value === literal
+      isEqualOrBothNaN(value, literal)
         ? null
         : new TypeCheckError({
             path,
@@ -53,7 +58,7 @@ export function typesLiteral<T extends PrimitiveValue>(literal: T): IdentityType
     () => typeName,
     typeInfoGen,
 
-    (value) => (value === literal ? thisTc : null),
+    (value) => (isEqualOrBothNaN(value, literal) ? thisTc : null),
     undefined,
     undefined
   )

package/src/types/typeCheckErrorUtils.ts

@@ -16,6 +16,7 @@ export function prependPathElementToTypeCheckError(
 
   return new TypeCheckError({
     path: fullPath,
+    modelTrail: valueError.modelTrail,
     expectedTypeName: valueError.expectedTypeName,
     actualValue: valueError.actualValue,
     typeCheckedValue,

package/src/types/utility/typesCodecSupport.ts

@@ -1,6 +1,6 @@
 import { isObservableArray, isObservableObject, remove } from "mobx"
 import type { ModelPropTransform } from "../../modelShared/prop"
-import { isArray, isObject, lazy } from "../../utils"
+import { copyOwnEnumerableProps, isArray, isObject, lazy } from "../../utils"
 import { setIfDifferent } from "../../utils/setIfDifferent"
 import { ArrayTypeInfo, typesArray } from "../arrayBased/typesArray"
 import { TupleTypeInfo, typesTuple } from "../arrayBased/typesTuple"
@@ -19,23 +19,26 @@ import {
   type RuntimeAdapter,
 } from "./typesCodecCore"
 import { OrTypeInfo, typesOr } from "./typesOr"
-import { RefinementTypeInfo } from "./typesRefinement"
+import { RefinementTypeInfo, typesRefinement } from "./typesRefinement"
 import { SkipCheckTypeInfo, typesSkipCheck } from "./typesSkipCheck"
 import { TagTypeInfo, typesTag } from "./typesTag"
 
 const codecSupportCache = new WeakMap<AnyStandardType, ResolvedCodecSupport>()
 
 function getArrayIndex(prop: PropertyKey): number | undefined {
-  // Proxy get/set traps always receive string|symbol keys (ECMAScript ToPropertyKey),
-  // so we only need to check for string numeric indices.
-  if (typeof prop === "string" && /^(0|[1-9]\d*)$/.test(prop)) {
-    return Number(prop)
-  }
-
-  return undefined
+  // Proxy traps receive string or symbol keys, including strings for numeric indices.
+  if (typeof prop !== "string") return undefined
+  const first = prop.charCodeAt(0)
+  if (first < 48 || first > 57) return undefined
+
+  const index = Number(prop)
+  return Number.isInteger(index) && index >= 0 && index < 0xffffffff && String(index) === prop
+    ? index
+    : undefined
 }
 
 function normalizeArrayIndex(index: number, length: number): number {
+  index = Math.trunc(index) || 0
   if (index < 0) {
     return Math.max(length + index, 0)
   }
@@ -44,6 +47,7 @@ function normalizeArrayIndex(index: number, length: number): number {
 }
 
 function resolveArrayAtIndex(index: number, length: number): number | undefined {
+  index = Math.trunc(index) || 0
   const resolvedIndex = index < 0 ? length + index : index
 
   if (resolvedIndex < 0 || resolvedIndex >= length) {
@@ -90,11 +94,7 @@ function objectLikeToStored(
     return runtime as never
   }
 
-  const stored: Record<string, unknown> = {}
-  for (const key of Object.keys(runtime)) {
-    stored[key] = convertValue(key, runtime[key])
-  }
-  return stored
+  return copyOwnEnumerableProps({}, runtime, (value, key) => convertValue(key, value))
 }
 
 /**
@@ -155,8 +155,7 @@ function createObjectRuntimeAdapter(
             }
           }
 
-          Reflect.set(target, prop, value)
-          return true
+          return Reflect.set(target, prop, value)
         },
 
         ...objectRecordProxyTraps,
@@ -217,8 +216,7 @@ function createRecordRuntimeAdapter(
             return true
           }
 
-          Reflect.set(target, prop, value)
-          return true
+          return Reflect.set(target, prop, value)
         },
 
         ...objectRecordProxyTraps,
@@ -250,7 +248,9 @@ function createArrayLikeRuntimeAdapter(
   const storedByRuntime = new WeakMap<unknown[], unknown[]>()
 
   const decodeIndex = (target: unknown[], index: number) =>
-    index < 0 || index >= target.length || !Reflect.has(target, index)
+    index < 0 ||
+    index >= target.length ||
+    (!isObservableArray(target) && !Reflect.has(target, index))
       ? undefined
       : getItemAdapter(index).toRuntime(target[index], (newStoredValue) => {
           target[index] = newStoredValue
@@ -265,13 +265,18 @@ function createArrayLikeRuntimeAdapter(
     return Reflect.apply(method, receiver, args)
   }
   const materializeRuntimeValues = (target: unknown[]) =>
-    Array.from({ length: target.length }, (_, index) => decodeIndex(target, index))
+    target.map((_value, index) => decodeIndex(target, index))
   const replaceStoredValues = (target: unknown[], runtimeValues: unknown[]) => {
-    target.splice(
-      0,
-      target.length,
-      ...runtimeValues.map((value, index) => getItemAdapter(index).toStored(value))
-    )
+    const storedValues = runtimeValues.map((value, index) => getItemAdapter(index).toStored(value))
+    if (isObservableArray(target)) {
+      target.replace(storedValues)
+    } else {
+      target.length = storedValues.length
+      for (let i = 0; i < storedValues.length; i++) {
+        if (i in storedValues) target[i] = storedValues[i]
+        else delete target[i]
+      }
+    }
   }
   const mutateViaRuntime = (
     target: unknown[],
@@ -296,6 +301,11 @@ function createArrayLikeRuntimeAdapter(
       }
 
       const proxy: unknown[] = new Proxy(stored, {
+        has(target, prop) {
+          const index = getArrayIndex(prop)
+          if (index !== undefined && isObservableArray(target)) return index < target.length
+          return Reflect.has(target, prop)
+        },
         get(target, prop, receiver) {
           const index = getArrayIndex(prop)
           if (index !== undefined) {
@@ -332,8 +342,9 @@ function createArrayLikeRuntimeAdapter(
                 }
 
                 const indexValue = target.length - 1
+                const present = isObservableArray(target) || indexValue in target
                 const value = target.pop()
-                return getItemAdapter(indexValue).toRuntime(value)
+                return present ? getItemAdapter(indexValue).toRuntime(value) : undefined
               }
             case "shift":
               return () => {
@@ -341,8 +352,9 @@ function createArrayLikeRuntimeAdapter(
                   return undefined
                 }
 
+                const present = isObservableArray(target) || 0 in target
                 const value = target.shift()
-                return getItemAdapter(0).toRuntime(value)
+                return present ? getItemAdapter(0).toRuntime(value) : undefined
               }
             case "unshift":
               return (...items: unknown[]) =>
@@ -350,12 +362,21 @@ function createArrayLikeRuntimeAdapter(
                   ...items.map((item, indexValue) => getItemAdapter(indexValue).toStored(item))
                 )
             case "splice":
-              return (start: number, deleteCount?: number, ...items: unknown[]) => {
+              return (...args: [start?: number, deleteCount?: number, ...items: unknown[]]) => {
+                const [start = 0, deleteCount, ...items] = args
                 const normalizedStart = normalizeArrayIndex(start, target.length)
                 const actualDeleteCount =
-                  deleteCount === undefined
-                    ? target.length - normalizedStart
-                    : Math.max(0, Math.min(deleteCount, target.length - normalizedStart))
+                  args.length === 0
+                    ? 0
+                    : args.length === 1
+                      ? target.length - normalizedStart
+                      : Math.max(
+                          0,
+                          Math.min(
+                            Math.trunc(deleteCount ?? 0) || 0,
+                            target.length - normalizedStart
+                          )
+                        )
 
                 const removedValues = target
                   .slice(normalizedStart, normalizedStart + actualDeleteCount)
@@ -443,8 +464,7 @@ function createArrayLikeRuntimeAdapter(
             return true
           }
 
-          Reflect.set(target, prop, value)
-          return true
+          return Reflect.set(target, prop, value)
         },
       })
 
@@ -461,7 +481,7 @@ function createArrayLikeRuntimeAdapter(
           return cachedStored
         }
 
-        return Array.from(runtime, (value, index) => getItemAdapter(index).toStored(value))
+        return runtime.map((value, index) => getItemAdapter(index).toStored(value))
       }
 
       return runtime as never
@@ -490,44 +510,55 @@ function createCodecLeafRuntimeAdapter(
     toRuntime(stored, setStored) {
       const cachedRuntime = isObject(stored) ? runtimeByStored.get(stored) : undefined
 
-      const runtime = transform.transform({
+      // 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.
+      let runtime: unknown
+      let storedChanged = false
+      runtime = transform.transform({
         originalValue: stored,
         cachedTransformedValue: cachedRuntime,
         setOriginalValue(newStoredValue) {
           if (setStored) {
-            setStored(newStoredValue)
+            try {
+              setStored(newStoredValue)
+            } finally {
+              // A retained codec setter can replace the value after decoding. Neither
+              // direction of the cache may keep associating it with the old stored value.
+              storedChanged = true
+              if (isObject(runtime)) storedByRuntime.delete(runtime)
+              if (isObject(stored)) runtimeByStored.delete(stored)
+            }
           }
         },
       })
 
-      if (isObject(runtime)) {
-        storedByRuntime.set(runtime, stored)
-      }
-
-      if (isObject(stored)) {
-        runtimeByStored.set(stored, runtime)
+      if (!storedChanged) {
+        if (isObject(runtime)) storedByRuntime.set(runtime, stored)
+        if (isObject(stored)) runtimeByStored.set(stored, runtime)
       }
 
       return runtime
     },
 
     toStored(runtime) {
-      const cachedStored = isObject(runtime) ? storedByRuntime.get(runtime) : undefined
-      if (cachedStored !== undefined) {
-        return cachedStored
+      if (isObject(runtime)) {
+        const cachedStored = storedByRuntime.get(runtime)
+        if (cachedStored !== undefined || storedByRuntime.has(runtime)) {
+          return cachedStored
+        }
       }
 
+      let cacheResult = false
       const stored = transform.untransform({
         transformedValue: runtime,
-        cacheTransformedValue: () => {},
+        cacheTransformedValue: () => {
+          cacheResult = true
+        },
       })
 
-      if (isObject(runtime)) {
-        storedByRuntime.set(runtime, stored)
-      }
-
-      if (isObject(stored)) {
-        runtimeByStored.set(stored, runtime)
+      if (cacheResult) {
+        if (isObject(runtime)) storedByRuntime.set(runtime, stored)
+        if (isObject(stored)) runtimeByStored.set(stored, runtime)
       }
 
       return stored
@@ -536,7 +567,7 @@ function createCodecLeafRuntimeAdapter(
     toStoredIfCached(runtime) {
       if (isObject(runtime)) {
         const cachedStored = storedByRuntime.get(runtime)
-        if (cachedStored !== undefined) {
+        if (cachedStored !== undefined || storedByRuntime.has(runtime)) {
           return { found: true, value: cachedStored }
         }
       }
@@ -675,7 +706,7 @@ function resolveCodecSupportForStandardType(type: AnyStandardType): ResolvedCode
           }
     } else if (typeInfo instanceof ObjectTypeInfo) {
       const childSupports = lazy(() => {
-        const supports: Record<string, ResolvedCodecSupport> = {}
+        const supports: Record<string, ResolvedCodecSupport> = Object.create(null)
         const props = typeInfo.props
         for (const propName of Object.keys(props)) {
           supports[propName] = resolveCodecSupportForStandardType(props[propName].type)
@@ -690,7 +721,7 @@ function resolveCodecSupportForStandardType(type: AnyStandardType): ResolvedCode
         : {
             hasCodec: true,
             storedType: typesObject(() => {
-              const storedProps: Record<string, AnyStandardType> = {}
+              const storedProps: Record<string, AnyStandardType> = Object.create(null)
               const props = typeInfo.props
               for (const propName of Object.keys(props)) {
                 storedProps[propName] = childSupports()[propName].storedType
@@ -722,7 +753,17 @@ function resolveCodecSupportForStandardType(type: AnyStandardType): ResolvedCode
     } else if (typeInfo instanceof RefinementTypeInfo) {
       const baseSupport = resolveCodecSupportForStandardType(typeInfo.baseType)
 
-      resolvedSupport = baseSupport.hasCodec ? baseSupport : noCodecSupport(type)
+      resolvedSupport = !baseSupport.hasCodec
+        ? noCodecSupport(type)
+        : {
+            hasCodec: true,
+            storedType: typesRefinement(
+              baseSupport.storedType,
+              (stored) => typeInfo.checkFunction(baseSupport.adapter.toRuntime(stored)),
+              typeInfo.typeName
+            ),
+            adapter: baseSupport.adapter,
+          }
     } else if (typeInfo instanceof SkipCheckTypeInfo) {
       const baseSupport = resolveCodecSupportForStandardType(typeInfo.baseType)