mobx-keystone 1.20.0 → 1.22.0

package/src/types/utility/typesRefinement.ts

@@ -1,125 +1,131 @@
-import { getTypeInfo } from "../getTypeInfo"
-import { resolveStandardType, resolveTypeChecker } from "../resolveTypeChecker"
-import type { AnyStandardType, AnyType, TypeToData } from "../schemas"
-import { TypeCheckError } from "../TypeCheckError"
-import { lateTypeChecker, TypeChecker, TypeInfo, TypeInfoGen } from "../TypeChecker"
-
-/**
- * A refinement over a given type. This allows you to do extra checks
- * over models, ensure numbers are integers, etc.
- *
- * Example:
- * ```ts
- * const integerType = types.refinement(types.number, (n) => {
- *   return Number.isInteger(n)
- * }, "integer")
- *
- * const sumModelType = types.refinement(types.model(Sum), (sum) => {
- *   // imagine that for some reason sum includes a number 'a', a number 'b'
- *   // and the result
- *
- *   const rightResult = sum.a + sum.b === sum.result
- *
- *   // simple mode that will just return that the whole model is incorrect
- *   return rightResult
- *
- *   // this will return that the result field is wrong
- *   return rightResult ? null : new TypeCheckError({
- *     path: ["result"],
- *     expectedTypeName: "a+b",
- *     actualValue: sum.result,
- *   })
- * })
- * ```
- *
- * @template T Base type.
- * @param baseType Base type.
- * @param checkFn Function that will receive the data (if it passes the base type
- * check) and return null or false if there were no errors or either a TypeCheckError instance or
- * true if there were.
- * @returns
- */
-export function typesRefinement<T extends AnyType>(
-  baseType: T,
-  checkFn: (data: TypeToData<T>) => TypeCheckError | null | boolean,
-  typeName?: string
-): T {
-  const typeInfoGen: TypeInfoGen = (t) =>
-    new RefinementTypeInfo(t, resolveStandardType(baseType), checkFn, typeName)
-
-  return lateTypeChecker(() => {
-    const baseChecker = resolveTypeChecker(baseType)
-
-    const getTypeName = (...recursiveTypeCheckers: TypeChecker[]) => {
-      const baseTypeName = baseChecker.getTypeName(...recursiveTypeCheckers, baseChecker)
-      const refinementName = typeName || "refinementOf"
-      return `${refinementName}<${baseTypeName}>`
-    }
-
-    const thisTc: TypeChecker = new TypeChecker(
-      baseChecker.baseType,
-
-      (data, path, typeCheckedValue) => {
-        const baseErr = baseChecker.check(data, path, typeCheckedValue)
-        if (baseErr) {
-          return baseErr
-        }
-
-        // The refinement function always runs with the full data value regardless of
-        // the partial check scope. This is intentional: cross-property invariants
-        // enforced by refinements must remain fully validated after every change.
-        const refinementErr = checkFn(data)
-
-        if (refinementErr === true || refinementErr == null) {
-          return null
-        } else if (refinementErr === false) {
-          return new TypeCheckError({
-            path,
-            expectedTypeName: getTypeName(thisTc),
-            actualValue: data,
-            typeCheckedValue,
-          })
-        } else {
-          // override typeCheckedValue
-          return new TypeCheckError({
-            path: refinementErr.path,
-            expectedTypeName: refinementErr.expectedTypeName,
-            actualValue: refinementErr.actualValue,
-            typeCheckedValue,
-          })
-        }
-      },
-
-      getTypeName,
-      typeInfoGen,
-
-      // we cannot check refinement here since it checks data instances, not snapshots
-      (sn) => baseChecker.snapshotType(sn),
-
-      (sn) => baseChecker.fromSnapshotProcessor(sn),
-      (sn) => baseChecker.toSnapshotProcessor(sn)
-    )
-
-    return thisTc
-  }, typeInfoGen) as any
-}
-
-/**
- * `types.refinement` type info.
- */
-export class RefinementTypeInfo extends TypeInfo {
-  readonly kind = "refinement"
-
-  get baseTypeInfo(): TypeInfo {
-    return getTypeInfo(this.baseType)
-  }
-
-  constructor(
-    thisType: AnyStandardType,
-    readonly baseType: AnyStandardType,
-    readonly checkFunction: (data: any) => TypeCheckError | null | boolean,
-    readonly typeName: string | undefined
-  ) {
-    super(thisType)
-  }
-}
+import { getTypeInfo } from "../getTypeInfo"
+import { resolveStandardType, resolveTypeChecker } from "../resolveTypeChecker"
+import type { AnyStandardType, AnyType, TypeToData } from "../schemas"
+import { TypeCheckError } from "../TypeCheckError"
+import { lateTypeChecker, TypeChecker, TypeInfo, type TypeInfoGen } from "../TypeChecker"
+
+/**
+ * A refinement over a given type. This allows you to do extra checks
+ * over models, ensure numbers are integers, etc.
+ *
+ * Example:
+ * ```ts
+ * const integerType = types.refinement(types.number, (n) => {
+ *   return Number.isInteger(n)
+ * }, "integer")
+ *
+ * const sumModelType = types.refinement(types.model(Sum), (sum) => {
+ *   // imagine that for some reason sum includes a number 'a', a number 'b'
+ *   // and the result
+ *
+ *   const rightResult = sum.a + sum.b === sum.result
+ *
+ *   // simple mode that will just return that the whole model is incorrect
+ *   return rightResult
+ *
+ *   // this will return that the result field is wrong
+ *   return rightResult ? null : new TypeCheckError({
+ *     path: ["result"],
+ *     expectedTypeName: "a+b",
+ *     actualValue: sum.result,
+ *   })
+ * })
+ * ```
+ *
+ * @template T Base type.
+ * @param baseType Base type.
+ * @param checkFn Function that will receive the data (if it passes the base type
+ * check) and return null or false if there were no errors or either a TypeCheckError instance or
+ * true if there were.
+ * @returns
+ */
+export function typesRefinement<T extends AnyType>(
+  baseType: T,
+  checkFn: (data: TypeToData<T>) => TypeCheckError | null | boolean,
+  typeName?: string
+): T {
+  const typeInfoGen: TypeInfoGen = (t) =>
+    new RefinementTypeInfo(t, resolveStandardType(baseType), checkFn, typeName)
+
+  return lateTypeChecker(() => {
+    const baseChecker = resolveTypeChecker(baseType)
+
+    const getTypeName = (...recursiveTypeCheckers: TypeChecker[]) => {
+      const baseTypeName = baseChecker.getTypeName(...recursiveTypeCheckers, baseChecker)
+      const refinementName = typeName || "refinementOf"
+      return `${refinementName}<${baseTypeName}>`
+    }
+
+    const thisTc: TypeChecker = new TypeChecker(
+      baseChecker.baseType,
+
+      (data, path, typeCheckedValue) => {
+        const baseErr = baseChecker.check(data, path, typeCheckedValue)
+        if (baseErr) {
+          return baseErr
+        }
+
+        // The refinement function always runs with the full data value regardless of
+        // the partial check scope. This is intentional: cross-property invariants
+        // enforced by refinements must remain fully validated after every change.
+        const refinementErr = checkFn(data)
+
+        if (refinementErr === true || refinementErr == null) {
+          return null
+        } else if (refinementErr === false) {
+          return new TypeCheckError({
+            path,
+            expectedTypeName: getTypeName(thisTc),
+            actualValue: data,
+            typeCheckedValue,
+          })
+        } else {
+          // override typeCheckedValue
+          return new TypeCheckError({
+            path: refinementErr.path,
+            expectedTypeName: refinementErr.expectedTypeName,
+            actualValue: refinementErr.actualValue,
+            typeCheckedValue,
+          })
+        }
+      },
+
+      getTypeName,
+      typeInfoGen,
+
+      // we cannot check refinement here since it checks data instances, not snapshots
+      (sn) => baseChecker.snapshotType(sn),
+
+      (sn) => baseChecker.fromSnapshotProcessor(sn),
+      (sn) => baseChecker.toSnapshotProcessor(sn)
+    )
+
+    return thisTc
+  }, typeInfoGen) as any
+}
+
+/**
+ * `types.refinement` type info.
+ */
+export class RefinementTypeInfo extends TypeInfo {
+  readonly kind = "refinement"
+  readonly baseType: AnyStandardType
+  readonly checkFunction: (data: any) => TypeCheckError | null | boolean
+  readonly typeName: string | undefined
+
+  get baseTypeInfo(): TypeInfo {
+    return getTypeInfo(this.baseType)
+  }
+
+  constructor(
+    thisType: AnyStandardType,
+    baseType: AnyStandardType,
+    checkFunction: (data: any) => TypeCheckError | null | boolean,
+    typeName: string | undefined
+  ) {
+    super(thisType)
+    this.baseType = baseType
+    this.checkFunction = checkFunction
+    this.typeName = typeName
+  }
+}

package/src/types/utility/typesSet.ts

@@ -1,110 +1,110 @@
-import { type ObservableSet } from "mobx"
-import type { ModelPropTransform } from "../../modelShared/prop"
-import { isSet } from "../../utils"
-import { asSet } from "../../wrappers/asSet"
-import { typesArray } from "../arrayBased/typesArray"
-import type { AnyType, ArrayType, TypeToData } from "../schemas"
-import { TypeCheckerBaseType } from "../TypeChecker"
-import type { CodecFromEncoded, RuntimeAdapter } from "./typesCodecCore"
-import { createCodecType } from "./typesCodecCore"
-import { resolveCodecSupport } from "./typesCodecSupport"
-
-function makeArrayBackedSetTransform<TStored, TRuntime>(
-  valueAdapter: RuntimeAdapter<TStored, TRuntime>
-): ModelPropTransform<Array<TStored>, Set<TRuntime> | ObservableSet<TRuntime>> {
-  const storedByRuntime = new WeakMap<Set<TRuntime> | ObservableSet<TRuntime>, Array<TStored>>()
-
-  return {
-    transform({ originalValue, cachedTransformedValue }) {
-      if (cachedTransformedValue) {
-        return cachedTransformedValue
-      }
-
-      const storedSet = asSet(originalValue)
-
-      const runtimeSet: Set<TRuntime> | ObservableSet<TRuntime> = new Proxy(storedSet, {
-        get(target, prop, receiver) {
-          switch (prop) {
-            case "has":
-              return (value: TRuntime) => target.has(valueAdapter.toStored(value))
-            case "add":
-              return (value: TRuntime) => {
-                target.add(valueAdapter.toStored(value))
-                return receiver
-              }
-            case "delete":
-              return (value: TRuntime) => target.delete(valueAdapter.toStored(value))
-            case "clear":
-              return () => target.clear()
-            case "size":
-              return target.size
-            case "forEach":
-              return (
-                callback: (
-                  value: TRuntime,
-                  key: TRuntime,
-                  set: Set<TRuntime> | ObservableSet<TRuntime>
-                ) => void,
-                thisArg?: unknown
-              ) => {
-                target.forEach((value) => {
-                  const runtimeValue = valueAdapter.toRuntime(value)
-                  callback.call(thisArg, runtimeValue, runtimeValue, receiver)
-                })
-              }
-            case "entries":
-              return function* () {
-                for (const value of target.values()) {
-                  const runtimeValue = valueAdapter.toRuntime(value)
-                  yield [runtimeValue, runtimeValue] as const
-                }
-              }
-            case "keys":
-            case "values":
-            case Symbol.iterator:
-              return function* () {
-                for (const value of target.values()) {
-                  yield valueAdapter.toRuntime(value)
-                }
-              }
-            default:
-              return Reflect.get(target, prop, receiver)
-          }
-        },
-      }) as unknown as Set<TRuntime> | ObservableSet<TRuntime>
-
-      storedByRuntime.set(runtimeSet, originalValue)
-      return runtimeSet
-    },
-
-    untransform({ transformedValue }) {
-      const cachedStored = storedByRuntime.get(transformedValue)
-      if (cachedStored) {
-        return cachedStored
-      }
-
-      return Array.from(transformedValue.values()).map((value) => valueAdapter.toStored(value))
-    },
-  }
-}
-
-export function typesSetFromArray<TValueType extends AnyType>(
-  valueType: TValueType
-): CodecFromEncoded<
-  ArrayType<TValueType[]>,
-  Set<TypeToData<TValueType>> | ObservableSet<TypeToData<TValueType>>
-> {
-  const valueSupport = resolveCodecSupport(valueType)
-
-  return createCodecType(
-    {
-      typeName: "setFromArray",
-      encodedType: typesArray(valueSupport.storedType),
-      is(value): value is Set<TypeToData<TValueType>> | ObservableSet<TypeToData<TValueType>> {
-        return isSet(value)
-      },
-      ...makeArrayBackedSetTransform(valueSupport.adapter),
-    },
-    TypeCheckerBaseType.Object
-  )
-}
+import type { ObservableSet } from "mobx"
+import type { ModelPropTransform } from "../../modelShared/prop"
+import { isSet } from "../../utils"
+import { asSet } from "../../wrappers/asSet"
+import { typesArray } from "../arrayBased/typesArray"
+import type { AnyType, ArrayType, TypeToData } from "../schemas"
+import { TypeCheckerBaseType } from "../TypeChecker"
+import type { CodecFromEncoded, RuntimeAdapter } from "./typesCodecCore"
+import { createCodecType } from "./typesCodecCore"
+import { resolveCodecSupport } from "./typesCodecSupport"
+
+function makeArrayBackedSetTransform<TStored, TRuntime>(
+  valueAdapter: RuntimeAdapter<TStored, TRuntime>
+): ModelPropTransform<Array<TStored>, Set<TRuntime> | ObservableSet<TRuntime>> {
+  const storedByRuntime = new WeakMap<Set<TRuntime> | ObservableSet<TRuntime>, Array<TStored>>()
+
+  return {
+    transform({ originalValue, cachedTransformedValue }) {
+      if (cachedTransformedValue) {
+        return cachedTransformedValue
+      }
+
+      const storedSet = asSet(originalValue)
+
+      const runtimeSet: Set<TRuntime> | ObservableSet<TRuntime> = new Proxy(storedSet, {
+        get(target, prop, receiver) {
+          switch (prop) {
+            case "has":
+              return (value: TRuntime) => target.has(valueAdapter.toStored(value))
+            case "add":
+              return (value: TRuntime) => {
+                target.add(valueAdapter.toStored(value))
+                return receiver
+              }
+            case "delete":
+              return (value: TRuntime) => target.delete(valueAdapter.toStored(value))
+            case "clear":
+              return () => target.clear()
+            case "size":
+              return target.size
+            case "forEach":
+              return (
+                callback: (
+                  value: TRuntime,
+                  key: TRuntime,
+                  set: Set<TRuntime> | ObservableSet<TRuntime>
+                ) => void,
+                thisArg?: unknown
+              ) => {
+                target.forEach((value) => {
+                  const runtimeValue = valueAdapter.toRuntime(value)
+                  callback.call(thisArg, runtimeValue, runtimeValue, receiver)
+                })
+              }
+            case "entries":
+              return function* () {
+                for (const value of target.values()) {
+                  const runtimeValue = valueAdapter.toRuntime(value)
+                  yield [runtimeValue, runtimeValue] as const
+                }
+              }
+            case "keys":
+            case "values":
+            case Symbol.iterator:
+              return function* () {
+                for (const value of target.values()) {
+                  yield valueAdapter.toRuntime(value)
+                }
+              }
+            default:
+              return Reflect.get(target, prop, receiver)
+          }
+        },
+      }) as unknown as Set<TRuntime> | ObservableSet<TRuntime>
+
+      storedByRuntime.set(runtimeSet, originalValue)
+      return runtimeSet
+    },
+
+    untransform({ transformedValue }) {
+      const cachedStored = storedByRuntime.get(transformedValue)
+      if (cachedStored) {
+        return cachedStored
+      }
+
+      return Array.from(transformedValue.values()).map((value) => valueAdapter.toStored(value))
+    },
+  }
+}
+
+export function typesSetFromArray<TValueType extends AnyType>(
+  valueType: TValueType
+): CodecFromEncoded<
+  ArrayType<TValueType[]>,
+  Set<TypeToData<TValueType>> | ObservableSet<TypeToData<TValueType>>
+> {
+  const valueSupport = resolveCodecSupport(valueType)
+
+  return createCodecType(
+    {
+      typeName: "setFromArray",
+      encodedType: typesArray(valueSupport.storedType),
+      is(value): value is Set<TypeToData<TValueType>> | ObservableSet<TypeToData<TValueType>> {
+        return isSet(value)
+      },
+      ...makeArrayBackedSetTransform(valueSupport.adapter),
+    },
+    TypeCheckerBaseType.Object
+  )
+}

package/src/types/utility/typesSkipCheck.ts

@@ -1,70 +1,69 @@
-import { getTypeInfo } from "../getTypeInfo"
-import { resolveStandardType, resolveTypeChecker } from "../resolveTypeChecker"
-import type { AnyStandardType, AnyType } from "../schemas"
-import { lateTypeChecker, TypeChecker, TypeInfo, TypeInfoGen } from "../TypeChecker"
-
-/**
- * A type that wraps another type but skips runtime validation.
- * Unlike `types.unchecked()`, this preserves the wrapped type's
- * runtime/snapshot typing and all processors/codecs/transforms.
- *
- * Use this when you want codec conversions (e.g. `types.dateAsTimestamp`,
- * `types.bigint`, `types.mapFromObject(...)`) without paying the cost of
- * runtime type checking on every change.
- *
- * Example:
- * ```ts
- * // Date codec with no runtime validation
- * const dateType = types.skipCheck(types.dateAsTimestamp)
- *
- * // In a model
- * class M extends Model({ date: tProp(types.skipCheck(types.dateAsTimestamp)) }) {}
- * ```
- *
- * @template T Base type.
- * @param baseType The type whose validation should be skipped.
- * @returns A type with the same runtime/snapshot behavior but no validation.
- */
-export function typesSkipCheck<T extends AnyType>(baseType: T): T {
-  const typeInfoGen: TypeInfoGen = (t) => new SkipCheckTypeInfo(t, resolveStandardType(baseType))
-
-  return lateTypeChecker(() => {
-    const baseChecker = resolveTypeChecker(baseType)
-
-    const getTypeName = (...recursiveTypeCheckers: TypeChecker[]) => {
-      const baseTypeName = baseChecker.getTypeName(...recursiveTypeCheckers, baseChecker)
-      return `skipCheck<${baseTypeName}>`
-    }
-
-    const thisTc: TypeChecker = new TypeChecker(
-      baseChecker.baseType,
-      (_data, _path, _typeCheckedValue) => null, // always passes validation
-      getTypeName,
-      typeInfoGen,
-      (sn) => baseChecker.snapshotType(sn),
-      (sn) => baseChecker.fromSnapshotProcessor(sn),
-      (sn) => baseChecker.toSnapshotProcessor(sn)
-    )
-    thisTc.skipCheck = true
-
-    return thisTc
-  }, typeInfoGen) as any
-}
-
-/**
- * `types.skipCheck` type info.
- */
-export class SkipCheckTypeInfo extends TypeInfo {
-  readonly kind = "skipCheck"
-
-  get baseTypeInfo(): TypeInfo {
-    return getTypeInfo(this.baseType)
-  }
-
-  constructor(
-    thisType: AnyStandardType,
-    readonly baseType: AnyStandardType
-  ) {
-    super(thisType)
-  }
-}
+import { getTypeInfo } from "../getTypeInfo"
+import { resolveStandardType, resolveTypeChecker } from "../resolveTypeChecker"
+import type { AnyStandardType, AnyType } from "../schemas"
+import { lateTypeChecker, TypeChecker, TypeInfo, type TypeInfoGen } from "../TypeChecker"
+
+/**
+ * A type that wraps another type but skips runtime validation.
+ * Unlike `types.unchecked()`, this preserves the wrapped type's
+ * runtime/snapshot typing and all processors/codecs/transforms.
+ *
+ * Use this when you want codec conversions (e.g. `types.dateAsTimestamp`,
+ * `types.bigint`, `types.mapFromObject(...)`) without paying the cost of
+ * runtime type checking on every change.
+ *
+ * Example:
+ * ```ts
+ * // Date codec with no runtime validation
+ * const dateType = types.skipCheck(types.dateAsTimestamp)
+ *
+ * // In a model
+ * class M extends Model({ date: tProp(types.skipCheck(types.dateAsTimestamp)) }) {}
+ * ```
+ *
+ * @template T Base type.
+ * @param baseType The type whose validation should be skipped.
+ * @returns A type with the same runtime/snapshot behavior but no validation.
+ */
+export function typesSkipCheck<T extends AnyType>(baseType: T): T {
+  const typeInfoGen: TypeInfoGen = (t) => new SkipCheckTypeInfo(t, resolveStandardType(baseType))
+
+  return lateTypeChecker(() => {
+    const baseChecker = resolveTypeChecker(baseType)
+
+    const getTypeName = (...recursiveTypeCheckers: TypeChecker[]) => {
+      const baseTypeName = baseChecker.getTypeName(...recursiveTypeCheckers, baseChecker)
+      return `skipCheck<${baseTypeName}>`
+    }
+
+    const thisTc: TypeChecker = new TypeChecker(
+      baseChecker.baseType,
+      (_data, _path, _typeCheckedValue) => null, // always passes validation
+      getTypeName,
+      typeInfoGen,
+      (sn) => baseChecker.snapshotType(sn),
+      (sn) => baseChecker.fromSnapshotProcessor(sn),
+      (sn) => baseChecker.toSnapshotProcessor(sn)
+    )
+    thisTc.skipCheck = true
+
+    return thisTc
+  }, typeInfoGen) as any
+}
+
+/**
+ * `types.skipCheck` type info.
+ */
+export class SkipCheckTypeInfo extends TypeInfo {
+  readonly kind = "skipCheck"
+  readonly baseType: AnyStandardType
+
+  get baseTypeInfo(): TypeInfo {
+    return getTypeInfo(this.baseType)
+  }
+
+  constructor(thisType: AnyStandardType, baseType: AnyStandardType) {
+    super(thisType)
+    this.baseType = baseType
+  }
+}