mobx-state-tree 3.12.2 → 3.15.0

package/dist/types/primitives.d.ts

@@ -1,81 +1,81 @@
-import { ISimpleType, IType } from "../internal";
-/**
- * `types.string` - Creates a type that can only contain a string value.
- * This type is used for string values by default
- *
- * Example:
- * ```ts
- * const Person = types.model({
- *   firstName: types.string,
- *   lastName: "Doe"
- * })
- * ```
- */
-export declare const string: ISimpleType<string>;
-/**
- * `types.number` - Creates a type that can only contain a numeric value.
- * This type is used for numeric values by default
- *
- * Example:
- * ```ts
- * const Vector = types.model({
- *   x: types.number,
- *   y: 1.5
- * })
- * ```
- */
-export declare const number: ISimpleType<number>;
-/**
- * `types.integer` - Creates a type that can only contain an integer value.
- * This type is used for integer values by default
- *
- * Example:
- * ```ts
- * const Size = types.model({
- *   width: types.integer,
- *   height: 10
- * })
- * ```
- */
-export declare const integer: ISimpleType<number>;
-/**
- * `types.boolean` - Creates a type that can only contain a boolean value.
- * This type is used for boolean values by default
- *
- * Example:
- * ```ts
- * const Thing = types.model({
- *   isCool: types.boolean,
- *   isAwesome: false
- * })
- * ```
- */
-export declare const boolean: ISimpleType<boolean>;
-/**
- * `types.null` - The type of the value `null`
- */
-export declare const nullType: ISimpleType<null>;
-/**
- * `types.undefined` - The type of the value `undefined`
- */
-export declare const undefinedType: ISimpleType<undefined>;
-/**
- * `types.Date` - Creates a type that can only contain a javascript Date value.
- *
- * Example:
- * ```ts
- * const LogLine = types.model({
- *   timestamp: types.Date,
- * })
- *
- * LogLine.create({ timestamp: new Date() })
- * ```
- */
-export declare const DatePrimitive: IType<number | Date, number, Date>;
-/**
- * Returns if a given value represents a primitive type.
- *
- * @param type
- * @returns
- */
-export declare function isPrimitiveType<IT extends ISimpleType<string> | ISimpleType<number> | ISimpleType<boolean> | typeof DatePrimitive>(type: IT): type is IT;
+import { ISimpleType, IType } from "../internal";
+/**
+ * `types.string` - Creates a type that can only contain a string value.
+ * This type is used for string values by default
+ *
+ * Example:
+ * ```ts
+ * const Person = types.model({
+ *   firstName: types.string,
+ *   lastName: "Doe"
+ * })
+ * ```
+ */
+export declare const string: ISimpleType<string>;
+/**
+ * `types.number` - Creates a type that can only contain a numeric value.
+ * This type is used for numeric values by default
+ *
+ * Example:
+ * ```ts
+ * const Vector = types.model({
+ *   x: types.number,
+ *   y: 1.5
+ * })
+ * ```
+ */
+export declare const number: ISimpleType<number>;
+/**
+ * `types.integer` - Creates a type that can only contain an integer value.
+ * This type is used for integer values by default
+ *
+ * Example:
+ * ```ts
+ * const Size = types.model({
+ *   width: types.integer,
+ *   height: 10
+ * })
+ * ```
+ */
+export declare const integer: ISimpleType<number>;
+/**
+ * `types.boolean` - Creates a type that can only contain a boolean value.
+ * This type is used for boolean values by default
+ *
+ * Example:
+ * ```ts
+ * const Thing = types.model({
+ *   isCool: types.boolean,
+ *   isAwesome: false
+ * })
+ * ```
+ */
+export declare const boolean: ISimpleType<boolean>;
+/**
+ * `types.null` - The type of the value `null`
+ */
+export declare const nullType: ISimpleType<null>;
+/**
+ * `types.undefined` - The type of the value `undefined`
+ */
+export declare const undefinedType: ISimpleType<undefined>;
+/**
+ * `types.Date` - Creates a type that can only contain a javascript Date value.
+ *
+ * Example:
+ * ```ts
+ * const LogLine = types.model({
+ *   timestamp: types.Date,
+ * })
+ *
+ * LogLine.create({ timestamp: new Date() })
+ * ```
+ */
+export declare const DatePrimitive: IType<number | Date, number, Date>;
+/**
+ * Returns if a given value represents a primitive type.
+ *
+ * @param type
+ * @returns
+ */
+export declare function isPrimitiveType<IT extends ISimpleType<string> | ISimpleType<number> | ISimpleType<boolean> | typeof DatePrimitive>(type: IT): type is IT;

package/dist/types/utility-types/custom.d.ts

@@ -1,60 +1,60 @@
-import { IType } from "../../internal";
-export interface CustomTypeOptions<S, T> {
-    /** Friendly name */
-    name: string;
-    /** given a serialized value, how to turn it into the target type */
-    fromSnapshot(snapshot: S): T;
-    /** return the serialization of the current value */
-    toSnapshot(value: T): S;
-    /** if true, this is a converted value, if false, it's a snapshot */
-    isTargetType(value: T | S): boolean;
-    /** a non empty string is assumed to be a validation error */
-    getValidationMessage(snapshot: S): string;
-}
-/**
- * `types.custom` - Creates a custom type. Custom types can be used for arbitrary immutable values, that have a serializable representation. For example, to create your own Date representation, Decimal type etc.
- *
- * The signature of the options is:
- * ```ts
- * export interface CustomTypeOptions<S, T> {
- *     // Friendly name
- *     name: string
- *     // given a serialized value, how to turn it into the target type
- *     fromSnapshot(snapshot: S): T
- *     // return the serialization of the current value
- *     toSnapshot(value: T): S
- *     // if true, this is a converted value, if false, it's a snapshot
- *     isTargetType(value: T | S): value is T
- *     // a non empty string is assumed to be a validation error
- *     getValidationMessage?(snapshot: S): string
- * }
- * ```
- *
- * Example:
- * ```ts
- * const DecimalPrimitive = types.custom<string, Decimal>({
- *     name: "Decimal",
- *     fromSnapshot(value: string) {
- *         return new Decimal(value)
- *     },
- *     toSnapshot(value: Decimal) {
- *         return value.toString()
- *     },
- *     isTargetType(value: string | Decimal): boolean {
- *         return value instanceof Decimal
- *     },
- *     getValidationMessage(value: string): string {
- *         if (/^-?\d+\.\d+$/.test(value)) return "" // OK
- *         return `'${value}' doesn't look like a valid decimal number`
- *     }
- * })
- *
- * const Wallet = types.model({
- *     balance: DecimalPrimitive
- * })
- * ```
- *
- * @param options
- * @returns
- */
-export declare function custom<S, T>(options: CustomTypeOptions<S, T>): IType<S | T, S, T>;
+import { IType } from "../../internal";
+export interface CustomTypeOptions<S, T> {
+    /** Friendly name */
+    name: string;
+    /** given a serialized value, how to turn it into the target type */
+    fromSnapshot(snapshot: S): T;
+    /** return the serialization of the current value */
+    toSnapshot(value: T): S;
+    /** if true, this is a converted value, if false, it's a snapshot */
+    isTargetType(value: T | S): boolean;
+    /** a non empty string is assumed to be a validation error */
+    getValidationMessage(snapshot: S): string;
+}
+/**
+ * `types.custom` - Creates a custom type. Custom types can be used for arbitrary immutable values, that have a serializable representation. For example, to create your own Date representation, Decimal type etc.
+ *
+ * The signature of the options is:
+ * ```ts
+ * export interface CustomTypeOptions<S, T> {
+ *     // Friendly name
+ *     name: string
+ *     // given a serialized value, how to turn it into the target type
+ *     fromSnapshot(snapshot: S): T
+ *     // return the serialization of the current value
+ *     toSnapshot(value: T): S
+ *     // if true, this is a converted value, if false, it's a snapshot
+ *     isTargetType(value: T | S): value is T
+ *     // a non empty string is assumed to be a validation error
+ *     getValidationMessage?(snapshot: S): string
+ * }
+ * ```
+ *
+ * Example:
+ * ```ts
+ * const DecimalPrimitive = types.custom<string, Decimal>({
+ *     name: "Decimal",
+ *     fromSnapshot(value: string) {
+ *         return new Decimal(value)
+ *     },
+ *     toSnapshot(value: Decimal) {
+ *         return value.toString()
+ *     },
+ *     isTargetType(value: string | Decimal): boolean {
+ *         return value instanceof Decimal
+ *     },
+ *     getValidationMessage(value: string): string {
+ *         if (/^-?\d+\.\d+$/.test(value)) return "" // OK
+ *         return `'${value}' doesn't look like a valid decimal number`
+ *     }
+ * })
+ *
+ * const Wallet = types.model({
+ *     balance: DecimalPrimitive
+ * })
+ * ```
+ *
+ * @param options
+ * @returns
+ */
+export declare function custom<S, T>(options: CustomTypeOptions<S, T>): IType<S | T, S, T>;

package/dist/types/utility-types/enumeration.d.ts

@@ -1,5 +1,5 @@
-import { ISimpleType } from "../../internal";
-/** @hidden */
-export declare type UnionStringArray<T extends string[]> = T[number];
-export declare function enumeration<T extends string>(options: T[]): ISimpleType<UnionStringArray<T[]>>;
-export declare function enumeration<T extends string>(name: string, options: T[]): ISimpleType<UnionStringArray<T[]>>;
+import { ISimpleType } from "../../internal";
+/** @hidden */
+export declare type UnionStringArray<T extends string[]> = T[number];
+export declare function enumeration<T extends string>(options: T[]): ISimpleType<UnionStringArray<T[]>>;
+export declare function enumeration<T extends string>(name: string, options: T[]): ISimpleType<UnionStringArray<T[]>>;

package/dist/types/utility-types/frozen.d.ts

@@ -1,11 +1,11 @@
-import { IType } from "../../internal";
-export declare function frozen<C>(subType: IType<C, any, any>): IType<C, C, C>;
-export declare function frozen<T>(defaultValue: T): IType<T | undefined | null, T, T>;
-export declare function frozen<T = any>(): IType<T, T, T>;
-/**
- * Returns if a given value represents a frozen type.
- *
- * @param type
- * @returns
- */
-export declare function isFrozenType<IT extends IType<T | any, T, T>, T = any>(type: IT): type is IT;
+import { IType } from "../../internal";
+export declare function frozen<C>(subType: IType<C, any, any>): IType<C, C, C>;
+export declare function frozen<T>(defaultValue: T): IType<T | undefined | null, T, T>;
+export declare function frozen<T = any>(): IType<T, T, T>;
+/**
+ * Returns if a given value represents a frozen type.
+ *
+ * @param type
+ * @returns
+ */
+export declare function isFrozenType<IT extends IType<T | any, T, T>, T = any>(type: IT): type is IT;

package/dist/types/utility-types/identifier.d.ts

@@ -1,44 +1,44 @@
-import { ISimpleType } from "../../internal";
-/**
- * `types.identifier` - Identifiers are used to make references, lifecycle events and reconciling works.
- * Inside a state tree, for each type can exist only one instance for each given identifier.
- * For example there couldn't be 2 instances of user with id 1. If you need more, consider using references.
- * Identifier can be used only as type property of a model.
- * This type accepts as parameter the value type of the identifier field that can be either string or number.
- *
- * Example:
- * ```ts
- *  const Todo = types.model("Todo", {
- *      id: types.identifier,
- *      title: types.string
- *  })
- * ```
- *
- * @returns
- */
-export declare const identifier: ISimpleType<string>;
-/**
- * `types.identifierNumber` - Similar to `types.identifier`. This one will serialize from / to a number when applying snapshots
- *
- * Example:
- * ```ts
- *  const Todo = types.model("Todo", {
- *      id: types.identifierNumber,
- *      title: types.string
- *  })
- * ```
- *
- * @returns
- */
-export declare const identifierNumber: ISimpleType<number>;
-/**
- * Returns if a given value represents an identifier type.
- *
- * @param type
- * @returns
- */
-export declare function isIdentifierType<IT extends typeof identifier | typeof identifierNumber>(type: IT): type is IT;
-/**
- * Valid types for identifiers.
- */
-export declare type ReferenceIdentifier = string | number;
+import { ISimpleType } from "../../internal";
+/**
+ * `types.identifier` - Identifiers are used to make references, lifecycle events and reconciling works.
+ * Inside a state tree, for each type can exist only one instance for each given identifier.
+ * For example there couldn't be 2 instances of user with id 1. If you need more, consider using references.
+ * Identifier can be used only as type property of a model.
+ * This type accepts as parameter the value type of the identifier field that can be either string or number.
+ *
+ * Example:
+ * ```ts
+ *  const Todo = types.model("Todo", {
+ *      id: types.identifier,
+ *      title: types.string
+ *  })
+ * ```
+ *
+ * @returns
+ */
+export declare const identifier: ISimpleType<string>;
+/**
+ * `types.identifierNumber` - Similar to `types.identifier`. This one will serialize from / to a number when applying snapshots
+ *
+ * Example:
+ * ```ts
+ *  const Todo = types.model("Todo", {
+ *      id: types.identifierNumber,
+ *      title: types.string
+ *  })
+ * ```
+ *
+ * @returns
+ */
+export declare const identifierNumber: ISimpleType<number>;
+/**
+ * Returns if a given value represents an identifier type.
+ *
+ * @param type
+ * @returns
+ */
+export declare function isIdentifierType<IT extends typeof identifier | typeof identifierNumber>(type: IT): type is IT;
+/**
+ * Valid types for identifiers.
+ */
+export declare type ReferenceIdentifier = string | number;

package/dist/types/utility-types/late.d.ts

@@ -1,10 +1,10 @@
-import { IAnyType } from "../../internal";
-export declare function late<T extends IAnyType>(type: () => T): T;
-export declare function late<T extends IAnyType>(name: string, type: () => T): T;
-/**
- * Returns if a given value represents a late type.
- *
- * @param type
- * @returns
- */
-export declare function isLateType<IT extends IAnyType>(type: IT): type is IT;
+import { IAnyType } from "../../internal";
+export declare function late<T extends IAnyType>(type: () => T): T;
+export declare function late<T extends IAnyType>(name: string, type: () => T): T;
+/**
+ * Returns if a given value represents a late type.
+ *
+ * @param type
+ * @returns
+ */
+export declare function isLateType<IT extends IAnyType>(type: IT): type is IT;

package/dist/types/utility-types/literal.d.ts

@@ -1,25 +1,25 @@
-import { ISimpleType, Primitives } from "../../internal";
-/**
- * `types.literal` - The literal type will return a type that will match only the exact given type.
- * The given value must be a primitive, in order to be serialized to a snapshot correctly.
- * You can use literal to match exact strings for example the exact male or female string.
- *
- * Example:
- * ```ts
- * const Person = types.model({
- *     name: types.string,
- *     gender: types.union(types.literal('male'), types.literal('female'))
- * })
- * ```
- *
- * @param value The value to use in the strict equal check
- * @returns
- */
-export declare function literal<S extends Primitives>(value: S): ISimpleType<S>;
-/**
- * Returns if a given value represents a literal type.
- *
- * @param type
- * @returns
- */
-export declare function isLiteralType<IT extends ISimpleType<any>>(type: IT): type is IT;
+import { ISimpleType, Primitives } from "../../internal";
+/**
+ * `types.literal` - The literal type will return a type that will match only the exact given type.
+ * The given value must be a primitive, in order to be serialized to a snapshot correctly.
+ * You can use literal to match exact strings for example the exact male or female string.
+ *
+ * Example:
+ * ```ts
+ * const Person = types.model({
+ *     name: types.string,
+ *     gender: types.union(types.literal('male'), types.literal('female'))
+ * })
+ * ```
+ *
+ * @param value The value to use in the strict equal check
+ * @returns
+ */
+export declare function literal<S extends Primitives>(value: S): ISimpleType<S>;
+/**
+ * Returns if a given value represents a literal type.
+ *
+ * @param type
+ * @returns
+ */
+export declare function isLiteralType<IT extends ISimpleType<any>>(type: IT): type is IT;

package/dist/types/utility-types/maybe.d.ts

@@ -1,26 +1,26 @@
-import { IType, IAnyType, ExtractC, ExtractS, ExtractTWithoutSTN } from "../../internal";
-/** @hidden */
-export interface IMaybeIType<IT extends IAnyType, C, O> extends IType<ExtractC<IT> | C, ExtractS<IT> | O, ExtractTWithoutSTN<IT> | O> {
-}
-/** @hidden */
-export interface IMaybe<IT extends IAnyType> extends IMaybeIType<IT, undefined, undefined> {
-}
-/** @hidden */
-export interface IMaybeNull<IT extends IAnyType> extends IMaybeIType<IT, null | undefined, null> {
-}
-/**
- * `types.maybe` - Maybe will make a type nullable, and also optional.
- * The value `undefined` will be used to represent nullability.
- *
- * @param type
- * @returns
- */
-export declare function maybe<IT extends IAnyType>(type: IT): IMaybe<IT>;
-/**
- * `types.maybeNull` - Maybe will make a type nullable, and also optional.
- * The value `null` will be used to represent no value.
- *
- * @param type
- * @returns
- */
-export declare function maybeNull<IT extends IAnyType>(type: IT): IMaybeNull<IT>;
+import { IType, IAnyType } from "../../internal";
+/** @hidden */
+export interface IMaybeIType<IT extends IAnyType, C, O> extends IType<IT["CreationType"] | C, IT["SnapshotType"] | O, IT["TypeWithoutSTN"] | O> {
+}
+/** @hidden */
+export interface IMaybe<IT extends IAnyType> extends IMaybeIType<IT, undefined, undefined> {
+}
+/** @hidden */
+export interface IMaybeNull<IT extends IAnyType> extends IMaybeIType<IT, null | undefined, null> {
+}
+/**
+ * `types.maybe` - Maybe will make a type nullable, and also optional.
+ * The value `undefined` will be used to represent nullability.
+ *
+ * @param type
+ * @returns
+ */
+export declare function maybe<IT extends IAnyType>(type: IT): IMaybe<IT>;
+/**
+ * `types.maybeNull` - Maybe will make a type nullable, and also optional.
+ * The value `null` will be used to represent no value.
+ *
+ * @param type
+ * @returns
+ */
+export declare function maybeNull<IT extends IAnyType>(type: IT): IMaybeNull<IT>;

package/dist/types/utility-types/optional.d.ts

@@ -1,20 +1,20 @@
-import { IType, IAnyType, ExtractS, ExtractC, ExtractCSTWithSTN, ExtractTWithoutSTN } from "../../internal";
-/** @hidden */
-export declare type ValidOptionalValue = string | boolean | number | null | undefined;
-/** @hidden */
-export declare type ValidOptionalValues = [ValidOptionalValue, ...ValidOptionalValue[]];
-/** @hidden */
-export declare type OptionalDefaultValueOrFunction<IT extends IAnyType> = ExtractC<IT> | ExtractS<IT> | (() => ExtractCSTWithSTN<IT>);
-/** @hidden */
-export interface IOptionalIType<IT extends IAnyType, OptionalVals extends ValidOptionalValues> extends IType<ExtractC<IT> | OptionalVals[number], ExtractS<IT>, ExtractTWithoutSTN<IT>> {
-}
-export declare function optional<IT extends IAnyType>(type: IT, defaultValueOrFunction: OptionalDefaultValueOrFunction<IT>): IOptionalIType<IT, [undefined]>;
-export declare function optional<IT extends IAnyType, OptionalVals extends ValidOptionalValues>(type: IT, defaultValueOrFunction: OptionalDefaultValueOrFunction<IT>, optionalValues: OptionalVals): IOptionalIType<IT, OptionalVals>;
-/**
- * Returns if a value represents an optional type.
- *
- * @template IT
- * @param type
- * @returns
- */
-export declare function isOptionalType<IT extends IAnyType>(type: IT): type is IT;
+import { IType, IAnyType, ExtractCSTWithSTN } from "../../internal";
+/** @hidden */
+export declare type ValidOptionalValue = string | boolean | number | null | undefined;
+/** @hidden */
+export declare type ValidOptionalValues = [ValidOptionalValue, ...ValidOptionalValue[]];
+/** @hidden */
+export declare type OptionalDefaultValueOrFunction<IT extends IAnyType> = IT["CreationType"] | IT["SnapshotType"] | (() => ExtractCSTWithSTN<IT>);
+/** @hidden */
+export interface IOptionalIType<IT extends IAnyType, OptionalVals extends ValidOptionalValues> extends IType<IT["CreationType"] | OptionalVals[number], IT["SnapshotType"], IT["TypeWithoutSTN"]> {
+}
+export declare function optional<IT extends IAnyType>(type: IT, defaultValueOrFunction: OptionalDefaultValueOrFunction<IT>): IOptionalIType<IT, [undefined]>;
+export declare function optional<IT extends IAnyType, OptionalVals extends ValidOptionalValues>(type: IT, defaultValueOrFunction: OptionalDefaultValueOrFunction<IT>, optionalValues: OptionalVals): IOptionalIType<IT, OptionalVals>;
+/**
+ * Returns if a value represents an optional type.
+ *
+ * @template IT
+ * @param type
+ * @returns
+ */
+export declare function isOptionalType<IT extends IAnyType>(type: IT): type is IT;