mobx-keystone 1.20.0 → 1.22.0

package/src/types/objectBased/typesArraySet.ts

@@ -1,134 +1,133 @@
-import { modelTypeKey } from "../../model/metadata"
-import { modelInfoByClass } from "../../modelShared/modelInfo"
-import { isObject } from "../../utils"
-import { withErrorPathSegment } from "../../utils/errorDiagnostics"
-import { ArraySet } from "../../wrappers/ArraySet"
-import { typesArray } from "../arrayBased/typesArray"
-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"
-
-/**
- * A type that represents an array backed set ArraySet.
- *
- * Example:
- * ```ts
- * const numberSetType = types.arraySet(types.number)
- * ```
- *
- * @template T Value type.
- * @param valueType Value type.
- * @returns
- */
-export function typesArraySet<T extends AnyType>(valueType: T): ModelType<ArraySet<TypeToData<T>>> {
-  const typeInfoGen: TypeInfoGen = (t) => new ArraySetTypeInfo(t, resolveStandardType(valueType))
-
-  return lateTypeChecker(() => {
-    const modelInfo = modelInfoByClass.get(ArraySet)!
-
-    const valueChecker = resolveTypeChecker(valueType)
-    const valueSupport = resolveCodecSupport(valueType)
-    const storedValueChecker = resolveTypeChecker(valueSupport.storedType)
-
-    const getTypeName = (...recursiveTypeCheckers: TypeChecker[]) =>
-      `ArraySet<${valueChecker.getTypeName(...recursiveTypeCheckers, valueChecker)}>`
-
-    const dataTypeChecker = typesObject(() => ({
-      items: typesArray(valueSupport.storedType as any),
-    }))
-
-    const thisTc: TypeChecker = new TypeChecker(
-      TypeCheckerBaseType.Object, // because it is really a model
-
-      (obj, path, typeCheckedValue) => {
-        if (!(obj instanceof ArraySet)) {
-          return new TypeCheckError({
-            path,
-            expectedTypeName: getTypeName(thisTc),
-            actualValue: obj,
-            typeCheckedValue,
-          })
-        }
-
-        const resolvedTc = resolveTypeChecker(dataTypeChecker)
-        return resolvedTc.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
-        }
-
-        const resolvedTc = resolveTypeChecker(dataTypeChecker)
-        return resolvedTc.snapshotType(obj) ? thisTc : null
-      },
-
-      (sn: { items: unknown[] }) => {
-        const items = withErrorPathSegment("items", () =>
-          sn.items.map((v, i) =>
-            withErrorPathSegment(i, () => storedValueChecker.fromSnapshotProcessor(v))
-          )
-        )
-
-        return {
-          ...sn,
-          [modelTypeKey]: modelInfo.name,
-          items,
-        }
-      },
-
-      (sn: { items: unknown[]; [modelTypeKey]?: string }) => {
-        const items = withErrorPathSegment("items", () =>
-          sn.items.map((v, i) =>
-            withErrorPathSegment(i, () => storedValueChecker.toSnapshotProcessor(v))
-          )
-        )
-
-        const snCopy = {
-          ...sn,
-          items,
-        }
-
-        return snCopy
-      }
-    )
-
-    return thisTc
-  }, typeInfoGen) as any
-}
-
-/**
- * `types.arraySet` type info.
- */
-export class ArraySetTypeInfo extends TypeInfo {
-  readonly kind = "arraySet"
-
-  get valueTypeInfo(): TypeInfo {
-    return getTypeInfo(this.valueType)
-  }
-
-  constructor(
-    originalType: AnyStandardType,
-    readonly valueType: AnyStandardType
-  ) {
-    super(originalType)
-  }
-}
+import { modelTypeKey } from "../../model/metadata"
+import { modelInfoByClass } from "../../modelShared/modelInfo"
+import { isObject } from "../../utils"
+import { withErrorPathSegment } from "../../utils/errorDiagnostics"
+import { ArraySet } from "../../wrappers/ArraySet"
+import { typesArray } from "../arrayBased/typesArray"
+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"
+
+/**
+ * A type that represents an array backed set ArraySet.
+ *
+ * Example:
+ * ```ts
+ * const numberSetType = types.arraySet(types.number)
+ * ```
+ *
+ * @template T Value type.
+ * @param valueType Value type.
+ * @returns
+ */
+export function typesArraySet<T extends AnyType>(valueType: T): ModelType<ArraySet<TypeToData<T>>> {
+  const typeInfoGen: TypeInfoGen = (t) => new ArraySetTypeInfo(t, resolveStandardType(valueType))
+
+  return lateTypeChecker(() => {
+    const modelInfo = modelInfoByClass.get(ArraySet)!
+
+    const valueChecker = resolveTypeChecker(valueType)
+    const valueSupport = resolveCodecSupport(valueType)
+    const storedValueChecker = resolveTypeChecker(valueSupport.storedType)
+
+    const getTypeName = (...recursiveTypeCheckers: TypeChecker[]) =>
+      `ArraySet<${valueChecker.getTypeName(...recursiveTypeCheckers, valueChecker)}>`
+
+    const dataTypeChecker = typesObject(() => ({
+      items: typesArray(valueSupport.storedType as any),
+    }))
+
+    const thisTc: TypeChecker = new TypeChecker(
+      TypeCheckerBaseType.Object, // because it is really a model
+
+      (obj, path, typeCheckedValue) => {
+        if (!(obj instanceof ArraySet)) {
+          return new TypeCheckError({
+            path,
+            expectedTypeName: getTypeName(thisTc),
+            actualValue: obj,
+            typeCheckedValue,
+          })
+        }
+
+        const resolvedTc = resolveTypeChecker(dataTypeChecker)
+        return resolvedTc.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
+        }
+
+        const resolvedTc = resolveTypeChecker(dataTypeChecker)
+        return resolvedTc.snapshotType(obj) ? thisTc : null
+      },
+
+      (sn: { items: unknown[] }) => {
+        const items = withErrorPathSegment("items", () =>
+          sn.items.map((v, i) =>
+            withErrorPathSegment(i, () => storedValueChecker.fromSnapshotProcessor(v))
+          )
+        )
+
+        return {
+          ...sn,
+          [modelTypeKey]: modelInfo.name,
+          items,
+        }
+      },
+
+      (sn: { items: unknown[]; [modelTypeKey]?: string }) => {
+        const items = withErrorPathSegment("items", () =>
+          sn.items.map((v, i) =>
+            withErrorPathSegment(i, () => storedValueChecker.toSnapshotProcessor(v))
+          )
+        )
+
+        const snCopy = {
+          ...sn,
+          items,
+        }
+
+        return snCopy
+      }
+    )
+
+    return thisTc
+  }, typeInfoGen) as any
+}
+
+/**
+ * `types.arraySet` type info.
+ */
+export class ArraySetTypeInfo extends TypeInfo {
+  readonly kind = "arraySet"
+  readonly valueType: AnyStandardType
+
+  get valueTypeInfo(): TypeInfo {
+    return getTypeInfo(this.valueType)
+  }
+
+  constructor(originalType: AnyStandardType, valueType: AnyStandardType) {
+    super(originalType)
+    this.valueType = valueType
+  }
+}

package/src/types/objectBased/typesDataModelData.ts

@@ -1,204 +1,203 @@
-import type { O } from "ts-toolbelt"
-import type { AnyDataModel } from "../../dataModel/BaseDataModel"
-import { getDataModelMetadata } from "../../dataModel/getDataModelMetadata"
-import { isDataModelClass } from "../../dataModel/utils"
-import type {
-  ModelClass,
-  ModelData,
-  ModelUntransformedData,
-} from "../../modelShared/BaseModelShared"
-import { modelInfoByClass } from "../../modelShared/modelInfo"
-import { getInternalModelClassPropsInfo } from "../../modelShared/modelPropsInfo"
-import { noDefaultValue } from "../../modelShared/prop"
-import { failure, lazy } from "../../utils"
-import { getTypeInfo } from "../getTypeInfo"
-import { registerStandardTypeResolver, resolveTypeChecker } from "../resolveTypeChecker"
-import type { AnyStandardType, IdentityType } from "../schemas"
-import {
-  lateTypeChecker,
-  TypeChecker,
-  TypeCheckerBaseType,
-  TypeInfo,
-  TypeInfoGen,
-} from "../TypeChecker"
-
-const cachedDataModelTypeChecker = new WeakMap<ModelClass<AnyDataModel>, TypeChecker>()
-const dataModelDataStandardTypes = 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 data model data.
- * The type referenced in the model decorator will be used for type checking.
- *
- * Example:
- * ```ts
- * const someDataModelDataType = types.dataModelData(SomeModel)
- * // or for recursive models
- * const someDataModelDataType = types.dataModelData<SomeModel>(() => SomeModel)
- * ```
- *
- * @template M Data model type.
- * @param modelClass Model class.
- * @returns
- */
-export function typesDataModelData<M = never, K = M>(
-  modelClass: _ClassOrObject<M, K>
-): IdentityType<
-  | ModelUntransformedData<
-      K extends M ? (M extends AnyDataModel ? M : never) : K extends AnyDataModel ? K : never
-    >
-  | ModelData<
-      K extends M ? (M extends AnyDataModel ? M : never) : K extends AnyDataModel ? K : never
-    >
-> {
-  // if we type it any stronger then recursive defs and so on stop working
-
-  if (!isDataModelClass(modelClass) && typeof modelClass === "function") {
-    // resolve later
-    const modelClassFn = modelClass as () => ModelClass<AnyDataModel>
-    const typeInfoGen: TypeInfoGen = (t) => new DataModelDataTypeInfo(t, modelClassFn())
-    const tc = lateTypeChecker(() => typesDataModelData(modelClassFn()) as any, typeInfoGen) as any
-    dataModelDataStandardTypes.add(tc as object)
-    return tc
-  } else {
-    const modelClazz: ModelClass<AnyDataModel> = modelClass as any
-
-    const cachedTypeChecker = cachedDataModelTypeChecker.get(modelClazz)
-    if (cachedTypeChecker) {
-      return cachedTypeChecker as any
-    }
-
-    const typeInfoGen: TypeInfoGen = (t) => new DataModelDataTypeInfo(t, modelClazz)
-
-    const tc = lateTypeChecker(() => {
-      const modelInfo = modelInfoByClass.get(modelClazz)!
-      const typeName = `DataModelData(${modelInfo.name})`
-
-      const dataTypeChecker = getDataModelMetadata(modelClazz).dataType
-      if (!dataTypeChecker) {
-        throw failure(
-          `type checking cannot be performed over data model data of type '${modelInfo.name}' since that model type has no data type declared, consider adding a data type or using types.unchecked() instead`
-        )
-      }
-
-      const resolvedDataTypeChecker = resolveTypeChecker(dataTypeChecker)
-
-      const thisTc: TypeChecker = new TypeChecker(
-        TypeCheckerBaseType.Object,
-
-        (value, path, typeCheckedValue) => {
-          return resolvedDataTypeChecker.check(value, path, typeCheckedValue)
-        },
-
-        () => typeName,
-        typeInfoGen,
-
-        (value) => {
-          return resolvedDataTypeChecker.snapshotType(value) ? thisTc : null
-        },
-
-        (sn: Record<string, unknown>) => {
-          return resolvedDataTypeChecker.fromSnapshotProcessor(sn)
-        },
-
-        (sn: Record<string, unknown>) => {
-          return resolvedDataTypeChecker.toSnapshotProcessor(sn)
-        }
-      )
-
-      return thisTc
-    }, typeInfoGen) as any
-
-    cachedDataModelTypeChecker.set(modelClazz, tc)
-    dataModelDataStandardTypes.add(tc as object)
-
-    return tc
-  }
-}
-
-/**
- * `types.dataModelData` type info for a model props.
- */
-export interface DataModelDataTypeInfoProps {
-  readonly [propName: string]: Readonly<{
-    type: AnyStandardType | undefined
-    typeInfo: TypeInfo | undefined
-    hasDefault: boolean
-    default: any
-  }>
-}
-
-/**
- * `types.dataModelData` type info.
- */
-export class DataModelDataTypeInfo extends TypeInfo {
-  readonly kind = "dataModelData"
-
-  private _props = lazy(() => {
-    const objSchema = getInternalModelClassPropsInfo(this.modelClass)
-
-    const propTypes: O.Writable<DataModelDataTypeInfoProps> = {}
-    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(): DataModelDataTypeInfoProps {
-    return this._props()
-  }
-
-  get modelType(): string {
-    const modelInfo = modelInfoByClass.get(this.modelClass)!
-    return modelInfo.name
-  }
-
-  constructor(
-    thisType: AnyStandardType,
-    readonly modelClass: ModelClass<AnyDataModel>
-  ) {
-    super(thisType)
-  }
-}
-
-/**
- * @internal
- */
-export function registerDataModelDataStandardTypeResolver() {
-  registerStandardTypeResolver((v) => (isDataModelClass(v) ? typesDataModelData(v) : undefined))
-}
-
-/**
- * @internal
- */
-export function isDataModelDataStandardType(value: unknown): boolean {
-  return typeof value === "object" || typeof value === "function"
-    ? dataModelDataStandardTypes.has(value as object)
-    : false
-}
+import type { O } from "ts-toolbelt"
+import type { AnyDataModel } from "../../dataModel/BaseDataModel"
+import { getDataModelMetadata } from "../../dataModel/getDataModelMetadata"
+import { isDataModelClass } from "../../dataModel/utils"
+import type {
+  ModelClass,
+  ModelData,
+  ModelUntransformedData,
+} from "../../modelShared/BaseModelShared"
+import { modelInfoByClass } from "../../modelShared/modelInfo"
+import { getInternalModelClassPropsInfo } from "../../modelShared/modelPropsInfo"
+import { noDefaultValue } from "../../modelShared/prop"
+import { failure, lazy } from "../../utils"
+import { getTypeInfo } from "../getTypeInfo"
+import { registerStandardTypeResolver, resolveTypeChecker } from "../resolveTypeChecker"
+import type { AnyStandardType, IdentityType } from "../schemas"
+import {
+  lateTypeChecker,
+  TypeChecker,
+  TypeCheckerBaseType,
+  TypeInfo,
+  type TypeInfoGen,
+} from "../TypeChecker"
+
+const cachedDataModelTypeChecker = new WeakMap<ModelClass<AnyDataModel>, TypeChecker>()
+const dataModelDataStandardTypes = 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 data model data.
+ * The type referenced in the model decorator will be used for type checking.
+ *
+ * Example:
+ * ```ts
+ * const someDataModelDataType = types.dataModelData(SomeModel)
+ * // or for recursive models
+ * const someDataModelDataType = types.dataModelData<SomeModel>(() => SomeModel)
+ * ```
+ *
+ * @template M Data model type.
+ * @param modelClass Model class.
+ * @returns
+ */
+export function typesDataModelData<M = never, K = M>(
+  modelClass: _ClassOrObject<M, K>
+): IdentityType<
+  | ModelUntransformedData<
+      K extends M ? (M extends AnyDataModel ? M : never) : K extends AnyDataModel ? K : never
+    >
+  | ModelData<
+      K extends M ? (M extends AnyDataModel ? M : never) : K extends AnyDataModel ? K : never
+    >
+> {
+  // if we type it any stronger then recursive defs and so on stop working
+
+  if (!isDataModelClass(modelClass) && typeof modelClass === "function") {
+    // resolve later
+    const modelClassFn = modelClass as () => ModelClass<AnyDataModel>
+    const typeInfoGen: TypeInfoGen = (t) => new DataModelDataTypeInfo(t, modelClassFn())
+    const tc = lateTypeChecker(() => typesDataModelData(modelClassFn()) as any, typeInfoGen) as any
+    dataModelDataStandardTypes.add(tc as object)
+    return tc
+  } else {
+    const modelClazz: ModelClass<AnyDataModel> = modelClass as any
+
+    const cachedTypeChecker = cachedDataModelTypeChecker.get(modelClazz)
+    if (cachedTypeChecker) {
+      return cachedTypeChecker as any
+    }
+
+    const typeInfoGen: TypeInfoGen = (t) => new DataModelDataTypeInfo(t, modelClazz)
+
+    const tc = lateTypeChecker(() => {
+      const modelInfo = modelInfoByClass.get(modelClazz)!
+      const typeName = `DataModelData(${modelInfo.name})`
+
+      const dataTypeChecker = getDataModelMetadata(modelClazz).dataType
+      if (!dataTypeChecker) {
+        throw failure(
+          `type checking cannot be performed over data model data of type '${modelInfo.name}' since that model type has no data type declared, consider adding a data type or using types.unchecked() instead`
+        )
+      }
+
+      const resolvedDataTypeChecker = resolveTypeChecker(dataTypeChecker)
+
+      const thisTc: TypeChecker = new TypeChecker(
+        TypeCheckerBaseType.Object,
+
+        (value, path, typeCheckedValue) => {
+          return resolvedDataTypeChecker.check(value, path, typeCheckedValue)
+        },
+
+        () => typeName,
+        typeInfoGen,
+
+        (value) => {
+          return resolvedDataTypeChecker.snapshotType(value) ? thisTc : null
+        },
+
+        (sn: Record<string, unknown>) => {
+          return resolvedDataTypeChecker.fromSnapshotProcessor(sn)
+        },
+
+        (sn: Record<string, unknown>) => {
+          return resolvedDataTypeChecker.toSnapshotProcessor(sn)
+        }
+      )
+
+      return thisTc
+    }, typeInfoGen) as any
+
+    cachedDataModelTypeChecker.set(modelClazz, tc)
+    dataModelDataStandardTypes.add(tc as object)
+
+    return tc
+  }
+}
+
+/**
+ * `types.dataModelData` type info for a model props.
+ */
+export interface DataModelDataTypeInfoProps {
+  readonly [propName: string]: Readonly<{
+    type: AnyStandardType | undefined
+    typeInfo: TypeInfo | undefined
+    hasDefault: boolean
+    default: any
+  }>
+}
+
+/**
+ * `types.dataModelData` type info.
+ */
+export class DataModelDataTypeInfo extends TypeInfo {
+  readonly kind = "dataModelData"
+  readonly modelClass: ModelClass<AnyDataModel>
+
+  private _props = lazy(() => {
+    const objSchema = getInternalModelClassPropsInfo(this.modelClass)
+
+    const propTypes: O.Writable<DataModelDataTypeInfoProps> = {}
+    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(): DataModelDataTypeInfoProps {
+    return this._props()
+  }
+
+  get modelType(): string {
+    const modelInfo = modelInfoByClass.get(this.modelClass)!
+    return modelInfo.name
+  }
+
+  constructor(thisType: AnyStandardType, modelClass: ModelClass<AnyDataModel>) {
+    super(thisType)
+    this.modelClass = modelClass
+  }
+}
+
+/**
+ * @internal
+ */
+export function registerDataModelDataStandardTypeResolver() {
+  registerStandardTypeResolver((v) => (isDataModelClass(v) ? typesDataModelData(v) : undefined))
+}
+
+/**
+ * @internal
+ */
+export function isDataModelDataStandardType(value: unknown): boolean {
+  return typeof value === "object" || typeof value === "function"
+    ? dataModelDataStandardTypes.has(value as object)
+    : false
+}