mobx-keystone 2.3.0 → 2.4.0

package/dist/types/serialization/builtinSerializers.d.ts

@@ -0,0 +1,49 @@
+import type { AnyDataModel } from "../dataModel/BaseDataModel";
+import type { JsonValue } from "./JsonValue";
+import type { ValueSerializer } from "./ValueSerializer";
+/**
+ * The built-in value serializers, appended in this order to every serializer's list (unless it is
+ * created with `builtins: false`). Pick some of them to build a list by hand, e.g.
+ * `createSerializer({ serializers: [builtinSerializers.date], builtins: false })`.
+ */
+export declare const builtinSerializers: Readonly<{
+    /**
+     * Models and frozen data that aren't references, as their snapshots (unmarked, since snapshots
+     * mark themselves with `$modelType` / `$frozen`), decoded with `fromSnapshot` into new
+     * instances. Tree arrays and plain objects that aren't references are walked like any other.
+     */
+    snapshot: ValueSerializer<object, any>;
+    /**
+     * Data model instances, as their registered name and their data (encoded, so data of the tree
+     * goes as a reference), decoded as a new instance over the decoded data.
+     */
+    dataModel: ValueSerializer<AnyDataModel, {
+        type: string;
+        data: JsonValue;
+    }>;
+    /**
+     * Dates, as `toISOString()` (an invalid date as `null`); decodes an ISO string, a timestamp or
+     * `null`.
+     */
+    date: ValueSerializer<Date, string | number | null>;
+    /**
+     * Maps (plain or observable), as an array of `[key, value]` entries; decoded as plain maps.
+     */
+    map: ValueSerializer<Map<unknown, unknown>, [JsonValue, JsonValue][]>;
+    /**
+     * Sets (plain or observable), as an array of their values; decoded as plain sets.
+     */
+    set: ValueSerializer<Set<unknown>, JsonValue[]>;
+    /**
+     * The numbers JSON can't hold: `"NaN"`, `"Infinity"`, `"-Infinity"`.
+     */
+    number: ValueSerializer<number, string>;
+    /**
+     * Bigints, as a decimal string, with no loss of precision.
+     */
+    bigint: ValueSerializer<bigint, string>;
+    /**
+     * `undefined` (as an array item, an argument or an object property, which keeps its key).
+     */
+    undefined: ValueSerializer<undefined, undefined>;
+}>;

package/dist/types/serialization/codec.d.ts

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

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

@@ -0,0 +1,8 @@
+export * from "./applyCall";
+export { builtinSerializers } from "./builtinSerializers";
+export * from "./Call";
+export { CallError, CallErrorCode, type CallErrorData, type CallErrorJson } from "./CallError";
+export * from "./JsonValue";
+export { type IdRefJson, idRefs, type PathRefJson, pathRefs, type ReferenceNodeInfo, type ReferenceSerializerOptions, } from "./references";
+export * from "./Serializer";
+export * from "./ValueSerializer";

package/dist/types/serialization/references.d.ts

@@ -0,0 +1,74 @@
+import type { AnyModel } from "../model/BaseModel";
+import type { PathElement } from "../parent/pathTypes";
+import type { ValueSerializer } from "./ValueSerializer";
+/**
+ * What a reference serializer's `when` option is told about a node.
+ */
+export interface ReferenceNodeInfo {
+    /**
+     * Whether the node is a model.
+     */
+    readonly isModel: boolean;
+    /**
+     * Whether the node is a value-type model (`Model({...}, { valueType: true })`).
+     */
+    readonly isValueType: boolean;
+}
+/**
+ * Options of the built-in reference serializers.
+ */
+export interface ReferenceSerializerOptions {
+    /**
+     * Decides, for every node the serializer could reference, whether it does. A node it declines
+     * falls through the list like any other value: a model ends up as its snapshot, a tree array
+     * or plain object is walked. The call's target ignores it: it is always a reference.
+     *
+     * Defaults to declining value-type models: `(node, { isValueType }) => !isValueType`.
+     */
+    when?(node: object, info: ReferenceNodeInfo): boolean;
+}
+/**
+ * A path reference, the payload of `{ "$mobxKeystone": "pathRef", "v": ... }`.
+ */
+export type PathRefJson = {
+    /**
+     * Path from the root to the node, through data nodes (as in patches).
+     */
+    path: PathElement[];
+    /**
+     * Id of the model reached by each step of the path (`null` for non-models).
+     * Optional when decoding: without it, ids aren't checked.
+     */
+    ids?: (string | null)[];
+};
+/**
+ * An id reference, the payload of `{ "$mobxKeystone": "idRef", "v": ... }`.
+ */
+export type IdRefJson = {
+    /**
+     * The model type (`$modelType`).
+     */
+    type: string;
+    /**
+     * The model id.
+     */
+    id: string;
+};
+/**
+ * References nodes of the tree by their path from the root, checking the ids of the models along
+ * it: `{ "$mobxKeystone": "pathRef", "v": { "path": ["cards", 2], "ids": [null, "c1"] } }`.
+ * It reaches any node, including tree arrays and plain objects.
+ *
+ * @param options Options.
+ * @returns The reference serializer.
+ */
+export declare function pathRefs(options?: ReferenceSerializerOptions): ValueSerializer<object, PathRefJson>;
+/**
+ * References models of the tree that have an id by their type and id:
+ * `{ "$mobxKeystone": "idRef", "v": { "type": "app/Card", "id": "c1" } }`. Ids are read and
+ * resolved as `getModelRefId` and `resolveId` do, and the type must match.
+ *
+ * @param options Options.
+ * @returns The reference serializer.
+ */
+export declare function idRefs(options?: ReferenceSerializerOptions): ValueSerializer<AnyModel, IdRefJson>;

package/dist/types/serialization/resolvedCall.d.ts

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

package/dist/types/snapshot/SnapshotOf.d.ts

@@ -1,8 +1,8 @@
-import { Frozen, frozenKey } from '../frozen/Frozen';
-import { AnyModel } from '../model/BaseModel';
-import { modelIdKey, modelTypeKey } from '../model/metadata';
-import { ModelFromSnapshot, ModelToSnapshot } from '../modelShared/BaseModelShared';
-import { ArraySet, ObjectMap } from '../wrappers';
+import type { Frozen, frozenKey } from "../frozen/Frozen";
+import type { AnyModel } from "../model/BaseModel";
+import type { modelIdKey, modelTypeKey } from "../model/metadata";
+import type { ModelFromSnapshot, ModelToSnapshot } from "../modelShared/BaseModelShared";
+import type { ArraySet, ObjectMap } from "../wrappers";
 export type FrozenData<D> = {
     [frozenKey]: true;
     data: D;

package/dist/types/snapshot/SnapshotProcessingError.d.ts

@@ -1,5 +1,5 @@
-import { Path } from '../parent/pathTypes';
-import { MobxKeystoneError } from '../utils';
+import type { Path } from "../parent/pathTypes";
+import { MobxKeystoneError } from "../utils";
 export interface SnapshotProcessingErrorData {
     message: string;
     path?: Path;

package/dist/types/snapshot/applySnapshot.d.ts

@@ -1,4 +1,4 @@
-import { SnapshotInOf, SnapshotOutOf } from './SnapshotOf';
+import type { SnapshotInOf, SnapshotOutOf } from "./SnapshotOf";
 /**
  * Applies a full snapshot over an object, reconciling it with the current contents of the object.
  * If it throws, the changes it made are rolled back (errors thrown by listeners do not roll them back).

package/dist/types/snapshot/cloneTreeValue.d.ts

@@ -1,4 +1,4 @@
-import { CloneOptions } from './clone';
+import type { CloneOptions } from "./clone";
 /**
  * Clones non-primitive tree-compatible values.
  * Intended to be used with `withSetter(cloneTreeValue)`.

package/dist/types/snapshot/fromSnapshot.d.ts

@@ -1,5 +1,5 @@
-import { AnyType, TypeToData, TypeToSnapshotIn, TypeToSnapshotOut } from '../types/schemas';
-import { SnapshotInOf, SnapshotOutOf } from './SnapshotOf';
+import type { AnyType, TypeToData, TypeToSnapshotIn, TypeToSnapshotOut } from "../types/schemas";
+import type { SnapshotInOf, SnapshotOutOf } from "./SnapshotOf";
 /**
  * From snapshot options.
  */

package/dist/types/snapshot/getSnapshot.d.ts

@@ -1,5 +1,5 @@
-import { AnyType, TypeToData, TypeToSnapshotOut } from '../types/schemas';
-import { SnapshotOutOf } from './SnapshotOf';
+import type { AnyType, TypeToData, TypeToSnapshotOut } from "../types/schemas";
+import type { SnapshotOutOf } from "./SnapshotOf";
 /**
  * Retrieves an immutable snapshot for a data structure.
  * Since returned snapshots are immutable they will respect shallow equality, this is,

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

@@ -1,8 +1,8 @@
-export * from './applySnapshot';
-export * from './clone';
-export * from './cloneTreeValue';
-export * from './fromSnapshot';
-export * from './getSnapshot';
-export * from './onSnapshot';
-export * from './SnapshotOf';
-export * from './SnapshotProcessingError';
+export * from "./applySnapshot";
+export * from "./clone";
+export * from "./cloneTreeValue";
+export * from "./fromSnapshot";
+export * from "./getSnapshot";
+export * from "./onSnapshot";
+export * from "./SnapshotOf";
+export * from "./SnapshotProcessingError";

package/dist/types/snapshot/onSnapshot.d.ts

@@ -1,4 +1,4 @@
-import { SnapshotOutOf } from './SnapshotOf';
+import type { SnapshotOutOf } from "./SnapshotOf";
 /**
  * Listener function for onSnapshot.
  */

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

@@ -1,3 +1,3 @@
-export * from './arrayActions';
-export * from './objectActions';
-export * from './standaloneActions';
+export * from "./arrayActions";
+export * from "./objectActions";
+export * from "./standaloneActions";

package/dist/types/standardActions/objectActions.d.ts

@@ -1,4 +1,4 @@
-import { AnyFunction } from '../utils/AnyFunction';
+import type { AnyFunction } from "../utils/AnyFunction";
 export declare const objectActions: {
     set: <T extends object, K extends keyof T>(target: T, key: K, value: T[K]) => void;
     assign: <T extends object>(target: T, partialObject: Partial<T>) => void;

package/dist/types/transforms/asMap.d.ts

@@ -1,4 +1,4 @@
-import { ModelPropTransform } from '../modelShared/prop';
+import type { ModelPropTransform } from "../modelShared/prop";
 /**
  * @deprecated Prefer the codec equivalent: `tProp(types.mapFromObject(valueType))`.
  * Use `tProp(types.skipCheck(types.mapFromObject(valueType)))` if you don't need runtime validation.

package/dist/types/transforms/asSet.d.ts

@@ -1,5 +1,5 @@
-import { ObservableSet } from 'mobx';
-import { ModelPropTransform } from '../modelShared/prop';
+import type { ObservableSet } from "mobx";
+import type { ModelPropTransform } from "../modelShared/prop";
 /**
  * @deprecated Prefer the codec equivalent: `tProp(types.setFromArray(valueType))`.
  * Use `tProp(types.skipCheck(types.setFromArray(valueType)))` if you don't need runtime validation.

package/dist/types/transforms/bigint.d.ts

@@ -1,4 +1,4 @@
-import { ModelPropTransform } from '../modelShared/prop';
+import type { ModelPropTransform } from "../modelShared/prop";
 /**
  * @deprecated Prefer the codec equivalent: `tProp(types.bigint)`.
  * Use `tProp(types.skipCheck(types.bigint))` if you don't need runtime validation.

package/dist/types/transforms/date.d.ts

@@ -1,4 +1,4 @@
-import { ModelPropTransform } from '../modelShared/prop';
+import type { ModelPropTransform } from "../modelShared/prop";
 /**
  * @deprecated Prefer the codec equivalent: `tProp(types.dateAsTimestamp)`.
  * Use `tProp(types.skipCheck(types.dateAsTimestamp))` if you don't need runtime validation.

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

@@ -1,4 +1,4 @@
-export * from './asMap';
-export * from './asSet';
-export * from './bigint';
-export * from './date';
+export * from "./asMap";
+export * from "./asSet";
+export * from "./bigint";
+export * from "./date";

package/dist/types/treeUtils/draft.d.ts

@@ -1,4 +1,4 @@
-import { Path } from '../parent/pathTypes';
+import type { Path } from "../parent/pathTypes";
 /**
  * A class with the implementationm of draft.
  * Use `draft` to create an instance of this class.

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

@@ -1,3 +1,3 @@
-export * from './deepEquals';
-export * from './draft';
-export * from './sandbox';
+export * from "./deepEquals";
+export * from "./draft";
+export * from "./sandbox";

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

@@ -1,2 +1,2 @@
-export * from './core';
-export * from './tweak';
+export * from "./core";
+export * from "./tweak";

package/dist/types/tweaker/tweak.d.ts

@@ -1,4 +1,4 @@
-import { AnyStandardType, TypeToData } from '../types/schemas';
+import type { AnyStandardType, TypeToData } from "../types/schemas";
 /**
  * Turns an object (array, plain object) into a tree node,
  * which then can accept calls to `getParent`, `getSnapshot`, etc.

package/dist/types/types/SnapshotTypeMismatchError.d.ts

@@ -1,5 +1,5 @@
-import { Path } from '../parent/pathTypes';
-import { MobxKeystoneError } from '../utils';
+import type { Path } from "../parent/pathTypes";
+import { MobxKeystoneError } from "../utils";
 export interface SnapshotTypeMismatchErrorData {
     path?: Path;
     expectedTypeName: string;

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

@@ -1,5 +1,5 @@
-import { Path } from '../parent/pathTypes';
-import { MobxKeystoneError } from '../utils';
+import type { Path } from "../parent/pathTypes";
+import { MobxKeystoneError } from "../utils";
 export interface TypeCheckErrorData {
     /** Path relative to the value being type checked. */
     path: Path;

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

@@ -1,6 +1,6 @@
-import { Path } from '../parent/pathTypes';
-import { AnyStandardType } from './schemas';
-import { TypeCheckError } from './TypeCheckError';
+import type { Path } from "../parent/pathTypes";
+import type { AnyStandardType } from "./schemas";
+import type { TypeCheckError } from "./TypeCheckError";
 type CheckFunction = (value: any, path: Path, typeCheckedValue: any) => TypeCheckError | null;
 /** @ignore */
 export type SnapshotProcessor = (snapshot: any) => unknown;

package/dist/types/types/arrayBased/typesArray.d.ts

@@ -1,5 +1,5 @@
-import { AnyStandardType, AnyType, ArrayType } from '../schemas';
-import { TypeInfo } from '../TypeChecker';
+import type { AnyStandardType, AnyType, ArrayType } from "../schemas";
+import { TypeInfo } from "../TypeChecker";
 /**
  * A type that represents an array of values of a given type.
  *

package/dist/types/types/arrayBased/typesTuple.d.ts

@@ -1,5 +1,5 @@
-import { AnyStandardType, AnyType, ArrayType } from '../schemas';
-import { TypeInfo } from '../TypeChecker';
+import type { AnyStandardType, AnyType, ArrayType } from "../schemas";
+import { TypeInfo } from "../TypeChecker";
 /**
  * A type that represents an tuple of values of a given type.
  *

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

@@ -1,5 +1,5 @@
-import { AnyType } from './schemas';
-import { TypeInfo } from './TypeChecker';
+import type { AnyType } from "./schemas";
+import type { TypeInfo } from "./TypeChecker";
 /**
  * Gets the type info of a given type.
  *

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

@@ -1,7 +1,7 @@
-export * from './SnapshotTypeMismatchError';
-export * from './schemas';
-export * from './TypeCheckError';
-export * from './tProp';
-export { typeCheck } from './typeCheck';
-export * from './types';
-export type { CodecFromEncoded } from './utility/typesCodecCore';
+export * from "./SnapshotTypeMismatchError";
+export * from "./schemas";
+export * from "./TypeCheckError";
+export * from "./tProp";
+export { typeCheck } from "./typeCheck";
+export * from "./types";
+export type { CodecFromEncoded } from "./utility/typesCodecCore";

package/dist/types/types/objectBased/typesArraySet.d.ts

@@ -1,6 +1,6 @@
-import { ArraySet } from '../../wrappers/ArraySet';
-import { AnyStandardType, AnyType, ModelType, TypeToData } from '../schemas';
-import { TypeInfo } from '../TypeChecker';
+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.
  *

package/dist/types/types/objectBased/typesDataModelData.d.ts

@@ -1,7 +1,7 @@
-import { AnyDataModel } from '../../dataModel/BaseDataModel';
-import { ModelClass, ModelData, ModelUntransformedData } from '../../modelShared/BaseModelShared';
-import { AnyStandardType, IdentityType } from '../schemas';
-import { TypeInfo } from '../TypeChecker';
+import type { AnyDataModel } from "../../dataModel/BaseDataModel";
+import type { ModelClass, ModelData, ModelUntransformedData } from "../../modelShared/BaseModelShared";
+import type { AnyStandardType, IdentityType } from "../schemas";
+import { TypeInfo } from "../TypeChecker";
 type _Class<T> = abstract new (...args: any[]) => T;
 type _ClassOrObject<M, K> = K extends M ? object : _Class<K> | (() => _Class<K>);
 /**

package/dist/types/types/objectBased/typesModel.d.ts

@@ -1,7 +1,7 @@
-import { AnyModel } from '../../model/BaseModel';
-import { ModelClass } from '../../modelShared/BaseModelShared';
-import { AnyStandardType, ModelType } from '../schemas';
-import { TypeInfo } from '../TypeChecker';
+import type { AnyModel } from "../../model/BaseModel";
+import type { ModelClass } from "../../modelShared/BaseModelShared";
+import type { AnyStandardType, ModelType } from "../schemas";
+import { TypeInfo } from "../TypeChecker";
 type _Class<T> = abstract new (...args: any[]) => T;
 type _ClassOrObject<M, K> = K extends M ? object : _Class<K> | (() => _Class<K>);
 /**

package/dist/types/types/objectBased/typesObject.d.ts

@@ -1,6 +1,6 @@
-import { Frozen } from '../../frozen/Frozen';
-import { AnyStandardType, AnyType, ModelType, ObjectTypeFunction, TypeToData } from '../schemas';
-import { TypeInfo } from '../TypeChecker';
+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.

package/dist/types/types/objectBased/typesObjectMap.d.ts

@@ -1,6 +1,6 @@
-import { ObjectMap } from '../../wrappers/ObjectMap';
-import { AnyStandardType, AnyType, ModelType, TypeToData } from '../schemas';
-import { TypeInfo } from '../TypeChecker';
+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.
  *

package/dist/types/types/objectBased/typesRecord.d.ts

@@ -1,5 +1,5 @@
-import { AnyStandardType, AnyType, RecordType } from '../schemas';
-import { TypeInfo } from '../TypeChecker';
+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.
  *

package/dist/types/types/objectBased/typesRef.d.ts

@@ -1,6 +1,6 @@
-import { Ref, RefConstructor } from '../../ref/Ref';
-import { ModelType } from '../schemas';
-import { TypeInfo } from '../TypeChecker';
+import type { 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.
  *

package/dist/types/types/primitiveBased/typesEnum.d.ts

@@ -1,4 +1,4 @@
-import { IdentityType } from '../schemas';
+import type { IdentityType } from "../schemas";
 /**
  * @ignore
  * Enum like object.

package/dist/types/types/primitiveBased/typesPrimitive.d.ts

@@ -1,6 +1,6 @@
-import { PrimitiveValue } from '../../utils/types';
-import { AnyStandardType, IdentityType } from '../schemas';
-import { TypeInfo } from '../TypeChecker';
+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).
  *

package/dist/types/types/primitiveBased/typesRefinedPrimitive.d.ts

@@ -6,7 +6,7 @@
  * types.integer
  * ```
  */
-export declare const typesInteger: import('..').IdentityType<number>;
+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")`
@@ -15,4 +15,4 @@ export declare const typesInteger: import('..').IdentityType<number>;
  * types.nonEmptyString
  * ```
  */
-export declare const typesNonEmptyString: import('..').IdentityType<string>;
+export declare const typesNonEmptyString: import("..").IdentityType<string>;

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

@@ -1,8 +1,8 @@
-import { AnyDataModel } from '../dataModel/BaseDataModel';
-import { AnyModel } from '../model/BaseModel';
-import { ModelClass } from '../modelShared/BaseModelShared';
-import { SnapshotInOf, SnapshotOutOf } from '../snapshot/SnapshotOf';
-import { IsOptionalValue, SimplifyObject } from '../utils/types';
+import type { AnyDataModel } from "../dataModel/BaseDataModel";
+import type { AnyModel } from "../model/BaseModel";
+import type { ModelClass } from "../modelShared/BaseModelShared";
+import type { SnapshotInOf, SnapshotOutOf } from "../snapshot/SnapshotOf";
+import type { IsOptionalValue, SimplifyObject } from "../utils/types";
 export interface Type<Name, Data> {
     /** @ignore */
     $$type: Name;

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

@@ -1,7 +1,7 @@
-import { MaybeOptionalModelProp, OptionalModelProp } from '../modelShared/prop';
-import { typesBoolean, typesNumber, typesString } from './primitiveBased/typesPrimitive';
-import { AnyType, TypeToData, TypeToSnapshotIn } from './schemas';
-import { TypeToStoredData } from './utility/typeToStoredData';
+import { type MaybeOptionalModelProp, type OptionalModelProp } from "../modelShared/prop";
+import { typesBoolean, typesNumber, typesString } from "./primitiveBased/typesPrimitive";
+import type { AnyType, TypeToData, TypeToSnapshotIn } from "./schemas";
+import type { TypeToStoredData } from "./utility/typeToStoredData";
 type StoredRequiredPropMetadata<TType extends AnyType> = {
     $storedValueType: TypeToStoredData<TType>;
     $storedCreationValueType: TypeToStoredData<TType>;

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

@@ -1,5 +1,5 @@
-import { AnyType, TypeToData } from './schemas';
-import { TypeCheckError } from './TypeCheckError';
+import type { AnyType, TypeToData } from "./schemas";
+import type { TypeCheckError } from "./TypeCheckError";
 /**
  * Checks if a value conforms to a given type.
  *