mobx-keystone 1.20.0 → 1.22.0

package/src/types/tProp.ts

@@ -1,268 +1,277 @@
-import { AnyModelProp, MaybeOptionalModelProp, OptionalModelProp, prop } from "../modelShared/prop"
-import { lazy } from "../utils"
-import {
-  typesBoolean,
-  typesNull,
-  typesNumber,
-  typesString,
-  typesUndefined,
-} from "./primitiveBased/typesPrimitive"
-import { resolveStandardType, resolveTypeChecker } from "./resolveTypeChecker"
-import type { AnyStandardType, AnyType, TypeToData, TypeToSnapshotIn } from "./schemas"
-import { createCodecPropTransform, resolveCodecSupport } from "./utility/typesCodec"
-import { typesOr } from "./utility/typesOr"
-import type { TypeToStoredData } from "./utility/typeToStoredData"
-
-const noDefaultValueSymbol = Symbol("noDefaultValue")
-
-const tPropCache = new WeakMap<AnyStandardType, Map<unknown, AnyModelProp>>()
-
-type AnyTypeOrArray = AnyType | ReadonlyArray<AnyType>
-
-type StoredRequiredPropMetadata<TType extends AnyType> = {
-  $storedValueType: TypeToStoredData<TType>
-  $storedCreationValueType: TypeToStoredData<TType>
-}
-
-type TypedMaybeOptionalModelProp<TType extends AnyType> = MaybeOptionalModelProp<
-  TypeToData<TType>
-> &
-  StoredRequiredPropMetadata<TType>
-
-type TypedOptionalModelProp<TType extends AnyType> = OptionalModelProp<TypeToData<TType>> & {
-  $storedValueType: TypeToStoredData<TType>
-  $storedCreationValueType: TypeToStoredData<TType> | null | undefined
-  $typedFromSnapshotOverride: TypeToSnapshotIn<TType> | null | undefined
-}
-
-function getOrCreateTProp(
-  type: AnyStandardType,
-  defKey: unknown,
-  createTProp: () => AnyModelProp
-): AnyModelProp {
-  let defValueCache = tPropCache.get(type)
-  if (!defValueCache) {
-    defValueCache = new Map()
-    tPropCache.set(type, defValueCache)
-  }
-
-  let prop = defValueCache.get(defKey)
-  if (!prop) {
-    prop = createTProp()
-    defValueCache.set(defKey, prop)
-  }
-
-  return prop
-}
-
-/**
- * Defines a string model property with a default value.
- * Equivalent to `tProp(types.string, defaultValue)`.
- *
- * Example:
- * ```ts
- * x: tProp("foo") // an optional string that will take the value `"foo"` when undefined.
- * ```
- *
- * @param defaultValue Default value.
- * @returns
- */
-export function tProp(defaultValue: string): TypedOptionalModelProp<typeof typesString>
-
-/**
- * Defines a number model property with a default value.
- * Equivalent to `tProp(types.number, defaultValue)`.
- *
- * Example:
- * ```ts
- * x: tProp(42) // an optional number that will take the value `42` when undefined.
- * ```
- *
- * @param defaultValue Default value.
- * @returns
- */
-export function tProp(defaultValue: number): TypedOptionalModelProp<typeof typesNumber>
-
-/**
- * Defines a boolean model property with a default value.
- * Equivalent to `tProp(types.boolean, defaultValue)`.
- *
- * Example:
- * ```ts
- * x: tProp(true) // an optional boolean that will take the value `true` when undefined.
- * ```
- *
- * @param defaultValue Default value.
- * @returns
- */
-export function tProp(defaultValue: boolean): TypedOptionalModelProp<typeof typesBoolean>
-
-/**
- * Defines a model property, with an optional function to generate a default value
- * if the input snapshot / model creation data is `null` or `undefined` and with an associated type checker.
- *
- * Example:
- * ```ts
- * x: tProp(types.number, () => 10) // an optional number, with a default value of 10
- * x: tProp(types.array(types.number), () => []) // an optional number array, with a default empty array
- * ```
- *
- * @template TType Type checker type.
- *
- * @param type Type checker.
- * @param defaultFn Default value generator function.
- * @returns
- */
-export function tProp<TType extends AnyType>(
-  type: TType,
-  defaultFn: () => TypeToData<TType>
-): TypedOptionalModelProp<TType>
-
-/**
- * Defines a model property using array syntax as a shorthand for `types.or(...)`,
- * with an optional function to generate a default value if the input snapshot /
- * model creation data is `null` or `undefined`.
- *
- * Example:
- * ```ts
- * x: tProp([String, Number], () => 10) // equivalent to tProp(types.or(String, Number), () => 10)
- * ```
- *
- * @template TType Array of possible type checkers.
- *
- * @param type Array shorthand for `types.or(...)`.
- * @param defaultFn Default value generator function.
- * @returns
- */
-export function tProp<TType extends ReadonlyArray<AnyType>>(
-  type: TType,
-  defaultFn: () => TypeToData<TType[number]>
-): TypedOptionalModelProp<TType[number]>
-
-/**
- * Defines a model property, with an optional default value
- * if the input snapshot / model creation data is `null` or `undefined` and with an associated type checker.
- * You should only use this with primitive values and never with object values
- * (array, model, object, etc).
- *
- * Example:
- * ```ts
- * x: tProp(types.number, 10) // an optional number, with a default value of 10
- * ```
- *
- * @template TType Type checker type.
- *
- * @param type Type checker.
- * @param defaultValue Default value generator function.
- * @returns
- */
-export function tProp<TType extends AnyType>(
-  type: TType,
-  defaultValue: TypeToData<TType>
-): TypedOptionalModelProp<TType>
-
-/**
- * Defines a model property using array syntax as a shorthand for `types.or(...)`,
- * with an optional default value if the input snapshot / model creation data is
- * `null` or `undefined`.
- *
- * Example:
- * ```ts
- * x: tProp([String, Number], "foo") // equivalent to tProp(types.or(String, Number), "foo")
- * ```
- *
- * @template TType Array of possible type checkers.
- *
- * @param type Array shorthand for `types.or(...)`.
- * @param defaultValue Default value.
- * @returns
- */
-export function tProp<TType extends ReadonlyArray<AnyType>>(
-  type: TType,
-  defaultValue: TypeToData<TType[number]>
-): TypedOptionalModelProp<TType[number]>
-
-/**
- * Defines a model property with no default value and an associated type checker.
- *
- * Example:
- * ```ts
- * x: tProp(types.number) // a required number
- * x: tProp(types.maybe(types.number)) // an optional number, which defaults to undefined
- * ```
- *
- * @template TType Type checker type.
- *
- * @param type Type checker.
- * @returns
- */
-export function tProp<TType extends AnyType>(type: TType): TypedMaybeOptionalModelProp<TType>
-
-/**
- * Defines a model property with no default value using array syntax as a shorthand
- * for `types.or(...)`.
- *
- * Example:
- * ```ts
- * x: tProp([String, undefined]) // equivalent to tProp(types.or(String, undefined))
- * ```
- *
- * @template TType Array of possible type checkers.
- *
- * @param type Array shorthand for `types.or(...)`.
- * @returns
- */
-export function tProp<TType extends ReadonlyArray<AnyType>>(
-  type: TType
-): TypedMaybeOptionalModelProp<TType[number]>
-
-export function tProp(typeOrDefaultValue: any, def?: any): AnyModelProp {
-  switch (typeof typeOrDefaultValue) {
-    case "string":
-      return tProp(typesString, typeOrDefaultValue)
-    case "number":
-      return tProp(typesNumber, typeOrDefaultValue)
-    case "boolean":
-      return tProp(typesBoolean, typeOrDefaultValue)
-    default:
-      break
-  }
-
-  const hasDefaultValue = arguments.length >= 2
-
-  const typeOrArray: AnyTypeOrArray = typeOrDefaultValue
-  const resolvedType: AnyType = Array.isArray(typeOrArray)
-    ? typesOr(...(typeOrArray as ReadonlyArray<AnyType>))
-    : (typeOrArray as AnyType)
-
-  const typeChecker = resolveStandardType(resolvedType)
-  const codecSupport = resolveCodecSupport(typeChecker)
-
-  return getOrCreateTProp(typeChecker, hasDefaultValue ? def : noDefaultValueSymbol, () => {
-    const fromSnapshotTypeChecker = hasDefaultValue
-      ? typesOr(codecSupport.storedType, typesUndefined, typesNull)
-      : codecSupport.storedType
-    const getFromSnapshotProcessor = lazy(
-      () => resolveTypeChecker(fromSnapshotTypeChecker).fromSnapshotProcessor
-    )
-    const getToSnapshotProcessor = lazy(
-      () => resolveTypeChecker(codecSupport.storedType).toSnapshotProcessor
-    )
-
-    // we use Object.create to avoid messing up with the prop cache
-    const baseProp = hasDefaultValue ? prop(def) : prop()
-    const newProp = codecSupport.hasCodec
-      ? baseProp.withTransform(createCodecPropTransform(typeChecker))
-      : Object.create(baseProp)
-
-    Object.assign(newProp, {
-      _typeChecker: typeChecker,
-
-      _fromSnapshotProcessor: (sn) => getFromSnapshotProcessor()(sn),
-
-      _toSnapshotProcessor: (sn) => getToSnapshotProcessor()(sn),
-    } satisfies Partial<AnyModelProp>)
-
-    return newProp
-  })
-}
+import {
+  type AnyModelProp,
+  type MaybeOptionalModelProp,
+  type OptionalModelProp,
+  prop,
+} from "../modelShared/prop"
+import { lazy } from "../utils"
+import {
+  typesBoolean,
+  typesNull,
+  typesNumber,
+  typesString,
+  typesUndefined,
+} from "./primitiveBased/typesPrimitive"
+import { resolveStandardType, resolveTypeChecker } from "./resolveTypeChecker"
+import type { AnyStandardType, AnyType, TypeToData, TypeToSnapshotIn } from "./schemas"
+import { createCodecPropTransform, resolveCodecSupport } from "./utility/typesCodec"
+import { typesOr } from "./utility/typesOr"
+import type { TypeToStoredData } from "./utility/typeToStoredData"
+
+const noDefaultValueSymbol = Symbol("noDefaultValue")
+
+const tPropCache = new WeakMap<AnyStandardType, Map<unknown, AnyModelProp>>()
+
+type AnyTypeOrArray = AnyType | ReadonlyArray<AnyType>
+
+type StoredRequiredPropMetadata<TType extends AnyType> = {
+  $storedValueType: TypeToStoredData<TType>
+  $storedCreationValueType: TypeToStoredData<TType>
+}
+
+type TypedMaybeOptionalModelProp<TType extends AnyType> = MaybeOptionalModelProp<
+  TypeToData<TType>
+> &
+  StoredRequiredPropMetadata<TType>
+
+type TypedOptionalModelProp<TType extends AnyType> = OptionalModelProp<TypeToData<TType>> & {
+  $storedValueType: TypeToStoredData<TType>
+  $storedCreationValueType: TypeToStoredData<TType> | null | undefined
+  $typedFromSnapshotOverride: TypeToSnapshotIn<TType> | null | undefined
+}
+
+function getOrCreateTProp(
+  type: AnyStandardType,
+  defKey: unknown,
+  createTProp: () => AnyModelProp
+): AnyModelProp {
+  let defValueCache = tPropCache.get(type)
+  if (!defValueCache) {
+    defValueCache = new Map()
+    tPropCache.set(type, defValueCache)
+  }
+
+  let prop = defValueCache.get(defKey)
+  if (!prop) {
+    prop = createTProp()
+    defValueCache.set(defKey, prop)
+  }
+
+  return prop
+}
+
+/**
+ * Defines a string model property with a default value.
+ * Equivalent to `tProp(types.string, defaultValue)`.
+ *
+ * Example:
+ * ```ts
+ * x: tProp("foo") // an optional string that will take the value `"foo"` when undefined.
+ * ```
+ *
+ * @param defaultValue Default value.
+ * @returns
+ */
+export function tProp(defaultValue: string): TypedOptionalModelProp<typeof typesString>
+
+/**
+ * Defines a number model property with a default value.
+ * Equivalent to `tProp(types.number, defaultValue)`.
+ *
+ * Example:
+ * ```ts
+ * x: tProp(42) // an optional number that will take the value `42` when undefined.
+ * ```
+ *
+ * @param defaultValue Default value.
+ * @returns
+ */
+export function tProp(defaultValue: number): TypedOptionalModelProp<typeof typesNumber>
+
+/**
+ * Defines a boolean model property with a default value.
+ * Equivalent to `tProp(types.boolean, defaultValue)`.
+ *
+ * Example:
+ * ```ts
+ * x: tProp(true) // an optional boolean that will take the value `true` when undefined.
+ * ```
+ *
+ * @param defaultValue Default value.
+ * @returns
+ */
+export function tProp(defaultValue: boolean): TypedOptionalModelProp<typeof typesBoolean>
+
+/**
+ * Defines a model property, with an optional function to generate a default value
+ * if the input snapshot / model creation data is `null` or `undefined` and with an associated type checker.
+ *
+ * Example:
+ * ```ts
+ * x: tProp(types.number, () => 10) // an optional number, with a default value of 10
+ * x: tProp(types.array(types.number), () => []) // an optional number array, with a default empty array
+ * ```
+ *
+ * @template TType Type checker type.
+ *
+ * @param type Type checker.
+ * @param defaultFn Default value generator function.
+ * @returns
+ */
+export function tProp<TType extends AnyType>(
+  type: TType,
+  defaultFn: () => TypeToData<TType>
+): TypedOptionalModelProp<TType>
+
+/**
+ * Defines a model property using array syntax as a shorthand for `types.or(...)`,
+ * with an optional function to generate a default value if the input snapshot /
+ * model creation data is `null` or `undefined`.
+ *
+ * Example:
+ * ```ts
+ * x: tProp([String, Number], () => 10) // equivalent to tProp(types.or(String, Number), () => 10)
+ * ```
+ *
+ * @template TType Array of possible type checkers.
+ *
+ * @param type Array shorthand for `types.or(...)`.
+ * @param defaultFn Default value generator function.
+ * @returns
+ */
+export function tProp<TType extends ReadonlyArray<AnyType>>(
+  type: TType,
+  defaultFn: () => TypeToData<TType[number]>
+): TypedOptionalModelProp<TType[number]>
+
+/**
+ * Defines a model property, with an optional default value
+ * if the input snapshot / model creation data is `null` or `undefined` and with an associated type checker.
+ * You should only use this with primitive values and never with object values
+ * (array, model, object, etc).
+ *
+ * Example:
+ * ```ts
+ * x: tProp(types.number, 10) // an optional number, with a default value of 10
+ * ```
+ *
+ * @template TType Type checker type.
+ *
+ * @param type Type checker.
+ * @param defaultValue Default value generator function.
+ * @returns
+ */
+export function tProp<TType extends AnyType>(
+  type: TType,
+  defaultValue: TypeToData<TType>
+): TypedOptionalModelProp<TType>
+
+/**
+ * Defines a model property using array syntax as a shorthand for `types.or(...)`,
+ * with an optional default value if the input snapshot / model creation data is
+ * `null` or `undefined`.
+ *
+ * Example:
+ * ```ts
+ * x: tProp([String, Number], "foo") // equivalent to tProp(types.or(String, Number), "foo")
+ * ```
+ *
+ * @template TType Array of possible type checkers.
+ *
+ * @param type Array shorthand for `types.or(...)`.
+ * @param defaultValue Default value.
+ * @returns
+ */
+export function tProp<TType extends ReadonlyArray<AnyType>>(
+  type: TType,
+  defaultValue: TypeToData<TType[number]>
+): TypedOptionalModelProp<TType[number]>
+
+/**
+ * Defines a model property with no default value and an associated type checker.
+ *
+ * Example:
+ * ```ts
+ * x: tProp(types.number) // a required number
+ * x: tProp(types.maybe(types.number)) // an optional number, which defaults to undefined
+ * ```
+ *
+ * @template TType Type checker type.
+ *
+ * @param type Type checker.
+ * @returns
+ */
+export function tProp<TType extends AnyType>(type: TType): TypedMaybeOptionalModelProp<TType>
+
+/**
+ * Defines a model property with no default value using array syntax as a shorthand
+ * for `types.or(...)`.
+ *
+ * Example:
+ * ```ts
+ * x: tProp([String, undefined]) // equivalent to tProp(types.or(String, undefined))
+ * ```
+ *
+ * @template TType Array of possible type checkers.
+ *
+ * @param type Array shorthand for `types.or(...)`.
+ * @returns
+ */
+export function tProp<TType extends ReadonlyArray<AnyType>>(
+  type: TType
+): TypedMaybeOptionalModelProp<TType[number]>
+
+export function tProp(
+  ...args: [typeOrDefaultValue: any] | [typeOrDefaultValue: any, def: any]
+): AnyModelProp {
+  const [typeOrDefaultValue, def] = args
+  switch (typeof typeOrDefaultValue) {
+    case "string":
+      return tProp(typesString, typeOrDefaultValue)
+    case "number":
+      return tProp(typesNumber, typeOrDefaultValue)
+    case "boolean":
+      return tProp(typesBoolean, typeOrDefaultValue)
+    default:
+      break
+  }
+
+  const hasDefaultValue = args.length >= 2
+
+  const typeOrArray: AnyTypeOrArray = typeOrDefaultValue
+  const resolvedType: AnyType = Array.isArray(typeOrArray)
+    ? typesOr(...(typeOrArray as ReadonlyArray<AnyType>))
+    : (typeOrArray as AnyType)
+
+  const typeChecker = resolveStandardType(resolvedType)
+  const codecSupport = resolveCodecSupport(typeChecker)
+
+  return getOrCreateTProp(typeChecker, hasDefaultValue ? def : noDefaultValueSymbol, () => {
+    const fromSnapshotTypeChecker = hasDefaultValue
+      ? typesOr(codecSupport.storedType, typesUndefined, typesNull)
+      : codecSupport.storedType
+    const getFromSnapshotProcessor = lazy(
+      () => resolveTypeChecker(fromSnapshotTypeChecker).fromSnapshotProcessor
+    )
+    const getToSnapshotProcessor = lazy(
+      () => resolveTypeChecker(codecSupport.storedType).toSnapshotProcessor
+    )
+
+    // we use Object.create to avoid messing up with the prop cache
+    const baseProp = hasDefaultValue ? prop(def) : prop()
+    const newProp = codecSupport.hasCodec
+      ? baseProp.withTransform(createCodecPropTransform(typeChecker))
+      : Object.create(baseProp)
+
+    Object.assign(newProp, {
+      _defaultValueIsTransformed: codecSupport.hasCodec,
+      _typeChecker: typeChecker,
+
+      _fromSnapshotProcessor: (sn) => getFromSnapshotProcessor()(sn),
+
+      _toSnapshotProcessor: (sn) => getToSnapshotProcessor()(sn),
+    } satisfies Partial<AnyModelProp>)
+
+    return newProp
+  })
+}

package/src/types/typeCheck.ts

@@ -1,21 +1,21 @@
-import { resolveTypeChecker } from "./resolveTypeChecker"
-import type { AnyType, TypeToData } from "./schemas"
-import type { TypeCheckError } from "./TypeCheckError"
-
-/**
- * Checks if a value conforms to a given type.
- *
- * @template T Type.
- * @param type Type to check for.
- * @param value Value to check.
- * @returns A TypeError if the check fails or null if no error.
- */
-export function typeCheck<T extends AnyType>(type: T, value: TypeToData<T>): TypeCheckError | null {
-  const typeChecker = resolveTypeChecker(type)
-
-  if (typeChecker.unchecked || typeChecker.skipCheck) {
-    return null
-  }
-
-  return typeChecker.check(value, [], value)
-}
+import { resolveTypeChecker } from "./resolveTypeChecker"
+import type { AnyType, TypeToData } from "./schemas"
+import type { TypeCheckError } from "./TypeCheckError"
+
+/**
+ * Checks if a value conforms to a given type.
+ *
+ * @template T Type.
+ * @param type Type to check for.
+ * @param value Value to check.
+ * @returns A TypeError if the check fails or null if no error.
+ */
+export function typeCheck<T extends AnyType>(type: T, value: TypeToData<T>): TypeCheckError | null {
+  const typeChecker = resolveTypeChecker(type)
+
+  if (typeChecker.unchecked || typeChecker.skipCheck) {
+    return null
+  }
+
+  return typeChecker.check(value, [], value)
+}

package/src/types/typeCheckErrorUtils.ts

@@ -1,23 +1,23 @@
-import type { Path, PathElement } from "../parent/pathTypes"
-import { TypeCheckError } from "./TypeCheckError"
-
-/**
- * Prefixes an existing type-check error path with one parent path segment.
- * @internal
- */
-export function prependPathElementToTypeCheckError(
-  valueError: TypeCheckError,
-  path: Path,
-  pathElement: PathElement,
-  typeCheckedValue: any
-): TypeCheckError {
-  const fullPath =
-    path.length > 0 ? [...path, pathElement, ...valueError.path] : [pathElement, ...valueError.path]
-
-  return new TypeCheckError({
-    path: fullPath,
-    expectedTypeName: valueError.expectedTypeName,
-    actualValue: valueError.actualValue,
-    typeCheckedValue,
-  })
-}
+import type { Path, PathElement } from "../parent/pathTypes"
+import { TypeCheckError } from "./TypeCheckError"
+
+/**
+ * Prefixes an existing type-check error path with one parent path segment.
+ * @internal
+ */
+export function prependPathElementToTypeCheckError(
+  valueError: TypeCheckError,
+  path: Path,
+  pathElement: PathElement,
+  typeCheckedValue: any
+): TypeCheckError {
+  const fullPath =
+    path.length > 0 ? [...path, pathElement, ...valueError.path] : [pathElement, ...valueError.path]
+
+  return new TypeCheckError({
+    path: fullPath,
+    expectedTypeName: valueError.expectedTypeName,
+    actualValue: valueError.actualValue,
+    typeCheckedValue,
+  })
+}