mobx-keystone 1.20.0 → 1.22.0

package/src/types/objectBased/typesObjectMap.ts

@@ -1,143 +1,142 @@
-import { modelTypeKey } from "../../model/metadata"
-import { modelInfoByClass } from "../../modelShared/modelInfo"
-import { isObject } from "../../utils"
-import { withErrorPathSegment } from "../../utils/errorDiagnostics"
-import { ObjectMap } from "../../wrappers/ObjectMap"
-import { getTypeInfo } from "../getTypeInfo"
-import { resolveStandardType, resolveTypeChecker } from "../resolveTypeChecker"
-import type { AnyStandardType, AnyType, ModelType, TypeToData } from "../schemas"
-import { TypeCheckError } from "../TypeCheckError"
-import {
-  lateTypeChecker,
-  TypeChecker,
-  TypeCheckerBaseType,
-  TypeInfo,
-  TypeInfoGen,
-} from "../TypeChecker"
-import { resolveCodecSupport } from "../utility/typesCodec"
-import { typesObject } from "./typesObject"
-import { typesRecord } from "./typesRecord"
-
-/**
- * A type that represents an object-like map ObjectMap.
- *
- * Example:
- * ```ts
- * const numberMapType = types.objectMap(types.number)
- * ```
- *
- * @template T Value type.
- * @param valueType Value type.
- * @returns
- */
-export function typesObjectMap<T extends AnyType>(
-  valueType: T
-): ModelType<ObjectMap<TypeToData<T>>> {
-  const typeInfoGen: TypeInfoGen = (t) => new ObjectMapTypeInfo(t, resolveStandardType(valueType))
-
-  return lateTypeChecker(() => {
-    const modelInfo = modelInfoByClass.get(ObjectMap)!
-
-    const valueChecker = resolveTypeChecker(valueType)
-    const valueSupport = resolveCodecSupport(valueType)
-    const storedValueChecker = resolveTypeChecker(valueSupport.storedType)
-
-    const getTypeName = (...recursiveTypeCheckers: TypeChecker[]) =>
-      `ObjectMap<${valueChecker.getTypeName(...recursiveTypeCheckers, valueChecker)}>`
-
-    const dataTypeChecker = typesObject(() => ({
-      items: typesRecord(valueSupport.storedType as any),
-    }))
-    const resolvedDataTypeChecker = resolveTypeChecker(dataTypeChecker)
-
-    const thisTc: TypeChecker = new TypeChecker(
-      TypeCheckerBaseType.Object,
-
-      (obj, path, typeCheckedValue) => {
-        if (!(obj instanceof ObjectMap)) {
-          return new TypeCheckError({
-            path,
-            expectedTypeName: getTypeName(thisTc),
-            actualValue: obj,
-            typeCheckedValue,
-          })
-        }
-
-        return resolvedDataTypeChecker.check(obj.$, path, typeCheckedValue)
-      },
-
-      getTypeName,
-      typeInfoGen,
-
-      (obj) => {
-        if (!isObject(obj)) {
-          return null
-        }
-
-        if (obj[modelTypeKey] !== undefined) {
-          // fast check
-          return obj[modelTypeKey] === modelInfo.name ? thisTc : null
-        }
-
-        return resolvedDataTypeChecker.snapshotType(obj) ? thisTc : null
-      },
-
-      (sn: { items: Record<string, unknown> }) => {
-        const newItems: (typeof sn)["items"] = {}
-
-        withErrorPathSegment("items", () => {
-          for (const k of Object.keys(sn.items)) {
-            newItems[k] = withErrorPathSegment(k, () =>
-              storedValueChecker.fromSnapshotProcessor(sn.items[k])
-            )
-          }
-        })
-
-        return {
-          ...sn,
-          [modelTypeKey]: modelInfo.name,
-          items: newItems,
-        }
-      },
-
-      (sn: { items: Record<string, unknown>; [modelTypeKey]?: string }) => {
-        const newItems: (typeof sn)["items"] = {}
-
-        withErrorPathSegment("items", () => {
-          for (const k of Object.keys(sn.items)) {
-            newItems[k] = withErrorPathSegment(k, () =>
-              storedValueChecker.toSnapshotProcessor(sn.items[k])
-            )
-          }
-        })
-
-        const snCopy = {
-          ...sn,
-          items: newItems,
-        }
-
-        return snCopy
-      }
-    )
-
-    return thisTc
-  }, typeInfoGen) as any
-}
-
-/**
- * `types.objectMap` type info.
- */
-export class ObjectMapTypeInfo extends TypeInfo {
-  readonly kind = "objectMap"
-
-  get valueTypeInfo(): TypeInfo {
-    return getTypeInfo(this.valueType)
-  }
-
-  constructor(
-    thisType: AnyStandardType,
-    readonly valueType: AnyStandardType
-  ) {
-    super(thisType)
-  }
-}
+import { modelTypeKey } from "../../model/metadata"
+import { modelInfoByClass } from "../../modelShared/modelInfo"
+import { isObject } from "../../utils"
+import { withErrorPathSegment } from "../../utils/errorDiagnostics"
+import { ObjectMap } from "../../wrappers/ObjectMap"
+import { getTypeInfo } from "../getTypeInfo"
+import { resolveStandardType, resolveTypeChecker } from "../resolveTypeChecker"
+import type { AnyStandardType, AnyType, ModelType, TypeToData } from "../schemas"
+import { TypeCheckError } from "../TypeCheckError"
+import {
+  lateTypeChecker,
+  TypeChecker,
+  TypeCheckerBaseType,
+  TypeInfo,
+  type TypeInfoGen,
+} from "../TypeChecker"
+import { resolveCodecSupport } from "../utility/typesCodec"
+import { typesObject } from "./typesObject"
+import { typesRecord } from "./typesRecord"
+
+/**
+ * A type that represents an object-like map ObjectMap.
+ *
+ * Example:
+ * ```ts
+ * const numberMapType = types.objectMap(types.number)
+ * ```
+ *
+ * @template T Value type.
+ * @param valueType Value type.
+ * @returns
+ */
+export function typesObjectMap<T extends AnyType>(
+  valueType: T
+): ModelType<ObjectMap<TypeToData<T>>> {
+  const typeInfoGen: TypeInfoGen = (t) => new ObjectMapTypeInfo(t, resolveStandardType(valueType))
+
+  return lateTypeChecker(() => {
+    const modelInfo = modelInfoByClass.get(ObjectMap)!
+
+    const valueChecker = resolveTypeChecker(valueType)
+    const valueSupport = resolveCodecSupport(valueType)
+    const storedValueChecker = resolveTypeChecker(valueSupport.storedType)
+
+    const getTypeName = (...recursiveTypeCheckers: TypeChecker[]) =>
+      `ObjectMap<${valueChecker.getTypeName(...recursiveTypeCheckers, valueChecker)}>`
+
+    const dataTypeChecker = typesObject(() => ({
+      items: typesRecord(valueSupport.storedType as any),
+    }))
+    const resolvedDataTypeChecker = resolveTypeChecker(dataTypeChecker)
+
+    const thisTc: TypeChecker = new TypeChecker(
+      TypeCheckerBaseType.Object,
+
+      (obj, path, typeCheckedValue) => {
+        if (!(obj instanceof ObjectMap)) {
+          return new TypeCheckError({
+            path,
+            expectedTypeName: getTypeName(thisTc),
+            actualValue: obj,
+            typeCheckedValue,
+          })
+        }
+
+        return resolvedDataTypeChecker.check(obj.$, path, typeCheckedValue)
+      },
+
+      getTypeName,
+      typeInfoGen,
+
+      (obj) => {
+        if (!isObject(obj)) {
+          return null
+        }
+
+        if (obj[modelTypeKey] !== undefined) {
+          // fast check
+          return obj[modelTypeKey] === modelInfo.name ? thisTc : null
+        }
+
+        return resolvedDataTypeChecker.snapshotType(obj) ? thisTc : null
+      },
+
+      (sn: { items: Record<string, unknown> }) => {
+        const newItems: (typeof sn)["items"] = {}
+
+        withErrorPathSegment("items", () => {
+          for (const k of Object.keys(sn.items)) {
+            newItems[k] = withErrorPathSegment(k, () =>
+              storedValueChecker.fromSnapshotProcessor(sn.items[k])
+            )
+          }
+        })
+
+        return {
+          ...sn,
+          [modelTypeKey]: modelInfo.name,
+          items: newItems,
+        }
+      },
+
+      (sn: { items: Record<string, unknown>; [modelTypeKey]?: string }) => {
+        const newItems: (typeof sn)["items"] = {}
+
+        withErrorPathSegment("items", () => {
+          for (const k of Object.keys(sn.items)) {
+            newItems[k] = withErrorPathSegment(k, () =>
+              storedValueChecker.toSnapshotProcessor(sn.items[k])
+            )
+          }
+        })
+
+        const snCopy = {
+          ...sn,
+          items: newItems,
+        }
+
+        return snCopy
+      }
+    )
+
+    return thisTc
+  }, typeInfoGen) as any
+}
+
+/**
+ * `types.objectMap` type info.
+ */
+export class ObjectMapTypeInfo extends TypeInfo {
+  readonly kind = "objectMap"
+  readonly valueType: AnyStandardType
+
+  get valueTypeInfo(): TypeInfo {
+    return getTypeInfo(this.valueType)
+  }
+
+  constructor(thisType: AnyStandardType, valueType: AnyStandardType) {
+    super(thisType)
+    this.valueType = valueType
+  }
+}

package/src/types/objectBased/typesRecord.ts

@@ -1,157 +1,156 @@
-import { isObservableObject, keys } from "mobx"
-import type { Path } from "../../parent/pathTypes"
-import { failure, isObject } from "../../utils"
-import { withErrorPathSegment } from "../../utils/errorDiagnostics"
-import { createPerEntryCachedCheck, recordCachePruning } from "../createPerEntryCachedCheck"
-import { getTypeInfo } from "../getTypeInfo"
-import { resolveStandardType, resolveTypeChecker } from "../resolveTypeChecker"
-import type { AnyStandardType, AnyType, RecordType } from "../schemas"
-import { TypeCheckError } from "../TypeCheckError"
-import {
-  lateTypeChecker,
-  TypeChecker,
-  TypeCheckerBaseType,
-  TypeInfo,
-  TypeInfoGen,
-} from "../TypeChecker"
-import { prependPathElementToTypeCheckError } from "../typeCheckErrorUtils"
-
-/**
- * A type that represents an object-like map, an object with string keys and values all of a same given type.
- *
- * Example:
- * ```ts
- * // { [k: string]: number }
- * const numberMapType = types.record(types.number)
- * ```
- *
- * @template T Type.
- * @param valueType Type of the values of the object-like map.
- * @returns
- */
-export function typesRecord<T extends AnyType>(valueType: T): RecordType<T> {
-  const typeInfoGen: TypeInfoGen = (tc) => new RecordTypeInfo(tc, resolveStandardType(valueType))
-
-  return lateTypeChecker(() => {
-    const valueChecker = resolveTypeChecker(valueType)
-    const emptyChildPath: Path = []
-
-    const getTypeName = (...recursiveTypeCheckers: TypeChecker[]) =>
-      `Record<${valueChecker.getTypeName(...recursiveTypeCheckers, valueChecker)}>`
-
-    const applySnapshotProcessor = (obj: Record<string, unknown>, mode: "from" | "to") => {
-      if (valueChecker.unchecked) {
-        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, () =>
-          mode === "from"
-            ? valueChecker.fromSnapshotProcessor(obj[k])
-            : valueChecker.toSnapshotProcessor(obj[k])
-        )
-        newObj[k] = v
-      }
-
-      return newObj
-    }
-
-    const checkRecordValues = createPerEntryCachedCheck(
-      (obj, checkEntry) => {
-        // Use keys() from MobX for observable objects to track key additions/removals
-        // in MobX 4 (which lacks Proxy). Object.keys() doesn't establish MobX tracking
-        // in MobX 4, so the aggregation computed would miss newly added keys.
-        const objKeys = isObservableObject(obj) ? keys(obj) : Object.keys(obj)
-        for (let i = 0; i < objKeys.length; i++) {
-          const error = checkEntry(objKeys[i])
-          if (error) return error
-        }
-        return null
-      },
-      (obj, key, path, typeCheckedValue) => {
-        if (typeof key !== "string") {
-          throw failure(`record type keys must be strings, got ${typeof key}`)
-        }
-        const error = valueChecker.check(obj[key], emptyChildPath, typeCheckedValue)
-        return error ? prependPathElementToTypeCheckError(error, path, key, typeCheckedValue) : null
-      },
-      recordCachePruning
-    )
-
-    const thisTc: TypeChecker = new TypeChecker(
-      TypeCheckerBaseType.Object,
-
-      (obj, path, typeCheckedValue) => {
-        if (!isObject(obj)) {
-          return new TypeCheckError({
-            path,
-            expectedTypeName: getTypeName(thisTc),
-            actualValue: obj,
-            typeCheckedValue,
-          })
-        }
-
-        if (valueChecker.unchecked || valueChecker.skipCheck) {
-          return null
-        }
-
-        return checkRecordValues(obj, path, typeCheckedValue)
-      },
-
-      getTypeName,
-      typeInfoGen,
-
-      (obj) => {
-        if (!isObject(obj)) {
-          return null
-        }
-
-        if (!valueChecker.unchecked) {
-          const keys = Object.keys(obj)
-          for (let i = 0; i < keys.length; i++) {
-            const k = keys[i]
-            const v = obj[k]
-            const valueActualChecker = valueChecker.snapshotType(v)
-            if (!valueActualChecker) {
-              return null
-            }
-          }
-        }
-
-        return thisTc
-      },
-
-      (obj: Record<string, unknown>) => {
-        return applySnapshotProcessor(obj, "from")
-      },
-
-      (obj: Record<string, unknown>) => {
-        return applySnapshotProcessor(obj, "to")
-      }
-    )
-
-    return thisTc
-  }, typeInfoGen) as any
-}
-
-/**
- * `types.record` type info.
- */
-export class RecordTypeInfo extends TypeInfo {
-  readonly kind = "record"
-
-  get valueTypeInfo(): TypeInfo {
-    return getTypeInfo(this.valueType)
-  }
-
-  constructor(
-    thisType: AnyStandardType,
-    readonly valueType: AnyStandardType
-  ) {
-    super(thisType)
-  }
-}
+import { isObservableObject, keys } from "mobx"
+import type { Path } from "../../parent/pathTypes"
+import { failure, isObject } from "../../utils"
+import { withErrorPathSegment } from "../../utils/errorDiagnostics"
+import { createPerEntryCachedCheck, recordCachePruning } from "../createPerEntryCachedCheck"
+import { getTypeInfo } from "../getTypeInfo"
+import { resolveStandardType, resolveTypeChecker } from "../resolveTypeChecker"
+import type { AnyStandardType, AnyType, RecordType } from "../schemas"
+import { TypeCheckError } from "../TypeCheckError"
+import {
+  lateTypeChecker,
+  TypeChecker,
+  TypeCheckerBaseType,
+  TypeInfo,
+  type TypeInfoGen,
+} from "../TypeChecker"
+import { prependPathElementToTypeCheckError } from "../typeCheckErrorUtils"
+
+/**
+ * A type that represents an object-like map, an object with string keys and values all of a same given type.
+ *
+ * Example:
+ * ```ts
+ * // { [k: string]: number }
+ * const numberMapType = types.record(types.number)
+ * ```
+ *
+ * @template T Type.
+ * @param valueType Type of the values of the object-like map.
+ * @returns
+ */
+export function typesRecord<T extends AnyType>(valueType: T): RecordType<T> {
+  const typeInfoGen: TypeInfoGen = (tc) => new RecordTypeInfo(tc, resolveStandardType(valueType))
+
+  return lateTypeChecker(() => {
+    const valueChecker = resolveTypeChecker(valueType)
+    const emptyChildPath: Path = []
+
+    const getTypeName = (...recursiveTypeCheckers: TypeChecker[]) =>
+      `Record<${valueChecker.getTypeName(...recursiveTypeCheckers, valueChecker)}>`
+
+    const applySnapshotProcessor = (obj: Record<string, unknown>, mode: "from" | "to") => {
+      if (valueChecker.unchecked) {
+        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, () =>
+          mode === "from"
+            ? valueChecker.fromSnapshotProcessor(obj[k])
+            : valueChecker.toSnapshotProcessor(obj[k])
+        )
+        newObj[k] = v
+      }
+
+      return newObj
+    }
+
+    const checkRecordValues = createPerEntryCachedCheck(
+      (obj, checkEntry) => {
+        // Use keys() from MobX for observable objects to track key additions/removals
+        // in MobX 4 (which lacks Proxy). Object.keys() doesn't establish MobX tracking
+        // in MobX 4, so the aggregation computed would miss newly added keys.
+        const objKeys = isObservableObject(obj) ? keys(obj) : Object.keys(obj)
+        for (let i = 0; i < objKeys.length; i++) {
+          const error = checkEntry(objKeys[i])
+          if (error) return error
+        }
+        return null
+      },
+      (obj, key, path, typeCheckedValue) => {
+        if (typeof key !== "string") {
+          throw failure(`record type keys must be strings, got ${typeof key}`)
+        }
+        const error = valueChecker.check(obj[key], emptyChildPath, typeCheckedValue)
+        return error ? prependPathElementToTypeCheckError(error, path, key, typeCheckedValue) : null
+      },
+      recordCachePruning
+    )
+
+    const thisTc: TypeChecker = new TypeChecker(
+      TypeCheckerBaseType.Object,
+
+      (obj, path, typeCheckedValue) => {
+        if (!isObject(obj)) {
+          return new TypeCheckError({
+            path,
+            expectedTypeName: getTypeName(thisTc),
+            actualValue: obj,
+            typeCheckedValue,
+          })
+        }
+
+        if (valueChecker.unchecked || valueChecker.skipCheck) {
+          return null
+        }
+
+        return checkRecordValues(obj, path, typeCheckedValue)
+      },
+
+      getTypeName,
+      typeInfoGen,
+
+      (obj) => {
+        if (!isObject(obj)) {
+          return null
+        }
+
+        if (!valueChecker.unchecked) {
+          const keys = Object.keys(obj)
+          for (let i = 0; i < keys.length; i++) {
+            const k = keys[i]
+            const v = obj[k]
+            const valueActualChecker = valueChecker.snapshotType(v)
+            if (!valueActualChecker) {
+              return null
+            }
+          }
+        }
+
+        return thisTc
+      },
+
+      (obj: Record<string, unknown>) => {
+        return applySnapshotProcessor(obj, "from")
+      },
+
+      (obj: Record<string, unknown>) => {
+        return applySnapshotProcessor(obj, "to")
+      }
+    )
+
+    return thisTc
+  }, typeInfoGen) as any
+}
+
+/**
+ * `types.record` type info.
+ */
+export class RecordTypeInfo extends TypeInfo {
+  readonly kind = "record"
+  readonly valueType: AnyStandardType
+
+  get valueTypeInfo(): TypeInfo {
+    return getTypeInfo(this.valueType)
+  }
+
+  constructor(thisType: AnyStandardType, valueType: AnyStandardType) {
+    super(thisType)
+    this.valueType = valueType
+  }
+}