mobx-keystone 1.20.0 → 1.22.0

package/src/types/TypeChecker.ts

@@ -1,185 +1,202 @@
-import type { Path } from "../parent/pathTypes"
-import { isArray, isObject, isPrimitive, lazy } from "../utils"
-import { getOrCreate } from "../utils/mapUtils"
-import type { AnyStandardType } from "./schemas"
-import { TypeCheckError } from "./TypeCheckError"
-
-type CheckFunction = (value: any, path: Path, typeCheckedValue: any) => TypeCheckError | null
-
-/**
- * @internal
- */
-export enum TypeCheckerBaseType {
-  Object = "object",
-  Array = "array",
-  Primitive = "primitive",
-  Any = "any",
-}
-
-/**
- * @internal
- */
-export function getTypeCheckerBaseTypeFromValue(value: any): TypeCheckerBaseType {
-  // array must be before object since arrays are also objects
-  if (isArray(value)) {
-    return TypeCheckerBaseType.Array
-  }
-  if (isObject(value)) {
-    return TypeCheckerBaseType.Object
-  }
-  if (isPrimitive(value)) {
-    return TypeCheckerBaseType.Primitive
-  }
-  return TypeCheckerBaseType.Any
-}
-
-const typeCheckersWithCachedSnapshotProcessorResultsOfObject = new WeakMap<
-  object,
-  Set<TypeChecker>
->()
-
-/**
- * @internal
- */
-export function invalidateCachedToSnapshotProcessorResult(obj: object) {
-  const set = typeCheckersWithCachedSnapshotProcessorResultsOfObject.get(obj)
-
-  if (set) {
-    set.forEach((typeChecker) => {
-      typeChecker.invalidateSnapshotProcessorCachedResult(obj)
-    })
-    typeCheckersWithCachedSnapshotProcessorResultsOfObject.delete(obj)
-  }
-}
-
-/**
- * @internal
- */
-export class TypeChecker {
-  unchecked: boolean
-  skipCheck = false
-
-  check(value: any, path: Path, typeCheckedValue: any): TypeCheckError | null {
-    if (this.unchecked || this.skipCheck) {
-      return null
-    }
-
-    return this._check!(value, path, typeCheckedValue)
-  }
-
-  private _cachedTypeInfoGen: TypeInfoGen
-
-  get typeInfo() {
-    return this._cachedTypeInfoGen(this as any)
-  }
-
-  constructor(
-    readonly baseType: TypeCheckerBaseType,
-    private readonly _check: CheckFunction | null,
-    readonly getTypeName: (...recursiveTypeCheckers: TypeChecker[]) => string,
-    readonly typeInfoGen: TypeInfoGen,
-    readonly snapshotType: (sn: unknown) => TypeChecker | null,
-    private readonly _fromSnapshotProcessor: (sn: any) => unknown,
-    private readonly _toSnapshotProcessor: (sn: any) => unknown
-  ) {
-    this.unchecked = !_check
-    this._cachedTypeInfoGen = lazy(typeInfoGen)
-  }
-
-  fromSnapshotProcessor = (sn: any): unknown => {
-    // we cannot cache fromSnapshotProcessor since nobody ensures us
-    // the original snapshot won't be tweaked after use
-    return this._fromSnapshotProcessor(sn)
-  }
-
-  private readonly _toSnapshotProcessorCache = new WeakMap<object, unknown>()
-
-  invalidateSnapshotProcessorCachedResult(obj: object) {
-    this._toSnapshotProcessorCache.delete(obj)
-  }
-
-  toSnapshotProcessor = (sn: any): unknown => {
-    if (typeof sn !== "object" || sn === null) {
-      // not cacheable
-      return this._toSnapshotProcessor(sn)
-    }
-
-    if (this._toSnapshotProcessorCache.has(sn)) {
-      return this._toSnapshotProcessorCache.get(sn)
-    }
-
-    const val = this._toSnapshotProcessor(sn)
-    this._toSnapshotProcessorCache.set(sn, val)
-
-    // register this type checker as listener of that sn changes
-    const typeCheckerSet = getOrCreate(
-      typeCheckersWithCachedSnapshotProcessorResultsOfObject,
-      sn,
-      () => new Set()
-    )
-
-    typeCheckerSet.add(this)
-
-    return val
-  }
-}
-
-const lateTypeCheckerSymbol = Symbol("lateTypeCheker")
-
-/**
- * @internal
- */
-export interface LateTypeChecker {
-  [lateTypeCheckerSymbol]: true
-  (): TypeChecker
-  typeInfo: TypeInfo
-}
-
-/**
- * @internal
- */
-export function lateTypeChecker(fn: () => TypeChecker, typeInfoGen: TypeInfoGen): LateTypeChecker {
-  let cached: TypeChecker | undefined
-  const ltc = () => {
-    if (cached) {
-      return cached
-    }
-
-    cached = fn()
-    return cached
-  }
-  ;(ltc as LateTypeChecker)[lateTypeCheckerSymbol] = true
-
-  const cachedTypeInfoGen = lazy(typeInfoGen)
-
-  Object.defineProperty(ltc, "typeInfo", {
-    enumerable: true,
-    configurable: false,
-    get() {
-      return cachedTypeInfoGen(ltc as any)
-    },
-  })
-
-  return ltc as LateTypeChecker
-}
-
-/**
- * @internal
- */
-export function isLateTypeChecker(ltc: unknown): ltc is LateTypeChecker {
-  return typeof ltc === "function" && lateTypeCheckerSymbol in ltc
-}
-
-/**
- * Type info base class.
- */
-export class TypeInfo {
-  readonly kind: string = "typeInfo"
-
-  constructor(readonly thisType: AnyStandardType) {}
-}
-
-/**
- * @internal
- */
-export type TypeInfoGen = (t: AnyStandardType) => TypeInfo
+import type { Path } from "../parent/pathTypes"
+import { isArray, isObject, isPrimitive, lazy } from "../utils"
+import { getOrCreate } from "../utils/mapUtils"
+import type { AnyStandardType } from "./schemas"
+import type { TypeCheckError } from "./TypeCheckError"
+
+type CheckFunction = (value: any, path: Path, typeCheckedValue: any) => TypeCheckError | null
+
+/**
+ * @internal
+ */
+export enum TypeCheckerBaseType {
+  Object = "object",
+  Array = "array",
+  Primitive = "primitive",
+  Any = "any",
+}
+
+/**
+ * @internal
+ */
+export function getTypeCheckerBaseTypeFromValue(value: any): TypeCheckerBaseType {
+  // array must be before object since arrays are also objects
+  if (isArray(value)) {
+    return TypeCheckerBaseType.Array
+  }
+  if (isObject(value)) {
+    return TypeCheckerBaseType.Object
+  }
+  if (isPrimitive(value)) {
+    return TypeCheckerBaseType.Primitive
+  }
+  return TypeCheckerBaseType.Any
+}
+
+const typeCheckersWithCachedSnapshotProcessorResultsOfObject = new WeakMap<
+  object,
+  Set<TypeChecker>
+>()
+
+/**
+ * @internal
+ */
+export function invalidateCachedToSnapshotProcessorResult(obj: object) {
+  const set = typeCheckersWithCachedSnapshotProcessorResultsOfObject.get(obj)
+
+  if (set) {
+    set.forEach((typeChecker) => {
+      typeChecker.invalidateSnapshotProcessorCachedResult(obj)
+    })
+    typeCheckersWithCachedSnapshotProcessorResultsOfObject.delete(obj)
+  }
+}
+
+/**
+ * @internal
+ */
+export class TypeChecker {
+  unchecked: boolean
+  skipCheck = false
+  readonly baseType: TypeCheckerBaseType
+  private readonly _check: CheckFunction | null
+  readonly getTypeName: (...recursiveTypeCheckers: TypeChecker[]) => string
+  readonly typeInfoGen: TypeInfoGen
+  readonly snapshotType: (sn: unknown) => TypeChecker | null
+  private readonly _fromSnapshotProcessor: (sn: any) => unknown
+  private readonly _toSnapshotProcessor: (sn: any) => unknown
+
+  check(value: any, path: Path, typeCheckedValue: any): TypeCheckError | null {
+    if (this.unchecked || this.skipCheck) {
+      return null
+    }
+
+    return this._check!(value, path, typeCheckedValue)
+  }
+
+  private _cachedTypeInfoGen: TypeInfoGen
+
+  get typeInfo() {
+    return this._cachedTypeInfoGen(this as any)
+  }
+
+  constructor(
+    baseType: TypeCheckerBaseType,
+    _check: CheckFunction | null,
+    getTypeName: (...recursiveTypeCheckers: TypeChecker[]) => string,
+    typeInfoGen: TypeInfoGen,
+    snapshotType: (sn: unknown) => TypeChecker | null,
+    _fromSnapshotProcessor: (sn: any) => unknown,
+    _toSnapshotProcessor: (sn: any) => unknown
+  ) {
+    this.baseType = baseType
+    this._check = _check
+    this.getTypeName = getTypeName
+    this.typeInfoGen = typeInfoGen
+    this.snapshotType = snapshotType
+    this._fromSnapshotProcessor = _fromSnapshotProcessor
+    this._toSnapshotProcessor = _toSnapshotProcessor
+    this.unchecked = !_check
+    this._cachedTypeInfoGen = lazy(typeInfoGen)
+  }
+
+  fromSnapshotProcessor = (sn: any): unknown => {
+    // we cannot cache fromSnapshotProcessor since nobody ensures us
+    // the original snapshot won't be tweaked after use
+    return this._fromSnapshotProcessor(sn)
+  }
+
+  private readonly _toSnapshotProcessorCache = new WeakMap<object, unknown>()
+
+  invalidateSnapshotProcessorCachedResult(obj: object) {
+    this._toSnapshotProcessorCache.delete(obj)
+  }
+
+  toSnapshotProcessor = (sn: any): unknown => {
+    if (typeof sn !== "object" || sn === null) {
+      // not cacheable
+      return this._toSnapshotProcessor(sn)
+    }
+
+    if (this._toSnapshotProcessorCache.has(sn)) {
+      return this._toSnapshotProcessorCache.get(sn)
+    }
+
+    const val = this._toSnapshotProcessor(sn)
+    this._toSnapshotProcessorCache.set(sn, val)
+
+    // register this type checker as listener of that sn changes
+    const typeCheckerSet = getOrCreate(
+      typeCheckersWithCachedSnapshotProcessorResultsOfObject,
+      sn,
+      () => new Set()
+    )
+
+    typeCheckerSet.add(this)
+
+    return val
+  }
+}
+
+const lateTypeCheckerSymbol = Symbol("lateTypeCheker")
+
+/**
+ * @internal
+ */
+export interface LateTypeChecker {
+  [lateTypeCheckerSymbol]: true
+  (): TypeChecker
+  typeInfo: TypeInfo
+}
+
+/**
+ * @internal
+ */
+export function lateTypeChecker(fn: () => TypeChecker, typeInfoGen: TypeInfoGen): LateTypeChecker {
+  let cached: TypeChecker | undefined
+  const ltc = () => {
+    if (cached) {
+      return cached
+    }
+
+    cached = fn()
+    return cached
+  }
+  ;(ltc as LateTypeChecker)[lateTypeCheckerSymbol] = true
+
+  const cachedTypeInfoGen = lazy(typeInfoGen)
+
+  Object.defineProperty(ltc, "typeInfo", {
+    enumerable: true,
+    configurable: false,
+    get() {
+      return cachedTypeInfoGen(ltc as any)
+    },
+  })
+
+  return ltc as LateTypeChecker
+}
+
+/**
+ * @internal
+ */
+export function isLateTypeChecker(ltc: unknown): ltc is LateTypeChecker {
+  return typeof ltc === "function" && lateTypeCheckerSymbol in ltc
+}
+
+/**
+ * Type info base class.
+ */
+export class TypeInfo {
+  readonly kind: string = "typeInfo"
+  readonly thisType: AnyStandardType
+
+  constructor(thisType: AnyStandardType) {
+    this.thisType = thisType
+  }
+}
+
+/**
+ * @internal
+ */
+export type TypeInfoGen = (t: AnyStandardType) => TypeInfo

package/src/types/arrayBased/typesArray.ts

@@ -1,137 +1,136 @@
-import type { Path } from "../../parent/pathTypes"
-import { isArray } from "../../utils"
-import { withErrorPathSegment } from "../../utils/errorDiagnostics"
-import { arrayCachePruning, createPerEntryCachedCheck } from "../createPerEntryCachedCheck"
-import { getTypeInfo } from "../getTypeInfo"
-import { resolveStandardType, resolveTypeChecker } from "../resolveTypeChecker"
-import type { AnyStandardType, AnyType, ArrayType } from "../schemas"
-import { TypeCheckError } from "../TypeCheckError"
-import {
-  lateTypeChecker,
-  TypeChecker,
-  TypeCheckerBaseType,
-  TypeInfo,
-  TypeInfoGen,
-} from "../TypeChecker"
-import { prependPathElementToTypeCheckError } from "../typeCheckErrorUtils"
-
-/**
- * A type that represents an array of values of a given type.
- *
- * Example:
- * ```ts
- * const numberArrayType = types.array(types.number)
- * ```
- *
- * @template T Item type.
- * @param itemType Type of inner items.
- * @returns
- */
-export function typesArray<T extends AnyType>(itemType: T): ArrayType<T[]> {
-  const typeInfoGen: TypeInfoGen = (t) => new ArrayTypeInfo(t, resolveStandardType(itemType))
-
-  return lateTypeChecker(() => {
-    const itemChecker = resolveTypeChecker(itemType)
-    const emptyChildPath: Path = []
-
-    const getTypeName = (...recursiveTypeCheckers: TypeChecker[]) =>
-      `Array<${itemChecker.getTypeName(...recursiveTypeCheckers, itemChecker)}>`
-
-    const checkArrayItems = createPerEntryCachedCheck<number>(
-      (array, checkEntry) => {
-        for (let i = 0; i < array.length; i++) {
-          const error = checkEntry(i)
-          if (error) return error
-        }
-        return null
-      },
-      (array, index, path, typeCheckedValue) => {
-        const error = itemChecker.check(array[index], emptyChildPath, typeCheckedValue)
-        return error
-          ? prependPathElementToTypeCheckError(error, path, index, typeCheckedValue)
-          : null
-      },
-      arrayCachePruning
-    )
-
-    const thisTc: TypeChecker = new TypeChecker(
-      TypeCheckerBaseType.Array,
-
-      (array, path, typeCheckedValue) => {
-        if (!isArray(array)) {
-          return new TypeCheckError({
-            path,
-            expectedTypeName: getTypeName(thisTc),
-            actualValue: array,
-            typeCheckedValue,
-          })
-        }
-
-        if (itemChecker.unchecked || itemChecker.skipCheck) {
-          return null
-        }
-
-        return checkArrayItems(array, path, typeCheckedValue)
-      },
-      getTypeName,
-      typeInfoGen,
-
-      (array) => {
-        if (!isArray(array)) {
-          return null
-        }
-
-        if (!itemChecker.unchecked) {
-          for (let i = 0; i < array.length; i++) {
-            const itemActualChecker = itemChecker.snapshotType(array[i])
-            if (!itemActualChecker) {
-              return null
-            }
-          }
-        }
-
-        return thisTc
-      },
-
-      (sn: unknown[]) => {
-        if (itemChecker.unchecked) {
-          return sn
-        }
-
-        return sn.map((item, i) =>
-          withErrorPathSegment(i, () => itemChecker.fromSnapshotProcessor(item))
-        )
-      },
-
-      (sn: unknown[]) => {
-        if (itemChecker.unchecked) {
-          return sn
-        }
-
-        return sn.map((item, i) =>
-          withErrorPathSegment(i, () => itemChecker.toSnapshotProcessor(item))
-        )
-      }
-    )
-
-    return thisTc
-  }, typeInfoGen) as any
-}
-
-/**
- * `types.array` type info.
- */
-export class ArrayTypeInfo extends TypeInfo {
-  readonly kind = "array"
-
-  get itemTypeInfo(): TypeInfo {
-    return getTypeInfo(this.itemType)
-  }
-
-  constructor(
-    thisType: AnyStandardType,
-    readonly itemType: AnyStandardType
-  ) {
-    super(thisType)
-  }
-}
+import type { Path } from "../../parent/pathTypes"
+import { isArray } from "../../utils"
+import { withErrorPathSegment } from "../../utils/errorDiagnostics"
+import { arrayCachePruning, createPerEntryCachedCheck } from "../createPerEntryCachedCheck"
+import { getTypeInfo } from "../getTypeInfo"
+import { resolveStandardType, resolveTypeChecker } from "../resolveTypeChecker"
+import type { AnyStandardType, AnyType, ArrayType } from "../schemas"
+import { TypeCheckError } from "../TypeCheckError"
+import {
+  lateTypeChecker,
+  TypeChecker,
+  TypeCheckerBaseType,
+  TypeInfo,
+  type TypeInfoGen,
+} from "../TypeChecker"
+import { prependPathElementToTypeCheckError } from "../typeCheckErrorUtils"
+
+/**
+ * A type that represents an array of values of a given type.
+ *
+ * Example:
+ * ```ts
+ * const numberArrayType = types.array(types.number)
+ * ```
+ *
+ * @template T Item type.
+ * @param itemType Type of inner items.
+ * @returns
+ */
+export function typesArray<T extends AnyType>(itemType: T): ArrayType<T[]> {
+  const typeInfoGen: TypeInfoGen = (t) => new ArrayTypeInfo(t, resolveStandardType(itemType))
+
+  return lateTypeChecker(() => {
+    const itemChecker = resolveTypeChecker(itemType)
+    const emptyChildPath: Path = []
+
+    const getTypeName = (...recursiveTypeCheckers: TypeChecker[]) =>
+      `Array<${itemChecker.getTypeName(...recursiveTypeCheckers, itemChecker)}>`
+
+    const checkArrayItems = createPerEntryCachedCheck<number>(
+      (array, checkEntry) => {
+        for (let i = 0; i < array.length; i++) {
+          const error = checkEntry(i)
+          if (error) return error
+        }
+        return null
+      },
+      (array, index, path, typeCheckedValue) => {
+        const error = itemChecker.check(array[index], emptyChildPath, typeCheckedValue)
+        return error
+          ? prependPathElementToTypeCheckError(error, path, index, typeCheckedValue)
+          : null
+      },
+      arrayCachePruning
+    )
+
+    const thisTc: TypeChecker = new TypeChecker(
+      TypeCheckerBaseType.Array,
+
+      (array, path, typeCheckedValue) => {
+        if (!isArray(array)) {
+          return new TypeCheckError({
+            path,
+            expectedTypeName: getTypeName(thisTc),
+            actualValue: array,
+            typeCheckedValue,
+          })
+        }
+
+        if (itemChecker.unchecked || itemChecker.skipCheck) {
+          return null
+        }
+
+        return checkArrayItems(array, path, typeCheckedValue)
+      },
+      getTypeName,
+      typeInfoGen,
+
+      (array) => {
+        if (!isArray(array)) {
+          return null
+        }
+
+        if (!itemChecker.unchecked) {
+          for (let i = 0; i < array.length; i++) {
+            const itemActualChecker = itemChecker.snapshotType(array[i])
+            if (!itemActualChecker) {
+              return null
+            }
+          }
+        }
+
+        return thisTc
+      },
+
+      (sn: unknown[]) => {
+        if (itemChecker.unchecked) {
+          return sn
+        }
+
+        return sn.map((item, i) =>
+          withErrorPathSegment(i, () => itemChecker.fromSnapshotProcessor(item))
+        )
+      },
+
+      (sn: unknown[]) => {
+        if (itemChecker.unchecked) {
+          return sn
+        }
+
+        return sn.map((item, i) =>
+          withErrorPathSegment(i, () => itemChecker.toSnapshotProcessor(item))
+        )
+      }
+    )
+
+    return thisTc
+  }, typeInfoGen) as any
+}
+
+/**
+ * `types.array` type info.
+ */
+export class ArrayTypeInfo extends TypeInfo {
+  readonly kind = "array"
+  readonly itemType: AnyStandardType
+
+  get itemTypeInfo(): TypeInfo {
+    return getTypeInfo(this.itemType)
+  }
+
+  constructor(thisType: AnyStandardType, itemType: AnyStandardType) {
+    super(thisType)
+    this.itemType = itemType
+  }
+}