mobx-keystone 1.20.0 → 1.22.0

package/src/types/utility/typesTag.ts

@@ -1,82 +1,88 @@
-import { getTypeInfo } from "../getTypeInfo"
-import { resolveStandardType, resolveTypeChecker } from "../resolveTypeChecker"
-import type { AnyStandardType, AnyType } from "../schemas"
-import { lateTypeChecker, TypeChecker, TypeInfo, TypeInfoGen } from "../TypeChecker"
-
-/**
- * Wrap a given type with tag information.
- * This allows you to associate metadata with the type of a prop that
- * you can use at runtime.
- *
- * Example:
- * ```ts
- * const widthType = types.tag(types.number, { displayName: "Width in Inches", required: true }, "dimension")
- * const heightType = types.tag(types.number, { displayName: "Height in Inches", required: true }, "dimension")
- * ```
- *
- * These can then be accessed at runtime through inspection APIs, e.g.
- * ```
- * @model('MyModel')
- * class MyModel extends Model({
- *   width: tProp(widthType, 10),
- *   height: tProp(heightType, 10)
- * }) {}
- *
- * const m = new MyModel({})
- * const type = types.model<typeof Model>(m.constructor)
- * const modelTypeInfo = getTypeInfo(type) as ModelTypeInfo
- * const propTypeInfo = modelTypeInfo.props.width.typeInfo as TagTypeInfo
- * const displayName = propTypeInfo.displayName
- * ```
- * @template T Base type.
- * @param baseType Base type.
- * @template A Tag object.
- * @param tag Abitrary object that can be queried at runtime.
- * @returns
- */
-export function typesTag<T extends AnyType, A>(baseType: T, tag: A, typeName?: string): T {
-  const typeInfoGen: TypeInfoGen = (t) =>
-    new TagTypeInfo(t, resolveStandardType(baseType), tag, typeName)
-
-  return lateTypeChecker(() => {
-    const baseChecker = resolveTypeChecker(baseType)
-
-    const getTypeName = (...recursiveTypeCheckers: TypeChecker[]) => {
-      const baseTypeName = baseChecker.getTypeName(...recursiveTypeCheckers, baseChecker)
-      const taggedName = typeName || "tagged"
-      return `${taggedName}<${baseTypeName}>`
-    }
-
-    const thisTc: TypeChecker = new TypeChecker(
-      baseChecker.baseType,
-      (data, path, typeCheckedValue) => baseChecker.check(data, path, typeCheckedValue),
-      getTypeName,
-      typeInfoGen,
-      (sn) => baseChecker.snapshotType(sn),
-      (sn) => baseChecker.fromSnapshotProcessor(sn),
-      (sn) => baseChecker.toSnapshotProcessor(sn)
-    )
-
-    return thisTc
-  }, typeInfoGen) as any
-}
-
-/**
- * `types.tag` type info.
- */
-export class TagTypeInfo<A> extends TypeInfo {
-  readonly kind = "tag"
-
-  get baseTypeInfo(): TypeInfo {
-    return getTypeInfo(this.baseType)
-  }
-
-  constructor(
-    thisType: AnyStandardType,
-    readonly baseType: AnyStandardType,
-    readonly tag: A,
-    readonly typeName: string | undefined
-  ) {
-    super(thisType)
-  }
-}
+import { getTypeInfo } from "../getTypeInfo"
+import { resolveStandardType, resolveTypeChecker } from "../resolveTypeChecker"
+import type { AnyStandardType, AnyType } from "../schemas"
+import { lateTypeChecker, TypeChecker, TypeInfo, type TypeInfoGen } from "../TypeChecker"
+
+/**
+ * Wrap a given type with tag information.
+ * This allows you to associate metadata with the type of a prop that
+ * you can use at runtime.
+ *
+ * Example:
+ * ```ts
+ * const widthType = types.tag(types.number, { displayName: "Width in Inches", required: true }, "dimension")
+ * const heightType = types.tag(types.number, { displayName: "Height in Inches", required: true }, "dimension")
+ * ```
+ *
+ * These can then be accessed at runtime through inspection APIs, e.g.
+ * ```
+ * @model('MyModel')
+ * class MyModel extends Model({
+ *   width: tProp(widthType, 10),
+ *   height: tProp(heightType, 10)
+ * }) {}
+ *
+ * const m = new MyModel({})
+ * const type = types.model<typeof Model>(m.constructor)
+ * const modelTypeInfo = getTypeInfo(type) as ModelTypeInfo
+ * const propTypeInfo = modelTypeInfo.props.width.typeInfo as TagTypeInfo
+ * const displayName = propTypeInfo.displayName
+ * ```
+ * @template T Base type.
+ * @param baseType Base type.
+ * @template A Tag object.
+ * @param tag Abitrary object that can be queried at runtime.
+ * @returns
+ */
+export function typesTag<T extends AnyType, A>(baseType: T, tag: A, typeName?: string): T {
+  const typeInfoGen: TypeInfoGen = (t) =>
+    new TagTypeInfo(t, resolveStandardType(baseType), tag, typeName)
+
+  return lateTypeChecker(() => {
+    const baseChecker = resolveTypeChecker(baseType)
+
+    const getTypeName = (...recursiveTypeCheckers: TypeChecker[]) => {
+      const baseTypeName = baseChecker.getTypeName(...recursiveTypeCheckers, baseChecker)
+      const taggedName = typeName || "tagged"
+      return `${taggedName}<${baseTypeName}>`
+    }
+
+    const thisTc: TypeChecker = new TypeChecker(
+      baseChecker.baseType,
+      (data, path, typeCheckedValue) => baseChecker.check(data, path, typeCheckedValue),
+      getTypeName,
+      typeInfoGen,
+      (sn) => baseChecker.snapshotType(sn),
+      (sn) => baseChecker.fromSnapshotProcessor(sn),
+      (sn) => baseChecker.toSnapshotProcessor(sn)
+    )
+
+    return thisTc
+  }, typeInfoGen) as any
+}
+
+/**
+ * `types.tag` type info.
+ */
+export class TagTypeInfo<A> extends TypeInfo {
+  readonly kind = "tag"
+  readonly baseType: AnyStandardType
+  readonly tag: A
+  readonly typeName: string | undefined
+
+  get baseTypeInfo(): TypeInfo {
+    return getTypeInfo(this.baseType)
+  }
+
+  constructor(
+    thisType: AnyStandardType,
+    baseType: AnyStandardType,
+    tag: A,
+    typeName: string | undefined
+  ) {
+    super(thisType)
+    this.baseType = baseType
+    this.tag = tag
+    this.typeName = typeName
+  }
+}

package/src/types/utility/typesUnchecked.ts

@@ -1,40 +1,40 @@
-import { identityFn } from "../../utils"
-import type { IdentityType } from "../schemas"
-import { TypeChecker, TypeCheckerBaseType, TypeInfo } from "../TypeChecker"
-
-const unchecked: IdentityType<any> = new TypeChecker(
-  TypeCheckerBaseType.Any,
-  null,
-  () => "any",
-  (t) => new UncheckedTypeInfo(t),
-
-  () => unchecked as any,
-
-  identityFn,
-  identityFn
-) as any
-
-/**
- * A type that represents a given value that won't be type checked.
- * This is basically a way to bail out of the runtime type checking system.
- *
- * Example:
- * ```ts
- * const uncheckedSomeModel = types.unchecked<SomeModel>()
- * const anyType = types.unchecked<any>()
- * const customUncheckedType = types.unchecked<(A & B) | C>()
- * ```
- *
- * @template T Type of the value, or unkown if not given.
- * @returns
- */
-export function typesUnchecked<T = never>(): IdentityType<T> {
-  return unchecked
-}
-
-/**
- * `types.unchecked` type info.
- */
-export class UncheckedTypeInfo extends TypeInfo {
-  readonly kind = "unchecked"
-}
+import { identityFn } from "../../utils"
+import type { IdentityType } from "../schemas"
+import { TypeChecker, TypeCheckerBaseType, TypeInfo } from "../TypeChecker"
+
+const unchecked: IdentityType<any> = new TypeChecker(
+  TypeCheckerBaseType.Any,
+  null,
+  () => "any",
+  (t) => new UncheckedTypeInfo(t),
+
+  () => unchecked as any,
+
+  identityFn,
+  identityFn
+) as any
+
+/**
+ * A type that represents a given value that won't be type checked.
+ * This is basically a way to bail out of the runtime type checking system.
+ *
+ * Example:
+ * ```ts
+ * const uncheckedSomeModel = types.unchecked<SomeModel>()
+ * const anyType = types.unchecked<any>()
+ * const customUncheckedType = types.unchecked<(A & B) | C>()
+ * ```
+ *
+ * @template T Type of the value, or unkown if not given.
+ * @returns
+ */
+export function typesUnchecked<T = never>(): IdentityType<T> {
+  return unchecked
+}
+
+/**
+ * `types.unchecked` type info.
+ */
+export class UncheckedTypeInfo extends TypeInfo {
+  readonly kind = "unchecked"
+}

package/src/utils/AnyFunction.ts

@@ -1,4 +1,4 @@
-/**
- * Any function type.
- */
-export type AnyFunction = (...args: any[]) => any
+/**
+ * Any function type.
+ */
+export type AnyFunction = (...args: any[]) => any

package/src/utils/ModelPool.ts

@@ -1,59 +1,59 @@
-import type { AnyModel } from "../model/BaseModel"
-import { getModelIdPropertyName } from "../model/getModelMetadata"
-import { modelIdKey, modelTypeKey } from "../model/metadata"
-import { getSnapshotModelType, isModel } from "../model/utils"
-import { ModelClass } from "../modelShared/BaseModelShared"
-import { getModelInfoForName } from "../modelShared/modelInfo"
-import { dataObjectParent } from "../parent/core"
-import {
-  getDeepObjectChildren,
-  registerDeepObjectChildrenExtension,
-} from "../parent/coreObjectChildren"
-
-function byModelTypeAndIdKey(modelType: string, modelId: string) {
-  return JSON.stringify([modelType, modelId])
-}
-
-export class ModelPool {
-  private pool: ReadonlyMap<string, AnyModel>
-
-  constructor(root: object) {
-    // make sure we don't use the sub-data $ object
-    root = dataObjectParent.get(root) ?? root
-
-    this.pool = getDeepChildrenModels(getDeepObjectChildren(root))
-  }
-
-  findModelByTypeAndId(modelType: string, modelId: string | undefined): AnyModel | undefined {
-    return modelId ? this.pool.get(byModelTypeAndIdKey(modelType, modelId)) : undefined
-  }
-
-  findModelForSnapshot(sn: any): AnyModel | undefined {
-    const modelType = getSnapshotModelType(sn)
-    if (modelType === undefined) {
-      return undefined
-    }
-
-    const modelInfo = getModelInfoForName(modelType)!
-    const modelIdPropertyName = getModelIdPropertyName(modelInfo.class as ModelClass<AnyModel>)
-
-    return modelIdPropertyName
-      ? this.findModelByTypeAndId(modelType, (sn as any)[modelIdPropertyName])
-      : undefined
-  }
-}
-
-const getDeepChildrenModels = registerDeepObjectChildrenExtension<Map<string, AnyModel>>({
-  initData() {
-    return new Map()
-  },
-
-  addNode(node, data) {
-    if (isModel(node)) {
-      const id = node[modelIdKey]
-      if (id) {
-        data.set(byModelTypeAndIdKey(node[modelTypeKey], id), node)
-      }
-    }
-  },
-})
+import type { AnyModel } from "../model/BaseModel"
+import { getModelIdPropertyName } from "../model/getModelMetadata"
+import { modelIdKey, modelTypeKey } from "../model/metadata"
+import { getSnapshotModelType, isModel } from "../model/utils"
+import type { ModelClass } from "../modelShared/BaseModelShared"
+import { getModelInfoForName } from "../modelShared/modelInfo"
+import { dataObjectParent } from "../parent/core"
+import {
+  getDeepObjectChildren,
+  registerDeepObjectChildrenExtension,
+} from "../parent/coreObjectChildren"
+
+function byModelTypeAndIdKey(modelType: string, modelId: string) {
+  return JSON.stringify([modelType, modelId])
+}
+
+export class ModelPool {
+  private pool: ReadonlyMap<string, AnyModel>
+
+  constructor(root: object) {
+    // make sure we don't use the sub-data $ object
+    root = dataObjectParent.get(root) ?? root
+
+    this.pool = getDeepChildrenModels(getDeepObjectChildren(root))
+  }
+
+  findModelByTypeAndId(modelType: string, modelId: string | undefined): AnyModel | undefined {
+    return modelId ? this.pool.get(byModelTypeAndIdKey(modelType, modelId)) : undefined
+  }
+
+  findModelForSnapshot(sn: any): AnyModel | undefined {
+    const modelType = getSnapshotModelType(sn)
+    if (modelType === undefined) {
+      return undefined
+    }
+
+    const modelInfo = getModelInfoForName(modelType)!
+    const modelIdPropertyName = getModelIdPropertyName(modelInfo.class as ModelClass<AnyModel>)
+
+    return modelIdPropertyName
+      ? this.findModelByTypeAndId(modelType, (sn as any)[modelIdPropertyName])
+      : undefined
+  }
+}
+
+const getDeepChildrenModels = registerDeepObjectChildrenExtension<Map<string, AnyModel>>({
+  initData() {
+    return new Map()
+  },
+
+  addNode(node, data) {
+    if (isModel(node)) {
+      const id = node[modelIdKey]
+      if (id) {
+        data.set(byModelTypeAndIdKey(node[modelTypeKey], id), node)
+      }
+    }
+  },
+})

package/src/utils/chainFns.ts

@@ -1,18 +1,18 @@
-export function chainFns<F extends Function>(...fns: (F | undefined)[]): F | undefined {
-  const definedFns = fns.filter((fn) => !!fn)
-  if (definedFns.length <= 0) {
-    return undefined
-  }
-
-  const chainedFn = (v: any, ...args: any[]) => {
-    let ret = v
-
-    for (let i = 0; i < definedFns.length; i++) {
-      ret = definedFns[i](ret, ...args)
-    }
-
-    return ret
-  }
-
-  return chainedFn as unknown as F
-}
+export function chainFns<F extends Function>(...fns: (F | undefined)[]): F | undefined {
+  const definedFns = fns.filter((fn) => !!fn)
+  if (definedFns.length <= 0) {
+    return undefined
+  }
+
+  const chainedFn = (v: any, ...args: any[]) => {
+    let ret = v
+
+    for (let i = 0; i < definedFns.length; i++) {
+      ret = definedFns[i](ret, ...args)
+    }
+
+    return ret
+  }
+
+  return chainedFn as unknown as F
+}