mobx-keystone 1.20.0 → 1.22.0

package/src/types/objectBased/typesModel.ts

@@ -1,221 +1,220 @@
-import type { O } from "ts-toolbelt"
-import type { AnyModel } from "../../model/BaseModel"
-import { getModelMetadata } from "../../model/getModelMetadata"
-import { modelTypeKey } from "../../model/metadata"
-import { isModelClass } from "../../model/utils"
-import type { ModelClass } from "../../modelShared/BaseModelShared"
-import { modelInfoByClass } from "../../modelShared/modelInfo"
-import { getInternalModelClassPropsInfo } from "../../modelShared/modelPropsInfo"
-import { noDefaultValue } from "../../modelShared/prop"
-import { isObject, lazy } from "../../utils"
-import { getTypeInfo } from "../getTypeInfo"
-import { registerStandardTypeResolver, resolveTypeChecker } from "../resolveTypeChecker"
-import type { AnyStandardType, ModelType } from "../schemas"
-import { TypeCheckError } from "../TypeCheckError"
-import {
-  lateTypeChecker,
-  TypeChecker,
-  TypeCheckerBaseType,
-  TypeInfo,
-  TypeInfoGen,
-} from "../TypeChecker"
-
-const cachedModelTypeChecker = new WeakMap<ModelClass<AnyModel>, TypeChecker>()
-const modelStandardTypes = new WeakSet<object>()
-
-type _Class<T> = abstract new (...args: any[]) => T
-type _ClassOrObject<M, K> = K extends M ? object : _Class<K> | (() => _Class<K>)
-
-/**
- * A type that represents a model. The type referenced in the model decorator will be used for type checking.
- *
- * Example:
- * ```ts
- * const someModelType = types.model(SomeModel)
- * // or for recursive models
- * const someModelType = types.model<SomeModel>(() => SomeModel)
- * ```
- *
- * @template M Model type.
- * @param modelClass Model class.
- * @returns
- */
-export function typesModel<M = never, K = M>(modelClass: _ClassOrObject<M, K>): ModelType<K> {
-  // if we type it any stronger then recursive defs and so on stop working
-
-  if (!isModelClass(modelClass) && typeof modelClass === "function") {
-    // resolve later
-    const modelClassFn = modelClass as () => ModelClass<AnyModel>
-    const typeInfoGen: TypeInfoGen = (t) => new ModelTypeInfo(t, modelClassFn())
-    const tc = lateTypeChecker(() => typesModel(modelClassFn()) as any, typeInfoGen) as any
-    modelStandardTypes.add(tc as object)
-    return tc
-  } else {
-    const modelClazz: ModelClass<AnyModel> = modelClass as any
-
-    const cachedTypeChecker = cachedModelTypeChecker.get(modelClazz)
-    if (cachedTypeChecker) {
-      return cachedTypeChecker as any
-    }
-
-    const typeInfoGen: TypeInfoGen = (t) => new ModelTypeInfo(t, modelClazz)
-
-    const tc = lateTypeChecker(() => {
-      const modelInfo = modelInfoByClass.get(modelClazz)!
-      const typeName = `Model(${modelInfo.name})`
-
-      const dataTypeChecker = getModelMetadata(modelClazz).dataType
-      const resolvedDataTypeChecker = dataTypeChecker
-        ? resolveTypeChecker(dataTypeChecker)
-        : undefined
-
-      const thisTc: TypeChecker = new TypeChecker(
-        TypeCheckerBaseType.Object,
-
-        (value, path, typeCheckedValue) => {
-          if (!(value instanceof modelClazz)) {
-            return new TypeCheckError({
-              path,
-              expectedTypeName: typeName,
-              actualValue: value,
-              typeCheckedValue,
-            })
-          }
-
-          if (resolvedDataTypeChecker) {
-            return resolvedDataTypeChecker.check(value.$, path, typeCheckedValue)
-          }
-
-          return null
-        },
-        () => typeName,
-        typeInfoGen,
-
-        (value) => {
-          if (!isObject(value)) {
-            return null
-          }
-
-          if (value[modelTypeKey] !== undefined) {
-            // fast check
-            return value[modelTypeKey] === modelInfo.name ? thisTc : null
-          }
-
-          if (resolvedDataTypeChecker) {
-            return resolvedDataTypeChecker.snapshotType(value) ? thisTc : null
-          }
-
-          // not enough info to be able to tell
-          return null
-        },
-
-        // No withErrorPathSegment wrapping needed here — model snapshot processors
-        // delegate to the data type checker, which handles path segments at the property level.
-        (sn) => {
-          if (sn[modelTypeKey]) {
-            return sn
-          } else {
-            return {
-              ...sn,
-              [modelTypeKey]: modelInfo.name,
-            }
-          }
-        },
-
-        (sn) => sn
-      )
-
-      return thisTc
-    }, typeInfoGen) as any
-
-    cachedModelTypeChecker.set(modelClazz, tc)
-    modelStandardTypes.add(tc as object)
-
-    return tc
-  }
-}
-
-/**
- * `types.model` type info for a model props.
- */
-export interface ModelTypeInfoProps {
-  readonly [propName: string]: Readonly<{
-    type: AnyStandardType | undefined
-    typeInfo: TypeInfo | undefined
-    hasDefault: boolean
-    default: any
-  }>
-}
-
-/**
- * `types.model` type info.
- */
-export class ModelTypeInfo extends TypeInfo {
-  readonly kind = "model"
-
-  private _props = lazy(() => {
-    const objSchema = getInternalModelClassPropsInfo(this.modelClass)
-
-    const propTypes: O.Writable<ModelTypeInfoProps> = {}
-    Object.keys(objSchema).forEach((propName) => {
-      const propData = objSchema[propName]
-
-      const type = propData._typeChecker
-
-      let typeInfo: TypeInfo | undefined
-      if (type) {
-        typeInfo = getTypeInfo(type)
-      }
-
-      let hasDefault = false
-      let defaultValue: any
-      if (propData._defaultFn !== noDefaultValue) {
-        defaultValue = propData._defaultFn
-        hasDefault = true
-      } else if (propData._defaultValue !== noDefaultValue) {
-        defaultValue = propData._defaultValue
-        hasDefault = true
-      }
-
-      propTypes[propName] = {
-        type,
-        typeInfo,
-        hasDefault,
-        default: defaultValue,
-      }
-    })
-    return propTypes
-  })
-
-  get props(): ModelTypeInfoProps {
-    return this._props()
-  }
-
-  get modelType(): string {
-    const modelInfo = modelInfoByClass.get(this.modelClass)!
-    return modelInfo.name
-  }
-
-  constructor(
-    thisType: AnyStandardType,
-    readonly modelClass: ModelClass<AnyModel>
-  ) {
-    super(thisType)
-  }
-}
-
-/**
- * @internal
- */
-export function registerModelStandardTypeResolver() {
-  registerStandardTypeResolver((v) => (isModelClass(v) ? typesModel(v) : undefined))
-}
-
-/**
- * @internal
- */
-export function isModelStandardType(value: unknown): boolean {
-  return typeof value === "object" || typeof value === "function"
-    ? modelStandardTypes.has(value as object)
-    : false
-}
+import type { O } from "ts-toolbelt"
+import type { AnyModel } from "../../model/BaseModel"
+import { getModelMetadata } from "../../model/getModelMetadata"
+import { modelTypeKey } from "../../model/metadata"
+import { isModelClass } from "../../model/utils"
+import type { ModelClass } from "../../modelShared/BaseModelShared"
+import { modelInfoByClass } from "../../modelShared/modelInfo"
+import { getInternalModelClassPropsInfo } from "../../modelShared/modelPropsInfo"
+import { noDefaultValue } from "../../modelShared/prop"
+import { isObject, lazy } from "../../utils"
+import { getTypeInfo } from "../getTypeInfo"
+import { registerStandardTypeResolver, resolveTypeChecker } from "../resolveTypeChecker"
+import type { AnyStandardType, ModelType } from "../schemas"
+import { TypeCheckError } from "../TypeCheckError"
+import {
+  lateTypeChecker,
+  TypeChecker,
+  TypeCheckerBaseType,
+  TypeInfo,
+  type TypeInfoGen,
+} from "../TypeChecker"
+
+const cachedModelTypeChecker = new WeakMap<ModelClass<AnyModel>, TypeChecker>()
+const modelStandardTypes = new WeakSet<object>()
+
+type _Class<T> = abstract new (...args: any[]) => T
+type _ClassOrObject<M, K> = K extends M ? object : _Class<K> | (() => _Class<K>)
+
+/**
+ * A type that represents a model. The type referenced in the model decorator will be used for type checking.
+ *
+ * Example:
+ * ```ts
+ * const someModelType = types.model(SomeModel)
+ * // or for recursive models
+ * const someModelType = types.model<SomeModel>(() => SomeModel)
+ * ```
+ *
+ * @template M Model type.
+ * @param modelClass Model class.
+ * @returns
+ */
+export function typesModel<M = never, K = M>(modelClass: _ClassOrObject<M, K>): ModelType<K> {
+  // if we type it any stronger then recursive defs and so on stop working
+
+  if (!isModelClass(modelClass) && typeof modelClass === "function") {
+    // resolve later
+    const modelClassFn = modelClass as () => ModelClass<AnyModel>
+    const typeInfoGen: TypeInfoGen = (t) => new ModelTypeInfo(t, modelClassFn())
+    const tc = lateTypeChecker(() => typesModel(modelClassFn()) as any, typeInfoGen) as any
+    modelStandardTypes.add(tc as object)
+    return tc
+  } else {
+    const modelClazz: ModelClass<AnyModel> = modelClass as any
+
+    const cachedTypeChecker = cachedModelTypeChecker.get(modelClazz)
+    if (cachedTypeChecker) {
+      return cachedTypeChecker as any
+    }
+
+    const typeInfoGen: TypeInfoGen = (t) => new ModelTypeInfo(t, modelClazz)
+
+    const tc = lateTypeChecker(() => {
+      const modelInfo = modelInfoByClass.get(modelClazz)!
+      const typeName = `Model(${modelInfo.name})`
+
+      const dataTypeChecker = getModelMetadata(modelClazz).dataType
+      const resolvedDataTypeChecker = dataTypeChecker
+        ? resolveTypeChecker(dataTypeChecker)
+        : undefined
+
+      const thisTc: TypeChecker = new TypeChecker(
+        TypeCheckerBaseType.Object,
+
+        (value, path, typeCheckedValue) => {
+          if (!(value instanceof modelClazz)) {
+            return new TypeCheckError({
+              path,
+              expectedTypeName: typeName,
+              actualValue: value,
+              typeCheckedValue,
+            })
+          }
+
+          if (resolvedDataTypeChecker) {
+            return resolvedDataTypeChecker.check(value.$, path, typeCheckedValue)
+          }
+
+          return null
+        },
+        () => typeName,
+        typeInfoGen,
+
+        (value) => {
+          if (!isObject(value)) {
+            return null
+          }
+
+          if (value[modelTypeKey] !== undefined) {
+            // fast check
+            return value[modelTypeKey] === modelInfo.name ? thisTc : null
+          }
+
+          if (resolvedDataTypeChecker) {
+            return resolvedDataTypeChecker.snapshotType(value) ? thisTc : null
+          }
+
+          // not enough info to be able to tell
+          return null
+        },
+
+        // No withErrorPathSegment wrapping needed here — model snapshot processors
+        // delegate to the data type checker, which handles path segments at the property level.
+        (sn) => {
+          if (sn[modelTypeKey]) {
+            return sn
+          } else {
+            return {
+              ...sn,
+              [modelTypeKey]: modelInfo.name,
+            }
+          }
+        },
+
+        (sn) => sn
+      )
+
+      return thisTc
+    }, typeInfoGen) as any
+
+    cachedModelTypeChecker.set(modelClazz, tc)
+    modelStandardTypes.add(tc as object)
+
+    return tc
+  }
+}
+
+/**
+ * `types.model` type info for a model props.
+ */
+export interface ModelTypeInfoProps {
+  readonly [propName: string]: Readonly<{
+    type: AnyStandardType | undefined
+    typeInfo: TypeInfo | undefined
+    hasDefault: boolean
+    default: any
+  }>
+}
+
+/**
+ * `types.model` type info.
+ */
+export class ModelTypeInfo extends TypeInfo {
+  readonly kind = "model"
+  readonly modelClass: ModelClass<AnyModel>
+
+  private _props = lazy(() => {
+    const objSchema = getInternalModelClassPropsInfo(this.modelClass)
+
+    const propTypes: O.Writable<ModelTypeInfoProps> = {}
+    Object.keys(objSchema).forEach((propName) => {
+      const propData = objSchema[propName]
+
+      const type = propData._typeChecker
+
+      let typeInfo: TypeInfo | undefined
+      if (type) {
+        typeInfo = getTypeInfo(type)
+      }
+
+      let hasDefault = false
+      let defaultValue: any
+      if (propData._defaultFn !== noDefaultValue) {
+        defaultValue = propData._defaultFn
+        hasDefault = true
+      } else if (propData._defaultValue !== noDefaultValue) {
+        defaultValue = propData._defaultValue
+        hasDefault = true
+      }
+
+      propTypes[propName] = {
+        type,
+        typeInfo,
+        hasDefault,
+        default: defaultValue,
+      }
+    })
+    return propTypes
+  })
+
+  get props(): ModelTypeInfoProps {
+    return this._props()
+  }
+
+  get modelType(): string {
+    const modelInfo = modelInfoByClass.get(this.modelClass)!
+    return modelInfo.name
+  }
+
+  constructor(thisType: AnyStandardType, modelClass: ModelClass<AnyModel>) {
+    super(thisType)
+    this.modelClass = modelClass
+  }
+}
+
+/**
+ * @internal
+ */
+export function registerModelStandardTypeResolver() {
+  registerStandardTypeResolver((v) => (isModelClass(v) ? typesModel(v) : undefined))
+}
+
+/**
+ * @internal
+ */
+export function isModelStandardType(value: unknown): boolean {
+  return typeof value === "object" || typeof value === "function"
+    ? modelStandardTypes.has(value as object)
+    : false
+}