mobx-keystone 0.67.4 → 0.68.1-alpha

package/src/dist/types/TypeCheckError.d.ts

@@ -0,0 +1,22 @@
+import { Path } from "../parent/pathTypes";
+/**
+ * A type checking error.
+ */
+export declare class TypeCheckError {
+    readonly path: Path;
+    readonly expectedTypeName: string;
+    readonly actualValue: any;
+    /**
+     * Creates an instance of TypeError.
+     * @param path Sub-path where the error occured.
+     * @param expectedTypeName Name of the expected type.
+     * @param actualValue Actual value.
+     */
+    constructor(path: Path, expectedTypeName: string, actualValue: any);
+    /**
+     * Throws the type check error as an actual error.
+     *
+     * @param typeCheckedValue Usually the value where the type check was invoked.
+     */
+    throw(typeCheckedValue: any): never;
+}

package/src/dist/types/TypeChecker.d.ts

@@ -0,0 +1,8 @@
+import type { AnyStandardType } from "./schemas";
+/**
+ * Type info base class.
+ */
+export declare class TypeInfo {
+    readonly thisType: AnyStandardType;
+    constructor(thisType: AnyStandardType);
+}

package/src/dist/types/arrayBased/array.d.ts

@@ -0,0 +1,23 @@
+import type { AnyStandardType, AnyType, ArrayType } from "../schemas";
+import { TypeInfo } from "../TypeChecker";
+/**
+ * A type that represents an array of values of a given type.
+ *
+ * Example:
+ * ```ts
+ * const numberArrayType = types.array(types.number)
+ * ```
+ *
+ * @typeparam T Item type.
+ * @param itemType Type of inner items.
+ * @returns
+ */
+export declare function typesArray<T extends AnyType>(itemType: T): ArrayType<T[]>;
+/**
+ * `types.array` type info.
+ */
+export declare class ArrayTypeInfo extends TypeInfo {
+    readonly itemType: AnyStandardType;
+    get itemTypeInfo(): TypeInfo;
+    constructor(thisType: AnyStandardType, itemType: AnyStandardType);
+}

package/src/dist/types/arrayBased/tuple.d.ts

@@ -0,0 +1,24 @@
+import type { AnyStandardType, AnyType, ArrayType } from "../schemas";
+import { TypeInfo } from "../TypeChecker";
+/**
+ * A type that represents an tuple of values of a given type.
+ *
+ * Example:
+ * ```ts
+ * const stringNumberTupleType = types.tuple(types.string, types.number)
+ * ```
+ *
+ * @typeparam T Item types.
+ * @param itemType Type of inner items.
+ * @returns
+ */
+export declare function typesTuple<T extends AnyType[]>(...itemTypes: T): ArrayType<T>;
+/**
+ * `types.tuple` type info.
+ */
+export declare class TupleTypeInfo extends TypeInfo {
+    readonly itemTypes: ReadonlyArray<AnyStandardType>;
+    private _itemTypeInfos;
+    get itemTypeInfos(): ReadonlyArray<TypeInfo>;
+    constructor(thisType: AnyStandardType, itemTypes: ReadonlyArray<AnyStandardType>);
+}

package/src/dist/types/getTypeInfo.d.ts

@@ -0,0 +1,9 @@
+import type { AnyType } from "./schemas";
+import type { TypeInfo } from "./TypeChecker";
+/**
+ * Gets the type info of a given type.
+ *
+ * @param type Type to get the info from.
+ * @returns The type info.
+ */
+export declare function getTypeInfo(type: AnyType): TypeInfo;

package/src/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./schemas";
+export * from "./tProp";
+export * from "./typeCheck";
+export * from "./TypeCheckError";
+export * from "./types";

package/src/dist/types/objectBased/arraySet.d.ts

@@ -0,0 +1,24 @@
+import { ArraySet } from "../../wrappers/ArraySet";
+import type { AnyStandardType, AnyType, ModelType, TypeToData } from "../schemas";
+import { TypeInfo } from "../TypeChecker";
+/**
+ * A type that represents an array backed set ArraySet.
+ *
+ * Example:
+ * ```ts
+ * const numberSetType = types.arraySet(types.number)
+ * ```
+ *
+ * @typeparam T Value type.
+ * @param valueType Value type.
+ * @returns
+ */
+export declare function typesArraySet<T extends AnyType>(valueType: T): ModelType<ArraySet<TypeToData<T>>>;
+/**
+ * `types.arraySet` type info.
+ */
+export declare class ArraySetTypeInfo extends TypeInfo {
+    readonly valueType: AnyStandardType;
+    get valueTypeInfo(): TypeInfo;
+    constructor(originalType: AnyStandardType, valueType: AnyStandardType);
+}

package/src/dist/types/objectBased/dataModelData.d.ts

@@ -0,0 +1,44 @@
+import type { AnyDataModel } from "../../dataModel/BaseDataModel";
+import type { ModelClass, ModelData } from "../../modelShared/BaseModelShared";
+import type { AnyStandardType, IdentityType } from "../schemas";
+import { TypeInfo } from "../TypeChecker";
+declare type _Class<T> = abstract new (...args: any[]) => T;
+declare 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)
+ * ```
+ *
+ * @typeparam M Data model type.
+ * @param modelClass Model class.
+ * @returns
+ */
+export declare function typesDataModelData<M = never, K = M>(modelClass: _ClassOrObject<M, K>): IdentityType<ModelData<K extends M ? (M extends AnyDataModel ? M : never) : K extends AnyDataModel ? K : never>>;
+/**
+ * `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 declare class DataModelDataTypeInfo extends TypeInfo {
+    readonly modelClass: ModelClass<AnyDataModel>;
+    private _props;
+    get props(): DataModelDataTypeInfoProps;
+    get modelType(): string;
+    constructor(thisType: AnyStandardType, modelClass: ModelClass<AnyDataModel>);
+}
+export {};

package/src/dist/types/objectBased/model.d.ts

@@ -0,0 +1,43 @@
+import type { AnyModel } from "../../model/BaseModel";
+import type { ModelClass } from "../../modelShared/BaseModelShared";
+import type { AnyStandardType, ModelType } from "../schemas";
+import { TypeInfo } from "../TypeChecker";
+declare type _Class<T> = abstract new (...args: any[]) => T;
+declare 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)
+ * ```
+ *
+ * @typeparam M Model type.
+ * @param modelClass Model class.
+ * @returns
+ */
+export declare function typesModel<M = never, K = M>(modelClass: _ClassOrObject<M, K>): ModelType<K>;
+/**
+ * `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 declare class ModelTypeInfo extends TypeInfo {
+    readonly modelClass: ModelClass<AnyModel>;
+    private _props;
+    get props(): ModelTypeInfoProps;
+    get modelType(): string;
+    constructor(thisType: AnyStandardType, modelClass: ModelClass<AnyModel>);
+}
+export {};

package/src/dist/types/objectBased/object.d.ts

@@ -0,0 +1,63 @@
+import { Frozen } from "../../frozen/Frozen";
+import type { AnyStandardType, AnyType, ModelType, ObjectTypeFunction, TypeToData } from "../schemas";
+import { TypeInfo } from "../TypeChecker";
+/**
+ * A type that represents a plain object.
+ * Note that the parameter must be a function that returns an object. This is done so objects can support self / cross types.
+ *
+ * Example:
+ * ```ts
+ * // notice the ({ ... }), not just { ... }
+ * const pointType = types.object(() => ({
+ *   x: types.number,
+ *   y: types.number
+ * }))
+ * ```
+ *
+ * @typeparam T Type.
+ * @param objectFunction Function that generates an object with types.
+ * @returns
+ */
+export declare function typesObject<T>(objectFunction: T): T;
+/**
+ * `types.object` type info for an object props.
+ */
+export interface ObjectTypeInfoProps {
+    readonly [propName: string]: Readonly<{
+        type: AnyStandardType;
+        typeInfo: TypeInfo;
+    }>;
+}
+/**
+ * `types.object` type info.
+ */
+export declare class ObjectTypeInfo extends TypeInfo {
+    private _objTypeFn;
+    private _props;
+    get props(): ObjectTypeInfoProps;
+    constructor(thisType: AnyStandardType, _objTypeFn: ObjectTypeFunction);
+}
+/**
+ * A type that represents frozen data.
+ *
+ * Example:
+ * ```ts
+ * const frozenNumberType = types.frozen(types.number)
+ * const frozenAnyType = types.frozen(types.unchecked<any>())
+ * const frozenNumberArrayType = types.frozen(types.array(types.number))
+ * const frozenUncheckedNumberArrayType = types.frozen(types.unchecked<number[]>())
+ * ```
+ *
+ * @typeparam T Type.
+ * @param dataType Type of the frozen data.
+ * @returns
+ */
+export declare function typesFrozen<T extends AnyType>(dataType: T): ModelType<Frozen<TypeToData<T>>>;
+/**
+ * `types.frozen` type info.
+ */
+export declare class FrozenTypeInfo extends TypeInfo {
+    readonly dataType: AnyStandardType;
+    get dataTypeInfo(): TypeInfo;
+    constructor(thisType: AnyStandardType, dataType: AnyStandardType);
+}

package/src/dist/types/objectBased/objectMap.d.ts

@@ -0,0 +1,24 @@
+import { ObjectMap } from "../../wrappers/ObjectMap";
+import type { AnyStandardType, AnyType, ModelType, TypeToData } from "../schemas";
+import { TypeInfo } from "../TypeChecker";
+/**
+ * A type that represents an object-like map ObjectMap.
+ *
+ * Example:
+ * ```ts
+ * const numberMapType = types.objectMap(types.number)
+ * ```
+ *
+ * @typeparam T Value type.
+ * @param valueType Value type.
+ * @returns
+ */
+export declare function typesObjectMap<T extends AnyType>(valueType: T): ModelType<ObjectMap<TypeToData<T>>>;
+/**
+ * `types.objectMap` type info.
+ */
+export declare class ObjectMapTypeInfo extends TypeInfo {
+    readonly valueType: AnyStandardType;
+    get valueTypeInfo(): TypeInfo;
+    constructor(thisType: AnyStandardType, valueType: AnyStandardType);
+}

package/src/dist/types/objectBased/record.d.ts

@@ -0,0 +1,24 @@
+import type { AnyStandardType, AnyType, RecordType } from "../schemas";
+import { TypeInfo } from "../TypeChecker";
+/**
+ * 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)
+ * ```
+ *
+ * @typeparam T Type.
+ * @param valueType Type of the values of the object-like map.
+ * @returns
+ */
+export declare function typesRecord<T extends AnyType>(valueType: T): RecordType<T>;
+/**
+ * `types.record` type info.
+ */
+export declare class RecordTypeInfo extends TypeInfo {
+    readonly valueType: AnyStandardType;
+    get valueTypeInfo(): TypeInfo;
+    constructor(thisType: AnyStandardType, valueType: AnyStandardType);
+}

package/src/dist/types/objectBased/ref.d.ts

@@ -0,0 +1,21 @@
+import { Ref, RefConstructor } from "../../ref/Ref";
+import type { ModelType } from "../schemas";
+import { TypeInfo } from "../TypeChecker";
+/**
+ * A type that represents a reference to an object or model.
+ *
+ * Example:
+ * ```ts
+ * const refToSomeObject = types.ref(SomeObject)
+ * ```
+ *
+ * @typeparam O Object or model type.
+ * @param refConstructor Ref object type.
+ * @returns
+ */
+export declare function typesRef<O extends object>(refConstructor: RefConstructor<O>): ModelType<Ref<O>>;
+/**
+ * `types.ref` type info.
+ */
+export declare class RefTypeInfo extends TypeInfo {
+}

package/src/dist/types/primitiveBased/enum.d.ts

@@ -0,0 +1,34 @@
+import type { IdentityType } from "../schemas";
+/**
+ * @ignore
+ * Enum like object.
+ */
+export interface EnumLike {
+    [k: string]: number | string;
+    [v: number]: string;
+}
+/**
+ * @ignore
+ * Extract enum values out of a enum object.
+ */
+export declare type EnumValues<E extends EnumLike> = E extends Record<infer _K, // eslint-disable-line @typescript-eslint/no-unused-vars
+infer V> ? V : never;
+/**
+ * An enum type, based on a TypeScript alike enum object.
+ * Syntactic sugar for `types.or(...enum_values.map(types.literal))`
+ *
+ * Example:
+ * ```ts
+ * enum Color {
+ *   Red = "red",
+ *   Green = "green"
+ * }
+ *
+ * const colorType = types.enum(Color)
+ * ```
+ *
+ * @typeparam E Enum type.
+ * @param enumObject
+ * @returns
+ */
+export declare function typesEnum<E extends EnumLike>(enumObject: E): IdentityType<EnumValues<E>>;

package/src/dist/types/primitiveBased/primitives.d.ts

@@ -0,0 +1,81 @@
+import type { PrimitiveValue } from "../../utils/types";
+import type { AnyStandardType, IdentityType } from "../schemas";
+import { TypeInfo } from "../TypeChecker";
+/**
+ * A type that represents a certain value of a primitive (for example an *exact* number or string).
+ *
+ * Example
+ * ```ts
+ * const hiType = types.literal("hi") // the string with value "hi"
+ * const number5Type = types.literal(5) // the number with value 5
+ * ```
+ *
+ * @typeparam T Literal value type.
+ * @param literal Literal value.
+ * @returns
+ */
+export declare function typesLiteral<T extends PrimitiveValue>(literal: T): IdentityType<T>;
+/**
+ * `types.literal` type info.
+ */
+export declare class LiteralTypeInfo extends TypeInfo {
+    readonly literal: PrimitiveValue;
+    constructor(thisType: AnyStandardType, literal: PrimitiveValue);
+}
+/**
+ * A type that represents the value undefined.
+ * Syntactic sugar for `types.literal(undefined)`.
+ *
+ * ```ts
+ * types.undefined
+ * ```
+ */
+export declare const typesUndefined: IdentityType<undefined>;
+/**
+ * A type that represents the value null.
+ * Syntactic sugar for `types.literal(null)`.
+ *
+ * ```ts
+ * types.null
+ * ```
+ */
+export declare const typesNull: IdentityType<null>;
+/**
+ * A type that represents any boolean value.
+ *
+ * ```ts
+ * types.boolean
+ * ```
+ */
+export declare const typesBoolean: IdentityType<boolean>;
+/**
+ * `types.boolean` type info.
+ */
+export declare class BooleanTypeInfo extends TypeInfo {
+}
+/**
+ * A type that represents any number value.
+ *
+ * ```ts
+ * types.number
+ * ```
+ */
+export declare const typesNumber: IdentityType<number>;
+/**
+ * `types.number` type info.
+ */
+export declare class NumberTypeInfo extends TypeInfo {
+}
+/**
+ * A type that represents any string value.
+ *
+ * ```ts
+ * types.string
+ * ```
+ */
+export declare const typesString: IdentityType<string>;
+/**
+ * `types.string` type info.
+ */
+export declare class StringTypeInfo extends TypeInfo {
+}

package/src/dist/types/primitiveBased/refinedPrimitives.d.ts

@@ -0,0 +1,18 @@
+/**
+ * A type that represents any integer number value.
+ * Syntactic sugar for `types.refinement(types.number, n => Number.isInteger(n), "integer")`
+ *
+ * ```ts
+ * types.integer
+ * ```
+ */
+export declare const typesInteger: import("..").IdentityType<number>;
+/**
+ * A type that represents any string value other than "".
+ * Syntactic sugar for `types.refinement(types.string, s => s !== "", "nonEmpty")`
+ *
+ * ```ts
+ * types.nonEmptyString
+ * ```
+ */
+export declare const typesNonEmptyString: import("..").IdentityType<string>;

package/src/dist/types/registerDefaultStandardTypeResolvers.d.ts

@@ -0,0 +1 @@
+export {};

package/src/dist/types/resolveTypeChecker.d.ts

@@ -0,0 +1 @@
+export {};

package/src/dist/types/schemas.d.ts

@@ -0,0 +1,53 @@
+import type { O } from "ts-toolbelt";
+import type { AnyModel } from "../model/BaseModel";
+import type { ModelClass } from "../modelShared/BaseModelShared";
+import type { IsOptionalValue } from "../utils/types";
+export interface Type<Name, Data> {
+    /** @ignore */
+    $$type: Name;
+    /** @ignore */
+    $$data: Data;
+}
+export interface IdentityType<Data> extends Type<"identity", Data> {
+}
+export interface ModelType<Model> extends Type<"model", Model> {
+}
+export interface ArrayType<S>// e.g. S = someType[] or [someType, someType]
+ extends Type<"array", {
+    [k in keyof S]: TypeToData<S[k]> extends infer R ? R : never;
+}> {
+}
+export interface ObjectOfTypes {
+    /** @ignore */
+    [k: string]: AnyType;
+}
+/**
+ * Name of the properties of an object that can be set to undefined, any or unknown
+ */
+declare type UndefinablePropsNames<T> = {
+    [K in keyof T]: IsOptionalValue<T[K], K, never>;
+}[keyof T];
+export interface ObjectType<S> extends Type<"object", O.Optional<{
+    [k in keyof S]: TypeToData<S[k]> extends infer R ? R : never;
+}, UndefinablePropsNames<{
+    [k in keyof S]: TypeToDataOpt<S[k]> extends infer R ? R : never;
+}>>> {
+}
+export interface ObjectTypeFunction {
+    (): ObjectOfTypes;
+}
+export interface RecordType<S> extends Type<"record", {
+    [k: string]: TypeToData<S> extends infer R ? R : never;
+}> {
+}
+export declare type AnyStandardType = IdentityType<any> | ModelType<any> | ArrayType<any> | ObjectType<any> | RecordType<any> | ObjectTypeFunction;
+export declare type AnyType = null | undefined | AnyNonValueType;
+export declare type AnyNonValueType = ModelClass<AnyModel> | StringConstructor | NumberConstructor | BooleanConstructor | AnyStandardType;
+export declare type TypeToData<S> = S extends ObjectTypeFunction ? ObjectType<ReturnType<S>>["$$data"] extends infer R ? R : never : S extends {
+    $$data: infer D;
+} ? D : S extends ModelClass<infer M> ? M : S extends StringConstructor ? string : S extends NumberConstructor ? number : S extends BooleanConstructor ? boolean : S extends null ? null : S extends undefined ? undefined : never;
+/** @ignore */
+export declare type TypeToDataOpt<S> = S extends {
+    $$data: infer D;
+} ? D & undefined : never;
+export {};

package/src/dist/types/tProp.d.ts

@@ -0,0 +1,92 @@
+import { MaybeOptionalModelProp, OptionalModelProp } from "../modelShared/prop";
+import type { AnyType, TypeToData } from "./schemas";
+/**
+ * Defines a string model property with a default value.
+ * Equivalent to `tProp(types.string, defaultValue)`.
+ *
+ * Example:
+ * ```ts
+ * x: tProp("foo") // an optional string that will take the value `"foo"` when undefined.
+ * ```
+ *
+ * @param defaultValue Default value.
+ * @returns
+ */
+export declare function tProp(defaultValue: string): OptionalModelProp<string>;
+/**
+ * Defines a number model property with a default value.
+ * Equivalent to `tProp(types.number, defaultValue)`.
+ *
+ * Example:
+ * ```ts
+ * x: tProp(42) // an optional number that will take the value `42` when undefined.
+ * ```
+ *
+ * @param defaultValue Default value.
+ * @returns
+ */
+export declare function tProp(defaultValue: number): OptionalModelProp<number>;
+/**
+ * Defines a boolean model property with a default value.
+ * Equivalent to `tProp(types.boolean, defaultValue)`.
+ *
+ * Example:
+ * ```ts
+ * x: tProp(true) // an optional boolean that will take the value `true` when undefined.
+ * ```
+ *
+ * @param defaultValue Default value.
+ * @param options Model property options.
+ * @returns
+ */
+export declare function tProp(defaultValue: boolean): OptionalModelProp<boolean>;
+/**
+ * Defines a model property, with an optional function to generate a default value
+ * if the input snapshot / model creation data is `null` or `undefined` and with an associated type checker.
+ *
+ * Example:
+ * ```ts
+ * x: tProp(types.number, () => 10) // an optional number, with a default value of 10
+ * x: tProp(types.array(types.number), () => []) // an optional number array, with a default empty array
+ * ```
+ *
+ * @typeparam TType Type checker type.
+ *
+ * @param type Type checker.
+ * @param defaultFn Default value generator function.
+ * @returns
+ */
+export declare function tProp<TType extends AnyType>(type: TType, defaultFn: () => TypeToData<TType>): OptionalModelProp<TypeToData<TType>>;
+/**
+ * Defines a model property, with an optional default value
+ * if the input snapshot / model creation data is `null` or `undefined` and with an associated type checker.
+ * You should only use this with primitive values and never with object values
+ * (array, model, object, etc).
+ *
+ * Example:
+ * ```ts
+ * x: tProp(types.number, 10) // an optional number, with a default value of 10
+ * ```
+ *
+ * @typeparam TType Type checker type.
+ *
+ * @param type Type checker.
+ * @param defaultValue Default value generator function.
+ * @returns
+ */
+export declare function tProp<TType extends AnyType>(type: TType, defaultValue: TypeToData<TType>): OptionalModelProp<TypeToData<TType>>;
+/**
+ * Defines a model property with no default value and an associated type checker.
+ *
+ * Example:
+ * ```ts
+ * x: tProp(types.number) // a required number
+ * x: tProp(types.maybe(types.number)) // an optional number, which defaults to undefined
+ * ```
+ *
+ * @typeparam TType Type checker type.
+ *
+ * @param type Type checker.
+ * @returns
+ */
+export declare function tProp<TType extends AnyType>(type: TType): MaybeOptionalModelProp<TypeToData<TType>>;

package/src/dist/types/typeCheck.d.ts

@@ -0,0 +1,11 @@
+import type { AnyType, TypeToData } from "./schemas";
+import type { TypeCheckError } from "./TypeCheckError";
+/**
+ * Checks if a value conforms to a given type.
+ *
+ * @typeparam T Type.
+ * @param type Type to check for.
+ * @param value Value to check.
+ * @returns A TypeError if the check fails or null if no error.
+ */
+export declare function typeCheck<T extends AnyType>(type: T, value: TypeToData<T>): TypeCheckError | null;