mobx-keystone 2.1.0 → 2.2.0

package/src/types/utility/typesCodecCore.ts

@@ -45,6 +45,11 @@ type CodecConfig<TEncodedType extends AnyType, TRuntime> = {
   is(value: unknown): value is TRuntime
 } & ModelPropTransform<TypeToData<TEncodedType>, TRuntime>
 
+// 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
+/**
+ * A codec type whose snapshot and stored forms are those of its encoded type.
+ */
 export type CodecFromEncoded<TEncodedType extends AnyType, TRuntime> = CodecType<
   TRuntime,
   TypeToSnapshotIn<TEncodedType>,

package/src/types/utility/typesCodecSupport.ts

@@ -1,6 +1,6 @@
 import { isObservableArray, isObservableObject, remove } from "mobx"
 import type { ModelPropTransform } from "../../modelShared/prop"
-import { copyOwnEnumerableProps, isArray, isObject, lazy } from "../../utils"
+import { copyOwnEnumerableProps, hasOwnProp, isArray, isObject, lazy } from "../../utils"
 import { setIfDifferent } from "../../utils/setIfDifferent"
 import { ArrayTypeInfo, typesArray } from "../arrayBased/typesArray"
 import { TupleTypeInfo, typesTuple } from "../arrayBased/typesTuple"
@@ -136,7 +136,7 @@ function createObjectRuntimeAdapter(
         get(target, prop, receiver) {
           if (typeof prop === "string") {
             const childSupport = getChildSupports()[prop]
-            if (childSupport && Object.hasOwn(target, prop)) {
+            if (childSupport && hasOwnProp(target, prop)) {
               return childSupport.adapter.toRuntime(target[prop], (newStoredValue) => {
                 target[prop] = newStoredValue
               })
@@ -200,7 +200,7 @@ function createRecordRuntimeAdapter(
 
       const proxy = new Proxy(stored, {
         get(target, prop, receiver) {
-          if (typeof prop === "string" && Object.hasOwn(target, prop)) {
+          if (typeof prop === "string" && hasOwnProp(target, prop)) {
             const valueSupport = getValueSupport()
             return valueSupport.adapter.toRuntime(target[prop], (newStoredValue) => {
               target[prop] = newStoredValue

package/src/types/utility/typesMap.ts

@@ -41,18 +41,14 @@ function makeMapProxy<TKeyStored, TKeyRuntime, TValueStored, TValueRuntime>(
             return getValue(storedKey)
           }
         case "getOrInsert":
-          return (key: TKeyRuntime, defaultValue: TValueRuntime) => {
-            const storedKey = keyAdapter.toStored(key)
-            if (!target.has(storedKey)) {
-              target.set(storedKey, valueAdapter.toStored(defaultValue))
-            }
-            return getValue(storedKey)
-          }
         case "getOrInsertComputed":
-          return (key: TKeyRuntime, callback: (key: TKeyRuntime) => TValueRuntime) => {
+          return (key: TKeyRuntime, valueOrCallback: unknown) => {
             const storedKey = keyAdapter.toStored(key)
             if (!target.has(storedKey)) {
-              const value = callback(key)
+              const value =
+                prop === "getOrInsert"
+                  ? (valueOrCallback as TValueRuntime)
+                  : (valueOrCallback as (key: TKeyRuntime) => TValueRuntime)(key)
               target.set(storedKey, valueAdapter.toStored(value))
             }
             return getValue(storedKey)
@@ -114,10 +110,18 @@ function makeMapProxy<TKeyStored, TKeyRuntime, TValueStored, TValueRuntime>(
   }) as unknown as Map<TKeyRuntime, TValueRuntime>
 }
 
-function makeObjectBackedMapTransform<TStoredValue, TRuntimeValue>(
-  valueAdapter: RuntimeAdapter<TStoredValue, TRuntimeValue>
-): ModelPropTransform<Record<string, TStoredValue>, Map<string, TRuntimeValue>> {
-  const storedByRuntime = new WeakMap<Map<string, TRuntimeValue>, Record<string, TStoredValue>>()
+function makeMapTransform<
+  TStored extends object,
+  TKeyStored,
+  TKeyRuntime,
+  TValueStored,
+  TValueRuntime,
+>(
+  keyAdapter: RuntimeAdapter<TKeyStored, TKeyRuntime>,
+  valueAdapter: RuntimeAdapter<TValueStored, TValueRuntime>,
+  toStored: (runtimeMap: Map<TKeyRuntime, TValueRuntime>) => TStored
+): ModelPropTransform<TStored, Map<TKeyRuntime, TValueRuntime>> {
+  const storedByRuntime = new WeakMap<Map<TKeyRuntime, TValueRuntime>, TStored>()
 
   return {
     transform({ originalValue, cachedTransformedValue }) {
@@ -125,63 +129,51 @@ function makeObjectBackedMapTransform<TStoredValue, TRuntimeValue>(
         return cachedTransformedValue
       }
 
-      const runtimeMap = makeMapProxy(asMap(originalValue), identityRuntimeAdapter, valueAdapter)
+      const runtimeMap = makeMapProxy(
+        asMap(originalValue as any) as Map<TKeyStored, TValueStored>,
+        keyAdapter,
+        valueAdapter
+      )
 
       storedByRuntime.set(runtimeMap, originalValue)
       return runtimeMap
     },
 
     untransform({ transformedValue }) {
-      const cachedStored = storedByRuntime.get(transformedValue)
-      if (cachedStored) {
-        return cachedStored
-      }
+      return storedByRuntime.get(transformedValue) ?? toStored(transformedValue)
+    },
+  }
+}
 
+function makeObjectBackedMapTransform<TStoredValue, TRuntimeValue>(
+  valueAdapter: RuntimeAdapter<TStoredValue, TRuntimeValue>
+): ModelPropTransform<Record<string, TStoredValue>, Map<string, TRuntimeValue>> {
+  return makeMapTransform(
+    identityRuntimeAdapter as RuntimeAdapter<string, string>,
+    valueAdapter,
+    (runtimeMap) => {
       const result: Record<string, TStoredValue> = {}
-      transformedValue.forEach((value, key) => {
+      runtimeMap.forEach((value, key) => {
         const storedValue = valueAdapter.toStored(value)
         if (key === "__proto__") setProtoProp(result, storedValue)
         else result[key] = storedValue
       })
       return result
-    },
-  }
+    }
+  )
 }
 
 function makeArrayBackedMapTransform<TKeyStored, TKeyRuntime, TValueStored, TValueRuntime>(
   keyAdapter: RuntimeAdapter<TKeyStored, TKeyRuntime>,
   valueAdapter: RuntimeAdapter<TValueStored, TValueRuntime>
 ): ModelPropTransform<Array<[TKeyStored, TValueStored]>, Map<TKeyRuntime, TValueRuntime>> {
-  const storedByRuntime = new WeakMap<
-    Map<TKeyRuntime, TValueRuntime>,
-    Array<[TKeyStored, TValueStored]>
-  >()
-
-  return {
-    transform({ originalValue, cachedTransformedValue }) {
-      if (cachedTransformedValue) {
-        return cachedTransformedValue
-      }
-
-      const runtimeMap = makeMapProxy(asMap(originalValue), keyAdapter, valueAdapter)
-
-      storedByRuntime.set(runtimeMap, originalValue)
-      return runtimeMap
-    },
-
-    untransform({ transformedValue }) {
-      const cachedStored = storedByRuntime.get(transformedValue)
-      if (cachedStored) {
-        return cachedStored
-      }
-
-      const result: Array<[TKeyStored, TValueStored]> = []
-      transformedValue.forEach((value, key) => {
-        result.push([keyAdapter.toStored(key), valueAdapter.toStored(value)])
-      })
-      return result
-    },
-  }
+  return makeMapTransform(keyAdapter, valueAdapter, (runtimeMap) => {
+    const result: Array<[TKeyStored, TValueStored]> = []
+    runtimeMap.forEach((value, key) => {
+      result.push([keyAdapter.toStored(key), valueAdapter.toStored(value)])
+    })
+    return result
+  })
 }
 
 export function typesMapFromObject<TValueType extends AnyType>(

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) {