mobx-keystone 0.68.0 → 0.68.1-alpha

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

@@ -0,0 +1,51 @@
+import { ArrayTypeInfo, typesArray } from "./arrayBased/array";
+import { TupleTypeInfo, typesTuple } from "./arrayBased/tuple";
+import { ArraySetTypeInfo, typesArraySet } from "./objectBased/arraySet";
+import { typesDataModelData } from "./objectBased/dataModelData";
+import { ModelTypeInfo, ModelTypeInfoProps, typesModel } from "./objectBased/model";
+import { FrozenTypeInfo, ObjectTypeInfo, ObjectTypeInfoProps, typesFrozen, typesObject } from "./objectBased/object";
+import { ObjectMapTypeInfo, typesObjectMap } from "./objectBased/objectMap";
+import { RecordTypeInfo, typesRecord } from "./objectBased/record";
+import { RefTypeInfo, typesRef } from "./objectBased/ref";
+import { typesEnum } from "./primitiveBased/enum";
+import { BooleanTypeInfo, LiteralTypeInfo, NumberTypeInfo, StringTypeInfo, typesLiteral } from "./primitiveBased/primitives";
+import type { AnyType } from "./schemas";
+import { typesMaybe, typesMaybeNull } from "./utility/maybe";
+import { OrTypeInfo, typesOr } from "./utility/or";
+import { RefinementTypeInfo, typesRefinement } from "./utility/refinement";
+import { typesUnchecked, UncheckedTypeInfo } from "./utility/unchecked";
+export { getTypeInfo } from "./getTypeInfo";
+export { TypeInfo } from "./TypeChecker";
+export type { ObjectTypeInfoProps, ModelTypeInfoProps };
+export { BooleanTypeInfo, LiteralTypeInfo, NumberTypeInfo, StringTypeInfo, FrozenTypeInfo, ObjectMapTypeInfo, RefinementTypeInfo, RecordTypeInfo, RefTypeInfo, UncheckedTypeInfo, ObjectTypeInfo, ArraySetTypeInfo, ArrayTypeInfo, ModelTypeInfo, OrTypeInfo, TupleTypeInfo, };
+export declare const types: {
+    literal: typeof typesLiteral;
+    undefined: import("./schemas").IdentityType<undefined>;
+    null: import("./schemas").IdentityType<null>;
+    boolean: import("./schemas").IdentityType<boolean>;
+    number: import("./schemas").IdentityType<number>;
+    string: import("./schemas").IdentityType<string>;
+    or: typeof typesOr;
+    maybe: typeof typesMaybe;
+    maybeNull: typeof typesMaybeNull;
+    array: typeof typesArray;
+    record: typeof typesRecord;
+    unchecked: typeof typesUnchecked;
+    model: typeof typesModel;
+    dataModelData: typeof typesDataModelData;
+    object: typeof typesObject;
+    ref: typeof typesRef;
+    frozen: typeof typesFrozen;
+    enum: typeof typesEnum;
+    refinement: typeof typesRefinement;
+    integer: import("./schemas").IdentityType<number>;
+    nonEmptyString: import("./schemas").IdentityType<string>;
+    objectMap: typeof typesObjectMap;
+    arraySet: typeof typesArraySet;
+    tuple: typeof typesTuple;
+    mapArray<T extends AnyType>(valueType: T): import("./schemas").ArrayType<import("./schemas").ArrayType<[import("./schemas").IdentityType<string>, T]>[]>;
+    setArray<T_1 extends AnyType>(valueType: T_1): import("./schemas").ArrayType<T_1[]>;
+    mapObject<T_2 extends AnyType>(valueType: T_2): import("./schemas").RecordType<T_2>;
+    dateString: import("./schemas").IdentityType<string>;
+    dateTimestamp: import("./schemas").IdentityType<number>;
+};

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

@@ -0,0 +1,29 @@
+import type { AnyType, IdentityType } from "../schemas";
+/**
+ * A type that represents either a type or undefined.
+ * Syntactic sugar for `types.or(baseType, types.undefined)`
+ *
+ * Example:
+ * ```ts
+ * const numberOrUndefinedType = types.maybe(types.number)
+ * ```
+ *
+ * @typeparam T Type.
+ * @param baseType Type.
+ * @returns
+ */
+export declare function typesMaybe<T extends AnyType>(baseType: T): T | IdentityType<undefined>;
+/**
+ * A type that represents either a type or null.
+ * Syntactic sugar for `types.or(baseType, types.null)`
+ *
+ *  * Example:
+ * ```ts
+ * const numberOrNullType = types.maybeNull(types.number)
+ * ```
+ *
+ * @typeparam T Type.
+ * @param type Type.
+ * @returns
+ */
+export declare function typesMaybeNull<T extends AnyType>(type: T): T | IdentityType<null>;

package/src/dist/types/utility/or.d.ts

@@ -0,0 +1,35 @@
+import type { AnyStandardType, AnyType } from "../schemas";
+import { TypeInfo } from "../TypeChecker";
+/**
+ * A type that represents the union of several other types (a | b | c | ...).
+ * Accepts a dispatcher that, given a snapshot, returns the type
+ * that snapshot is.
+ *
+ * @typeparam T Type.
+ * @param dispatcher Function that given a snapshot returns the type.
+ * @param orTypes Possible types.
+ * @returns
+ */
+export declare function typesOr<T extends AnyType[]>(dispatcher: (sn: any) => T[number], ...orTypes: T): T[number];
+/**
+ * A type that represents the union of several other types (a | b | c | ...).
+ *
+ * Example:
+ * ```ts
+ * const booleanOrNumberType = types.or(types.boolean, types.number)
+ * ```
+ *
+ * @typeparam T Type.
+ * @param orTypes Possible types.
+ * @returns
+ */
+export declare function typesOr<T extends AnyType[]>(...orTypes: T): T[number];
+/**
+ * `types.or` type info.
+ */
+export declare class OrTypeInfo extends TypeInfo {
+    readonly orTypes: ReadonlyArray<AnyStandardType>;
+    private _orTypeInfos;
+    get orTypeInfos(): ReadonlyArray<TypeInfo>;
+    constructor(thisType: AnyStandardType, orTypes: ReadonlyArray<AnyStandardType>);
+}

package/src/dist/types/utility/refinement.d.ts

@@ -0,0 +1,45 @@
+import type { AnyStandardType, AnyType, TypeToData } from "../schemas";
+import { TypeInfo } from "../TypeChecker";
+import { TypeCheckError } from "../TypeCheckError";
+/**
+ * A refinement over a given type. This allows you to do extra checks
+ * over models, ensure numbers are integers, etc.
+ *
+ * Example:
+ * ```ts
+ * const integerType = types.refinement(types.number, (n) => {
+ *   return Number.isInteger(n)
+ * }, "integer")
+ *
+ * const sumModelType = types.refinement(types.model(Sum), (sum) => {
+ *   // imagine that for some reason sum includes a number 'a', a number 'b'
+ *   // and the result
+ *
+ *   const rightResult = sum.a + sum.b === sum.result
+ *
+ *   // simple mode that will just return that the whole model is incorrect
+ *   return rightResult
+ *
+ *   // this will return that the result field is wrong
+ *   return rightResult ? null : new TypeCheckError(["result"], "a+b", sum.result)
+ * })
+ * ```
+ *
+ * @typeparam T Base type.
+ * @param baseType Base type.
+ * @param checkFn Function that will receive the data (if it passes the base type
+ * check) and return null or false if there were no errors or either a TypeCheckError instance or
+ * true if there were.
+ * @returns
+ */
+export declare function typesRefinement<T extends AnyType>(baseType: T, checkFn: (data: TypeToData<T>) => TypeCheckError | null | boolean, typeName?: string): T;
+/**
+ * `types.refinement` type info.
+ */
+export declare class RefinementTypeInfo extends TypeInfo {
+    readonly baseType: AnyStandardType;
+    readonly checkFunction: (data: any) => TypeCheckError | null | boolean;
+    readonly typeName: string | undefined;
+    get baseTypeInfo(): TypeInfo;
+    constructor(thisType: AnyStandardType, baseType: AnyStandardType, checkFunction: (data: any) => TypeCheckError | null | boolean, typeName: string | undefined);
+}

package/src/dist/types/utility/unchecked.d.ts

@@ -0,0 +1,22 @@
+import type { IdentityType } from "../schemas";
+import { TypeInfo } from "../TypeChecker";
+/**
+ * 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>()
+ * ```
+ *
+ * @typeparam T Type of the value, or unkown if not given.
+ * @returns
+ */
+export declare function typesUnchecked<T = never>(): IdentityType<T>;
+/**
+ * `types.unchecked` type info.
+ */
+export declare class UncheckedTypeInfo extends TypeInfo {
+}

package/src/dist/utils/ModelPool.d.ts

@@ -0,0 +1,7 @@
+import type { AnyModel } from "../model/BaseModel";
+export declare class ModelPool {
+    private pool;
+    constructor(root: object);
+    findModelByTypeAndId(modelType: string, modelId: string | undefined): AnyModel | undefined;
+    findModelForSnapshot(sn: any): AnyModel | undefined;
+}

package/src/dist/utils/chainFns.d.ts

@@ -0,0 +1 @@
+export declare function chainFns<F extends Function>(...fns: (F | undefined)[]): F | undefined;

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

@@ -0,0 +1,6 @@
+/**
+ * A mobx-keystone error.
+ */
+export declare class MobxKeystoneError extends Error {
+    constructor(msg: string);
+}

package/src/dist/utils/mapUtils.d.ts

@@ -0,0 +1,2 @@
+export declare function getOrCreate<K, V, C = V>(map: Map<K, V>, key: K, create: () => C): V;
+export declare function getOrCreate<K extends object, V, C = V>(map: WeakMap<K, V>, key: K, create: () => C): V;

package/src/dist/utils/tag.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Creates a tag data accessor for a target object of a certain type.
+ * Tag data will be lazy created on access and reused for the same target object.
+ *
+ * @typeparam Target Target type.
+ * @typeparam TagData Tag data type.
+ * @param tagDataConstructor Function that will be called the first time the tag
+ * for a given object is requested.
+ * @returns The tag data associated with the target object.
+ */
+export declare function tag<Target extends object, TagData>(tagDataConstructor: (target: Target) => TagData): {
+    for(target: Target): TagData;
+};

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

@@ -0,0 +1,39 @@
+/**
+ * @ignore
+ *
+ * A primitive value.
+ */
+export declare type PrimitiveValue = undefined | null | boolean | number | string | bigint;
+/**
+ * @ignore
+ *
+ * A JSON-compatible primitive value.
+ */
+export declare type JSONPrimitiveValue = null | boolean | number | string;
+/**
+ * @ignore
+ *
+ * Checks if a value is optional (undefined or any).
+ *
+ * Examples:
+ * - string = false
+ * - undefined = true
+ * - string | undefined = true
+ * - string & undefined = false, but we don't care
+ * - any = true
+ * - unknown = false, but we don't care
+ * - null = false
+ * - string | null = false
+ * - string & null = false
+ */
+export declare type IsOptionalValue<C, TV, FV> = IsNeverType<Extract<C, undefined>, FV, TV>;
+/**
+ * @ignore
+ */
+export declare type IsNeverType<T, IfNever, IfNotNever> = [T] extends [never] ? IfNever : IfNotNever;
+/**
+ * @ignore
+ */
+export declare type Flatten<T> = T extends Record<any, any> ? {
+    [P in keyof T]: T[P];
+} : T;

package/src/dist/wrappers/ArraySet.d.ts

@@ -0,0 +1,29 @@
+declare const ArraySet_base: import("../model/Model")._Model<unknown, {
+    $modelId: import("../modelShared/prop").ModelIdProp;
+    items: import("../modelShared/prop").OptionalModelProp<any[]>;
+}, never, never>;
+/**
+ * A set that is backed by an array.
+ * Use `arraySet` to create it.
+ */
+export declare class ArraySet<V> extends ArraySet_base implements Set<V> {
+    add(value: V): this;
+    clear(): void;
+    delete(value: V): boolean;
+    forEach(callbackfn: (value: V, value2: V, set: Set<V>) => void, thisArg?: any): void;
+    has(value: V): boolean;
+    get size(): number;
+    keys(): IterableIterator<V>;
+    values(): IterableIterator<V>;
+    entries(): IterableIterator<[V, V]>;
+    [Symbol.iterator](): IterableIterator<V>;
+    get [Symbol.toStringTag](): string;
+}
+/**
+ * Creates a new ArraySet model instance.
+ *
+ * @typeparam V Value type.
+ * @param [entries] Optional initial values.
+ */
+export declare function arraySet<V>(values?: ReadonlyArray<V> | null): ArraySet<V>;
+export {};

package/src/dist/wrappers/ObjectMap.d.ts

@@ -0,0 +1,32 @@
+declare const ObjectMap_base: import("../model/Model")._Model<unknown, {
+    $modelId: import("../modelShared/prop").ModelIdProp;
+    items: import("../modelShared/prop").OptionalModelProp<{
+        [k: string]: any;
+    }>;
+}, never, never>;
+/**
+ * A map that is backed by an object-like map.
+ * Use `objectMap` to create it.
+ */
+export declare class ObjectMap<V> extends ObjectMap_base implements Map<string, V> {
+    clear(): void;
+    delete(key: string): boolean;
+    forEach(callbackfn: (value: V, key: string, map: Map<string, V>) => void, thisArg?: any): void;
+    get(key: string): V | undefined;
+    has(key: string): boolean;
+    set(key: string, value: V): this;
+    get size(): number;
+    keys(): IterableIterator<string>;
+    values(): IterableIterator<V>;
+    entries(): IterableIterator<[string, V]>;
+    [Symbol.iterator](): IterableIterator<[string, V]>;
+    get [Symbol.toStringTag](): string;
+}
+/**
+ * Creates a new ObjectMap model instance.
+ *
+ * @typeparam V Value type.
+ * @param [entries] Optional initial values.
+ */
+export declare function objectMap<V>(entries?: ReadonlyArray<readonly [string, V]> | null): ObjectMap<V>;
+export {};

package/src/dist/wrappers/asMap.d.ts

@@ -0,0 +1,29 @@
+import { ObservableMap } from "mobx";
+/**
+ * Wraps an observable object or a tuple array to offer a map like interface.
+ *
+ * @param array Array.
+ */
+export declare function asMap<K, V>(array: Array<[K, V]>): ObservableMap<K, V> & {
+    dataObject: Array<[K, V]>;
+};
+/**
+ * Wraps an observable object or a tuple array to offer a map like interface.
+ *
+ * @param object Object.
+ */
+export declare function asMap<T>(object: Record<string, T>): ObservableMap<string, T> & {
+    dataObject: Record<string, T>;
+};
+/**
+ * Converts a map to an object. If the map is a collection wrapper it will return the backed object.
+ *
+ * @param map
+ */
+export declare function mapToObject<T>(map: Map<string, T>): Record<string, T>;
+/**
+ * Converts a map to an array. If the map is a collection wrapper it will return the backed array.
+ *
+ * @param map
+ */
+export declare function mapToArray<K, V>(map: Map<K, V>): Array<[K, V]>;

package/src/dist/wrappers/asSet.d.ts

@@ -0,0 +1,15 @@
+import { ObservableSet } from "mobx";
+/**
+ * Wraps an observable array to offer a set like interface.
+ *
+ * @param array
+ */
+export declare function asSet<T>(array: Array<T>): ObservableSet<T> & {
+    dataObject: typeof array;
+};
+/**
+ * Converts a set to an array. If the set is a collection wrapper it will return the backed array.
+ *
+ * @param set
+ */
+export declare function setToArray<T>(set: Set<T>): Array<T>;

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

@@ -0,0 +1,4 @@
+export * from "./ArraySet";
+export * from "./asMap";
+export * from "./asSet";
+export * from "./ObjectMap";