mobx-keystone 0.68.0 → 0.68.1-alpha

package/src/dist/actionMiddlewares/undoMiddleware.d.ts

@@ -0,0 +1,283 @@
+import type { ActionMiddlewareDisposer } from "../action/middleware";
+import type { Path } from "../parent/pathTypes";
+import { Patch } from "../patch";
+/**
+ * An undo/redo event without attached state.
+ */
+export declare type UndoEventWithoutAttachedState = UndoSingleEvent | UndoEventGroup;
+/**
+ * An undo/redo event.
+ */
+export declare type UndoEvent = UndoEventWithoutAttachedState & {
+    /**
+     * The state saved before the event actions started / after the event actions finished.
+     */
+    attachedState: {
+        /**
+         * The state saved before the event actions started.
+         */
+        beforeEvent?: unknown;
+        /**
+         * The state saved after the event actions finished.
+         */
+        afterEvent?: unknown;
+    };
+};
+/**
+ * Undo event type.
+ */
+export declare enum UndoEventType {
+    Single = "single",
+    Group = "group"
+}
+/**
+ * An undo/redo single event.
+ */
+export interface UndoSingleEvent {
+    /**
+     * Expresses this is a single event.
+     */
+    readonly type: UndoEventType.Single;
+    /**
+     * Path to the object that invoked the action from its root.
+     */
+    readonly targetPath: Path;
+    /**
+     * Name of the action that was invoked.
+     */
+    readonly actionName: string;
+    /**
+     * Patches with changes done inside the action.
+     * Use `redo()` in the `UndoManager` to apply them.
+     */
+    readonly patches: ReadonlyArray<Patch>;
+    /**
+     * Patches to undo the changes done inside the action.
+     * Use `undo()` in the `UndoManager` to apply them.
+     */
+    readonly inversePatches: ReadonlyArray<Patch>;
+}
+/**
+ * An undo/redo event group.
+ */
+export interface UndoEventGroup {
+    /**
+     * Expresses this is an event group.
+     */
+    readonly type: UndoEventType.Group;
+    /**
+     * Name of the group (if any).
+     */
+    readonly groupName?: string;
+    /**
+     * Events that conform this group (might be single events or other nested groups).
+     */
+    readonly events: ReadonlyArray<UndoEventWithoutAttachedState>;
+}
+declare const UndoStore_base: import("../model/Model")._Model<unknown, {
+    undoEvents: import("..").OptionalModelProp<UndoEvent[]>;
+    redoEvents: import("..").OptionalModelProp<UndoEvent[]>;
+}, never, never>;
+/**
+ * Store model instance for undo/redo actions.
+ * Do not manipulate directly, other that creating it.
+ */
+export declare class UndoStore extends UndoStore_base {
+    /**
+     * @ignore
+     */
+    _clearUndo(): void;
+    /**
+     * @ignore
+     */
+    _clearRedo(): void;
+    /**
+     * @ignore
+     */
+    _undo(): void;
+    /**
+     * @ignore
+     */
+    _redo(): void;
+    /**
+     * @ignore
+     */
+    _addUndo(event: UndoEvent): void;
+    private _groupStack;
+    /**
+     * @ignore
+     */
+    _addUndoToParentGroup(parentGroup: UndoEventGroup, event: UndoEventWithoutAttachedState): void;
+    /**
+     * @ignore
+     */
+    get _currentGroup(): UndoEventGroup | undefined;
+    /**
+     * @ignore
+     */
+    _startGroup(groupName: string | undefined, startRunning: boolean, options: UndoMiddlewareOptions<unknown> | undefined): {
+        pause: () => void;
+        resume: () => void;
+        end: () => void;
+    };
+}
+/**
+ * Manager class returned by `undoMiddleware` that allows you to perform undo/redo actions.
+ */
+export declare class UndoManager {
+    private readonly disposer;
+    private readonly subtreeRoot;
+    private readonly options;
+    /**
+     * The store currently being used to store undo/redo action events.
+     */
+    readonly store: UndoStore;
+    /**
+     * The undo stack, where the first operation to undo will be the last of the array.
+     * Do not manipulate this array directly.
+     */
+    get undoQueue(): ReadonlyArray<UndoEvent>;
+    /**
+     * The redo stack, where the first operation to redo will be the last of the array.
+     * Do not manipulate this array directly.
+     */
+    get redoQueue(): ReadonlyArray<UndoEvent>;
+    /**
+     * The number of undo actions available.
+     */
+    get undoLevels(): number;
+    /**
+     * If undo can be performed (if there is at least one undo action available).
+     */
+    get canUndo(): boolean;
+    /**
+     * Clears the undo queue.
+     */
+    clearUndo(): void;
+    /**
+     * The number of redo actions available.
+     */
+    get redoLevels(): number;
+    /**
+     * If redo can be performed (if there is at least one redo action available)
+     */
+    get canRedo(): boolean;
+    /**
+     * Clears the redo queue.
+     */
+    clearRedo(): void;
+    /**
+     * Undoes the last action.
+     * Will throw if there is no action to undo.
+     */
+    undo(): void;
+    /**
+     * Redoes the previous action.
+     * Will throw if there is no action to redo.
+     */
+    redo(): void;
+    /**
+     * Disposes the undo middleware.
+     */
+    dispose(): void;
+    private _isUndoRecordingDisabled;
+    /**
+     * Returns if undo recording is currently disabled or not for this particular `UndoManager`.
+     */
+    get isUndoRecordingDisabled(): boolean;
+    /**
+     * Skips the undo recording mechanism for the code block that gets run synchronously inside.
+     *
+     * @typeparam T Code block return type.
+     * @param fn Code block to run.
+     * @returns The value returned by the code block.
+     */
+    withoutUndo<T>(fn: () => T): T;
+    /**
+     * Creates a custom group that can be continued multiple times and then ended.
+     * @param groupName Optional group name.
+     * @returns An API to continue/end the group.
+     */
+    createGroup(groupName?: string): {
+        continue<T>(fn: () => T): T;
+        end(): void;
+    };
+    /**
+     * Runs a synchronous code block as an undo group.
+     * Note that nested groups are allowed.
+     *
+     * @param groupName Group name.
+     * @param fn Code block.
+     * @returns Code block return value.
+     */
+    withGroup<T>(groupName: string, fn: () => T): T;
+    /**
+     * Runs a synchronous code block as an undo group.
+     * Note that nested groups are allowed.
+     *
+     * @param fn Code block.
+     * @returns Code block return value.
+     */
+    withGroup<T>(fn: () => T): T;
+    /**
+     * Runs an asynchronous code block as an undo group.
+     * Note that nested groups are allowed.
+     *
+     * @param groupName Group name.
+     * @param fn Flow function.
+     * @returns Flow function return value.
+     */
+    withGroupFlow<R>(groupName: string, fn: () => Generator<any, R, any>): Promise<R>;
+    /**
+     * Runs an asynchronous code block as an undo group.
+     * Note that nested groups are allowed.
+     *
+     * @param fn Flow function.
+     * @returns Flow function return value.
+     */
+    withGroupFlow<R>(fn: () => Generator<any, R, any>): Promise<R>;
+    /**
+     * Creates an instance of `UndoManager`.
+     * Do not use directly, use `undoMiddleware` instead.
+     *
+     * @param disposer
+     * @param subtreeRoot
+     * @param [store]
+     */
+    constructor(disposer: ActionMiddlewareDisposer, subtreeRoot: object, store: UndoStore | undefined, options: UndoMiddlewareOptions<unknown> | undefined);
+}
+/**
+ * Undo middleware options.
+ */
+export interface UndoMiddlewareOptions<S> {
+    attachedState?: {
+        save(): S;
+        restore(s: S): void;
+    };
+}
+/**
+ * Creates an undo middleware.
+ *
+ * @param subtreeRoot Subtree root target object.
+ * @param store Optional `UndoStore` where to store the undo/redo queues. Use this if you want to
+ * store such queues somewhere in your models. If none is provided it will reside in memory.
+ * @param options Extra options, such as how to save / restore certain snapshot of the state to be restored when undoing/redoing.
+ * @returns An `UndoManager` which allows you to do the manage the undo/redo operations and dispose of the middleware.
+ */
+export declare function undoMiddleware<S>(subtreeRoot: object, store?: UndoStore, options?: UndoMiddlewareOptions<S>): UndoManager;
+/**
+ * Returns if the undo recording mechanism is currently disabled.
+ *
+ * @returns `true` if it is currently disabled, `false` otherwise.
+ */
+export declare function isGlobalUndoRecordingDisabled(): boolean;
+/**
+ * Globally skips the undo recording mechanism for the code block that gets run synchronously inside.
+ * Consider using the `withoutUndo` method of a particular `UndoManager` instead.
+ *
+ * @typeparam T Code block return type.
+ * @param fn Code block to run.
+ * @returns The value returned by the code block.
+ */
+export declare function withoutUndo<T>(fn: () => T): T;
+export {};

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

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

package/src/dist/computedTree/computedTree.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Returns if a given node is a computed tree node.
+ *
+ * @param node Node to check.
+ * @returns `true` if it is a computed tree node, `false` otherwise.
+ */
+export declare function isComputedTreeNode(node: object): boolean;
+/**
+ * Decorator for turning a computed property into a computed tree which supports tree traversal
+ * functions, contexts, references, etc.
+ *
+ * @param target Prototype of the class.
+ * @param propertyKey Name of the member.
+ * @param descriptor Property descriptor for the member.
+ */
+export declare function computedTree(target: any, propertyKey: string, descriptor: PropertyDescriptor): void;

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

@@ -0,0 +1 @@
+export * from "./computedTree";

package/src/dist/context/context.d.ts

@@ -0,0 +1,84 @@
+/**
+ * A context.
+ */
+export interface Context<T> {
+    /**
+     * Gets the context default value.
+     *
+     * @returns
+     */
+    getDefault(): T;
+    /**
+     * Sets the context default value.
+     * @param value
+     */
+    setDefault(value: T): void;
+    /**
+     * Sets the context default value resolver.
+     * @param valueFn
+     */
+    setDefaultComputed(valueFn: () => T): void;
+    /**
+     * Gets the context value for a given node.
+     * @param node
+     */
+    get(node: object): T;
+    /**
+     * Gets node that will provide the context value, or `undefined`
+     * if it comes from the default.
+     * @param node
+     */
+    getProviderNode(node: object): object | undefined;
+    /**
+     * Sets the context value for a given node, effectively making it a provider.
+     * @param node
+     * @param value
+     */
+    set(node: object, value: T): void;
+    /**
+     * Sets the context value resolver for a given node, effectively making it a provider.
+     * @param node
+     * @param valueFn
+     */
+    setComputed(node: object, valueFn: () => T): void;
+    /**
+     * Unsets the context value for a given node, therefore it won't be a provider anymore.
+     * @param node
+     */
+    unset(node: object): void;
+    /**
+     * Applies a value override while the given function is running and, if a node is returned,
+     * sets the node as a provider of the value.
+     *
+     * @typeparam R
+     * @param fn Function to run.
+     * @param value Value to apply.
+     * @returns The value returned from the function.
+     */
+    apply<R>(fn: () => R, value: T): R;
+    /**
+     * Applies a computed value override while the given function is running and, if a node is returned,
+     * sets the node as a provider of the computed value.
+     *
+     * @typeparam R
+     * @param fn Function to run.
+     * @param value Value to apply.
+     * @returns The value returned from the function.
+     */
+    applyComputed<R>(fn: () => R, valueFn: () => T): R;
+}
+/**
+ * Creates a new context with no default value, thus making its default value undefined.
+ *
+ * @typeparam T Context value type.
+ * @returns
+ */
+export declare function createContext<T>(): Context<T | undefined>;
+/**
+ * Creates a new context with a default value.
+ *
+ * @typeparam T Context value type.
+ * @param defaultValue
+ * @returns
+ */
+export declare function createContext<T>(defaultValue: T): Context<T>;

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

@@ -0,0 +1 @@
+export * from "./context";

package/src/dist/dataModel/BaseDataModel.d.ts

@@ -0,0 +1,52 @@
+import { propsTypeSymbol } from "../modelShared/BaseModelShared";
+import { ModelProps, ModelPropsToCreationData, ModelPropsToData, ModelPropsToTransformedCreationData } from "../modelShared/prop";
+import type { TypeCheckError } from "../types/TypeCheckError";
+/**
+ * Base abstract class for data models. Use `DataModel` instead when extending.
+ *
+ * Never override the constructor, use `onLazyInit` instead.
+ *
+ * @typeparam Data Props data type.
+ */
+export declare abstract class BaseDataModel<TProps extends ModelProps> {
+    [propsTypeSymbol]: TProps;
+    /**
+     * Called after the instance is created when there's the first call to `fn(M, data)`.
+     */
+    protected onLazyInit?(): void;
+    /**
+     * Data part of the model, which is observable and will be serialized in snapshots.
+     * Use it if one of the data properties matches one of the model properties/functions.
+     * This also allows access to the backed values of transformed properties.
+     */
+    readonly $: ModelPropsToData<TProps>;
+    /**
+     * Performs a type check over the model instance.
+     * For this to work a data type has to be declared as part of the model properties.
+     *
+     * @returns A `TypeCheckError` or `null` if there is no error.
+     */
+    typeCheck(): TypeCheckError | null;
+    /**
+     * Creates an instance of a data model.
+     */
+    constructor(data: ModelPropsToCreationData<TProps> | ModelPropsToTransformedCreationData<TProps>);
+    toString(options?: {
+        withData?: boolean;
+    }): string;
+}
+/**
+ * @ignore
+ */
+export declare type BaseDataModelKeys = keyof AnyDataModel | "onLazyInit";
+/**
+ * Any kind of data model instance.
+ */
+export interface AnyDataModel extends BaseDataModel<any> {
+}
+/**
+ * A data model class declaration, made of a base model and the model interface.
+ */
+export declare type DataModelClassDeclaration<BaseModelClass, ModelInterface> = BaseModelClass & {
+    (...args: any[]): ModelInterface;
+};

package/src/dist/dataModel/DataModel.d.ts

@@ -0,0 +1,47 @@
+import type { AbstractModelClass, ModelCreationData, ModelTransformedCreationData } from "../modelShared/BaseModelShared";
+import type { ModelProps, ModelPropsToCreationData, ModelPropsToSetter, ModelPropsToTransformedCreationData, ModelPropsToTransformedData } from "../modelShared/prop";
+import type { AnyDataModel, BaseDataModel, BaseDataModelKeys } from "./BaseDataModel";
+export declare type _ComposedData<SuperModel, TProps extends ModelProps> = SuperModel extends AnyDataModel ? (ModelPropsToCreationData<TProps> & ModelCreationData<SuperModel>) | (ModelPropsToTransformedCreationData<TProps> & ModelTransformedCreationData<SuperModel>) : ModelPropsToCreationData<TProps> | ModelPropsToTransformedCreationData<TProps>;
+export interface _DataModel<SuperModel, TProps extends ModelProps> {
+    new (data: _ComposedData<SuperModel, TProps>): SuperModel & BaseDataModel<TProps> & Omit<ModelPropsToTransformedData<TProps>, BaseDataModelKeys> & ModelPropsToSetter<TProps>;
+}
+/**
+ * Base abstract class for data models that extends another model.
+ *
+ * @typeparam TProps New model properties type.
+ * @typeparam TModel Model type.
+ * @param genFn Function that returns the base model and model properties.
+ * @returns
+ */
+export declare function ExtendedDataModel<TProps extends ModelProps, TModel extends AnyDataModel, A extends []>(genFn: (...args: A) => {
+    baseModel: AbstractModelClass<TModel>;
+    props: TProps;
+}): _DataModel<TModel, TProps>;
+/**
+ * Base abstract class for data models that extends another model.
+ *
+ * @typeparam TProps New model properties type.
+ * @typeparam TModel Model type.
+ * @param baseModel Base model type.
+ * @param modelProps Model properties.
+ * @returns
+ */
+export declare function ExtendedDataModel<TProps extends ModelProps, TModel extends AnyDataModel>(baseModel: AbstractModelClass<TModel>, modelProps: TProps): _DataModel<TModel, TProps>;
+/**
+ * Base abstract class for data models.
+ *
+ * Never override the constructor, use `onLazyInit` or `onLazyAttachedToRootStore` instead.
+ *
+ * @typeparam TProps Model properties type.
+ * @param fnModelProps Function that generates model properties.
+ */
+export declare function DataModel<TProps extends ModelProps, A extends []>(fnModelProps: (...args: A) => TProps): _DataModel<unknown, TProps>;
+/**
+ * Base abstract class for data models.
+ *
+ * Never override the constructor, use `onLazyInit` or `onLazyAttachedToRootStore` instead.
+ *
+ * @typeparam TProps Model properties type.
+ * @param modelProps Model properties.
+ */
+export declare function DataModel<TProps extends ModelProps>(modelProps: TProps): _DataModel<unknown, TProps>;

package/src/dist/dataModel/DataModelConstructorOptions.d.ts

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

package/src/dist/dataModel/actions.d.ts

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

package/src/dist/dataModel/getDataModelMetadata.d.ts

@@ -0,0 +1,19 @@
+import type { ModelClass } from "../modelShared/BaseModelShared";
+import type { AnyType } from "../types/schemas";
+import type { AnyDataModel } from "./BaseDataModel";
+/**
+ * Associated data model metadata.
+ */
+export interface DataModelMetadata {
+    /**
+     * Associated data type for runtime checking (if any).
+     */
+    dataType?: AnyType;
+}
+/**
+ * Returns the associated metadata for a data model instance or class.
+ *
+ * @param modelClassOrInstance Data model class or instance.
+ * @returns The associated metadata.
+ */
+export declare function getDataModelMetadata(modelClassOrInstance: AnyDataModel | ModelClass<AnyDataModel>): DataModelMetadata;

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

@@ -0,0 +1,4 @@
+export * from "./BaseDataModel";
+export * from "./DataModel";
+export * from "./getDataModelMetadata";
+export * from "./utils";

package/src/dist/dataModel/newDataModel.d.ts

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

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

@@ -0,0 +1,8 @@
+import type { AnyDataModel } from "./BaseDataModel";
+/**
+ * Checks if an object is a data model instance.
+ *
+ * @param model
+ * @returns
+ */
+export declare function isDataModel(model: unknown): model is AnyDataModel;

package/src/dist/frozen/Frozen.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Should freeze and plain json checks be done when creating the frozen object?
+ */
+export declare enum FrozenCheckMode {
+    /** Only when in dev mode */
+    DevModeOnly = "devModeOnly",
+    /** Always */
+    On = "on",
+    /** Never */
+    Off = "off"
+}
+/**
+ * @ignore
+ */
+export declare const frozenKey = "$frozen";
+/**
+ * A class that contains frozen data.
+ * Use `frozen` to create an instance of this class.
+ *
+ * @typeparam T Data type.
+ */
+export declare class Frozen<T> {
+    /**
+     * Frozen data, deeply immutable.
+     */
+    readonly data: T;
+    /**
+     * Creates an instance of Frozen.
+     * Do not use directly, use `frozen` instead.
+     *
+     * @param dataToFreeze
+     * @param checkMode
+     */
+    constructor(dataToFreeze: T, checkMode?: FrozenCheckMode);
+}
+/**
+ * Marks some data as frozen. Frozen data becomes immutable (at least in dev mode), and is not enhanced
+ * with capabilities such as getting the parent of the objects (except for the root object), it is not
+ * made deeply observable (though the root object is observable by reference), etc.
+ * On the other hand, this means it will be much faster to create/access. Use this for big data pieces
+ * that are unlikely to change unless all of them change (for example lists of points for a polygon, etc).
+ *
+ * Note that data passed to frozen must be serializable to JSON, this is:
+ * - primitive, plain object, or array
+ * - without cycles
+ *
+ * @param data
+ * @param checkMode
+ */
+export declare function frozen<T>(data: T, checkMode?: FrozenCheckMode): Frozen<T>;

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

@@ -0,0 +1 @@
+export * from "./Frozen";

package/src/dist/globalConfig/globalConfig.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Model auto type-checking mode.
+ */
+export declare enum ModelAutoTypeCheckingMode {
+    /**
+     * Auto type check models only in dev mode
+     */
+    DevModeOnly = "devModeOnly",
+    /**
+     * Auto type check models no matter the current environment
+     */
+    AlwaysOn = "alwaysOn",
+    /**
+     * Do not auto type check models no matter the current environment
+     */
+    AlwaysOff = "alwaysOff"
+}
+/**
+ * Global config object.
+ */
+export interface GlobalConfig {
+    /**
+     * Model auto type-checking mode.
+     */
+    modelAutoTypeChecking: ModelAutoTypeCheckingMode;
+    /**
+     * ID generator function for model ids.
+     */
+    modelIdGenerator(): string;
+    /**
+     * Allow array elements to be `undefined`.
+     */
+    allowUndefinedArrayElements: boolean;
+    /**
+     * Enables/disables warnings related to duplicated model names (defaults to `true`).
+     * Usually set to false in test environments (e.g. jest).
+     */
+    showDuplicateModelNameWarnings: boolean;
+}
+/**
+ * Partially sets the current global config.
+ *
+ * @param config Partial object with the new configurations. Options not included in the object won't be changed.
+ */
+export declare function setGlobalConfig(config: Partial<GlobalConfig>): void;
+/**
+ * Returns the current global config object.
+ *
+ * @returns
+ */
+export declare function getGlobalConfig(): Readonly<GlobalConfig>;

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

@@ -0,0 +1 @@
+export * from "./globalConfig";

package/src/dist/index.d.ts

@@ -0,0 +1,23 @@
+export * from "./action";
+export * from "./actionMiddlewares";
+export * from "./computedTree";
+export * from "./context";
+export * from "./dataModel";
+export * from "./frozen";
+export * from "./globalConfig";
+export * from "./model";
+export * from "./modelShared";
+export * from "./parent";
+export * from "./patch";
+export * from "./redux";
+export * from "./ref";
+export * from "./rootStore";
+export * from "./snapshot";
+export * from "./standardActions";
+export * from "./transforms";
+export * from "./treeUtils";
+export * from "./tweaker";
+export * from "./types";
+export * from "./utils";
+export * from "./utils/tag";
+export * from "./wrappers";