document-model 1.0.22 → 1.0.24

package/dist/src/document/actions/index.d.ts

@@ -0,0 +1,10 @@
+import { Action, Document, ImmutableStateReducer, PruneAction, RedoAction, State, UndoAction } from '../types';
+export declare function setNameOperation<T>(document: T, name: string): T;
+export declare function undoOperation<T, A extends Action, L>(document: Document<T, A, L>, action: UndoAction, wrappedReducer: ImmutableStateReducer<T, A, L>): Document<T, A, L>;
+export declare function redoOperation<T, A extends Action, L>(document: Document<T, A, L>, action: RedoAction, wrappedReducer: ImmutableStateReducer<T, A, L>): Document<T, A, L>;
+export declare function pruneOperation<T, A extends Action, L>(document: Document<T, A, L>, action: PruneAction, wrappedReducer: ImmutableStateReducer<T, A, L>): Document<T, A, L>;
+export declare function loadStateOperation<T, A extends Action, L>(oldDocument: Document<T, A, L>, newDocument: {
+    name: string;
+    state?: State<T, L>;
+}): Document<T, A, L>;
+export * from './creators';

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

@@ -0,0 +1,8 @@
+import { BaseAction } from '../types';
+export declare const SET_NAME = "SET_NAME";
+export declare const UNDO = "UNDO";
+export declare const REDO = "REDO";
+export declare const PRUNE = "PRUNE";
+export declare const LOAD_STATE = "LOAD_STATE";
+export { LoadStateAction, PruneAction, RedoAction, SetNameAction, UndoAction, NOOPAction, } from '../types';
+export type { BaseAction };

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

@@ -0,0 +1,6 @@
+export * as actions from './actions/creators';
+export * from './object';
+export * from './reducer';
+export * from './signal';
+export * from './types';
+export * as utils from './utils';

package/dist/src/document/object.d.ts

@@ -0,0 +1,447 @@
+import type { BaseAction } from './actions/types';
+import type { SignalDispatch } from './signal';
+import type { Action, AttachmentRef, Document, ExtendedState, OperationScope, Reducer, ReducerOptions } from './types';
+/**
+ * This is an abstract class representing a document and provides methods
+ * for creating and manipulating documents.
+ * @typeparam T - The type of data stored in the document.
+ * @typeparam A - The type of action the document can take.
+ */
+export declare abstract class BaseDocument<T, A extends Action, L = unknown> {
+    protected _document: Document<T, A, L>;
+    private _reducer;
+    private _signalDispatch?;
+    /**
+     * Constructs a BaseDocument instance with an initial state.
+     * @param reducer - The reducer function that updates the state.
+     * @param document - The initial state of the document.
+     */
+    constructor(reducer: Reducer<T, A, L>, document: Document<T, A, L>, signalDispatch?: SignalDispatch);
+    /**
+     * Dispatches an action to update the state of the document.
+     * @param action - The action to dispatch.
+     * @returns The Document instance.
+     */
+    protected dispatch(action: A | BaseAction, options?: ReducerOptions): this;
+    /**
+     * Saves the state of the document to a file.
+     * @param path - The file path where the state should be saved.
+     * @param extension - The file extension to use when saving the state.
+     * @returns The file path where the state was saved.
+     */
+    protected saveToFile(path: string, extension: string, name?: string): Promise<string>;
+    /**
+     * Loads the state of the document from a file.
+     * @param path - The file path where the state is stored.
+     */
+    loadFromFile(path: string): Promise<void>;
+    /**
+     * Loads the state of the document from a file and returns it.
+     * @param path - The file path where the state is stored.
+     * @param reducer - The reducer function that updates the state.
+     * @returns The state of the document.
+     */
+    protected static stateFromFile<T, A extends Action, L>(path: string, reducer: Reducer<T, A, L>): Promise<Document<T, A, L>>;
+    /**
+     *    Gets the current state of the document.
+     */
+    get state(): {
+        readonly global: import("immer").Immutable<T>;
+        readonly local: import("immer").Immutable<L>;
+    };
+    /**
+     *    Gets the list of operations performed on the document.
+     */
+    get operations(): {
+        readonly global: readonly ({
+            readonly input: {
+                readonly operations: number;
+                readonly state: {
+                    readonly data?: unknown;
+                    readonly name: string;
+                };
+            };
+            readonly type: "LOAD_STATE";
+            readonly scope: OperationScope;
+            readonly index: number;
+            readonly timestamp: string;
+            readonly hash: string;
+            readonly skip: number;
+        } | {
+            readonly input: {
+                readonly end?: import("./types").InputMaybe<number>;
+                readonly start?: import("./types").InputMaybe<number>;
+            };
+            readonly type: "PRUNE";
+            readonly scope: OperationScope;
+            readonly index: number;
+            readonly timestamp: string;
+            readonly hash: string;
+            readonly skip: number;
+        } | {
+            readonly input: number;
+            readonly type: "REDO";
+            readonly scope: OperationScope;
+            readonly index: number;
+            readonly timestamp: string;
+            readonly hash: string;
+            readonly skip: number;
+        } | {
+            readonly input: string;
+            readonly type: "SET_NAME";
+            readonly scope: "global";
+            readonly index: number;
+            readonly timestamp: string;
+            readonly hash: string;
+            readonly skip: number;
+        } | {
+            readonly input: number;
+            readonly type: "UNDO";
+            readonly scope: OperationScope;
+            readonly index: number;
+            readonly timestamp: string;
+            readonly hash: string;
+            readonly skip: number;
+        } | {
+            readonly input: unknown;
+            readonly type: "NOOP";
+            readonly scope: OperationScope;
+            readonly index: number;
+            readonly timestamp: string;
+            readonly hash: string;
+            readonly skip: number;
+        } | import("immer").Immutable<A & {
+            index: number;
+            timestamp: string;
+            hash: string;
+            skip: number;
+        }>)[];
+        readonly local: readonly ({
+            readonly input: {
+                readonly operations: number;
+                readonly state: {
+                    readonly data?: unknown;
+                    readonly name: string;
+                };
+            };
+            readonly type: "LOAD_STATE";
+            readonly scope: OperationScope;
+            readonly index: number;
+            readonly timestamp: string;
+            readonly hash: string;
+            readonly skip: number;
+        } | {
+            readonly input: {
+                readonly end?: import("./types").InputMaybe<number>;
+                readonly start?: import("./types").InputMaybe<number>;
+            };
+            readonly type: "PRUNE";
+            readonly scope: OperationScope;
+            readonly index: number;
+            readonly timestamp: string;
+            readonly hash: string;
+            readonly skip: number;
+        } | {
+            readonly input: number;
+            readonly type: "REDO";
+            readonly scope: OperationScope;
+            readonly index: number;
+            readonly timestamp: string;
+            readonly hash: string;
+            readonly skip: number;
+        } | {
+            readonly input: string;
+            readonly type: "SET_NAME";
+            readonly scope: "global";
+            readonly index: number;
+            readonly timestamp: string;
+            readonly hash: string;
+            readonly skip: number;
+        } | {
+            readonly input: number;
+            readonly type: "UNDO";
+            readonly scope: OperationScope;
+            readonly index: number;
+            readonly timestamp: string;
+            readonly hash: string;
+            readonly skip: number;
+        } | {
+            readonly input: unknown;
+            readonly type: "NOOP";
+            readonly scope: OperationScope;
+            readonly index: number;
+            readonly timestamp: string;
+            readonly hash: string;
+            readonly skip: number;
+        } | import("immer").Immutable<A & {
+            index: number;
+            timestamp: string;
+            hash: string;
+            skip: number;
+        }>)[];
+    };
+    /**
+     * Gets the name of the document.
+     */
+    get name(): string;
+    /**
+     * Gets the type of document.
+     */
+    get documentType(): string;
+    /**
+     * Gets the timestamp of the date the document was created.
+     */
+    get created(): string;
+    /**
+     * Gets the timestamp of the date the document was last modified.
+     */
+    get lastModified(): string;
+    /**
+     * Gets the global revision number of the document.
+     */
+    get revision(): number;
+    getRevision(scope: OperationScope): number;
+    /**
+     * Gets the initial state of the document.
+     */
+    get initialState(): {
+        readonly name: string;
+        readonly revision: {
+            readonly global: number;
+            readonly local: number;
+        };
+        readonly documentType: string;
+        readonly created: string;
+        readonly lastModified: string;
+        readonly state: {
+            readonly global: import("immer").Immutable<T>;
+            readonly local: import("immer").Immutable<L>;
+        };
+        readonly attachments: {
+            readonly [x: string]: {
+                readonly data: string;
+                readonly mimeType: string;
+                readonly extension?: string | null | undefined;
+                readonly fileName?: string | null | undefined;
+            };
+        };
+    };
+    /**
+     * Returns the current document as an object
+     */
+    toDocument(): {
+        readonly name: string;
+        readonly revision: {
+            readonly global: number;
+            readonly local: number;
+        };
+        readonly documentType: string;
+        readonly created: string;
+        readonly lastModified: string;
+        readonly state: {
+            readonly global: import("immer").Immutable<T>;
+            readonly local: import("immer").Immutable<L>;
+        };
+        readonly attachments: {
+            readonly [x: string]: {
+                readonly data: string;
+                readonly mimeType: string;
+                readonly extension?: string | null | undefined;
+                readonly fileName?: string | null | undefined;
+            };
+        };
+        readonly operations: {
+            readonly global: readonly ({
+                readonly input: {
+                    readonly operations: number;
+                    readonly state: {
+                        readonly data?: unknown;
+                        readonly name: string;
+                    };
+                };
+                readonly type: "LOAD_STATE";
+                readonly scope: OperationScope;
+                readonly index: number;
+                readonly timestamp: string;
+                readonly hash: string;
+                readonly skip: number;
+            } | {
+                readonly input: {
+                    readonly end?: import("./types").InputMaybe<number>;
+                    readonly start?: import("./types").InputMaybe<number>;
+                };
+                readonly type: "PRUNE";
+                readonly scope: OperationScope;
+                readonly index: number;
+                readonly timestamp: string;
+                readonly hash: string;
+                readonly skip: number;
+            } | {
+                readonly input: number;
+                readonly type: "REDO";
+                readonly scope: OperationScope;
+                readonly index: number;
+                readonly timestamp: string;
+                readonly hash: string;
+                readonly skip: number;
+            } | {
+                readonly input: string;
+                readonly type: "SET_NAME";
+                readonly scope: "global";
+                readonly index: number;
+                readonly timestamp: string;
+                readonly hash: string;
+                readonly skip: number;
+            } | {
+                readonly input: number;
+                readonly type: "UNDO";
+                readonly scope: OperationScope;
+                readonly index: number;
+                readonly timestamp: string;
+                readonly hash: string;
+                readonly skip: number;
+            } | {
+                readonly input: unknown;
+                readonly type: "NOOP";
+                readonly scope: OperationScope;
+                readonly index: number;
+                readonly timestamp: string;
+                readonly hash: string;
+                readonly skip: number;
+            } | import("immer").Immutable<A & {
+                index: number;
+                timestamp: string;
+                hash: string;
+                skip: number;
+            }>)[];
+            readonly local: readonly ({
+                readonly input: {
+                    readonly operations: number;
+                    readonly state: {
+                        readonly data?: unknown;
+                        readonly name: string;
+                    };
+                };
+                readonly type: "LOAD_STATE";
+                readonly scope: OperationScope;
+                readonly index: number;
+                readonly timestamp: string;
+                readonly hash: string;
+                readonly skip: number;
+            } | {
+                readonly input: {
+                    readonly end?: import("./types").InputMaybe<number>;
+                    readonly start?: import("./types").InputMaybe<number>;
+                };
+                readonly type: "PRUNE";
+                readonly scope: OperationScope;
+                readonly index: number;
+                readonly timestamp: string;
+                readonly hash: string;
+                readonly skip: number;
+            } | {
+                readonly input: number;
+                readonly type: "REDO";
+                readonly scope: OperationScope;
+                readonly index: number;
+                readonly timestamp: string;
+                readonly hash: string;
+                readonly skip: number;
+            } | {
+                readonly input: string;
+                readonly type: "SET_NAME";
+                readonly scope: "global";
+                readonly index: number;
+                readonly timestamp: string;
+                readonly hash: string;
+                readonly skip: number;
+            } | {
+                readonly input: number;
+                readonly type: "UNDO";
+                readonly scope: OperationScope;
+                readonly index: number;
+                readonly timestamp: string;
+                readonly hash: string;
+                readonly skip: number;
+            } | {
+                readonly input: unknown;
+                readonly type: "NOOP";
+                readonly scope: OperationScope;
+                readonly index: number;
+                readonly timestamp: string;
+                readonly hash: string;
+                readonly skip: number;
+            } | import("immer").Immutable<A & {
+                index: number;
+                timestamp: string;
+                hash: string;
+                skip: number;
+            }>)[];
+        };
+        readonly initialState: {
+            readonly name: string;
+            readonly revision: {
+                readonly global: number;
+                readonly local: number;
+            };
+            readonly documentType: string;
+            readonly created: string;
+            readonly lastModified: string;
+            readonly state: {
+                readonly global: import("immer").Immutable<T>;
+                readonly local: import("immer").Immutable<L>;
+            };
+            readonly attachments: {
+                readonly [x: string]: {
+                    readonly data: string;
+                    readonly mimeType: string;
+                    readonly extension?: string | null | undefined;
+                    readonly fileName?: string | null | undefined;
+                };
+            };
+        };
+    };
+    /**
+     * Gets the attachment associated with the given key.
+     * @param attachment - The key of the attachment to retrieve.
+     */
+    getAttachment(attachment: AttachmentRef): import("./types").Attachment;
+    /**
+     * Sets the name of the document.
+     * @param name - The new name of the document.
+     */
+    setName(name: string): this;
+    /**
+     * Reverts a number of actions from the document.
+     * @param count - The number of actions to revert.
+     */
+    undo(count: number): this;
+    /**
+     * Reapplies a number of actions to the document.
+     * @param count - The number of actions to reapply.
+     */
+    redo(count: number): this;
+    /**
+     * Removes a range of operations from the document.
+     * @param start - The starting index of the range to remove.
+     * @param end - The ending index of the range to remove.
+     */
+    prune(start?: number | undefined, end?: number | undefined): this;
+    /**
+     * Loads a document state and a set of operations.
+     * @param state - The state to load.
+     * @param operations - The operations to apply to the document.
+     */
+    loadState(state: Pick<ExtendedState<T, L>, 'state' | 'name'>, operations: number): this;
+}
+/**
+ * Applies multiple mixins to a base class.
+ * Used to have separate mixins to group methods by actions.
+ *
+ * @remarks
+ * {@link https://www.typescriptlang.org/docs/handbook/mixins.html#alternative-pattern}
+ *
+ * @param derivedCtor - The class to apply the mixins to.
+ * @param constructors - The constructors of the mixins.
+ */
+export declare function applyMixins(derivedCtor: any, constructors: any[]): void;

package/dist/src/document/reducer.d.ts

@@ -0,0 +1,16 @@
+import { BaseAction } from './actions/types';
+import { Action, Document, ImmutableStateReducer, ReducerOptions } from './types';
+import { SignalDispatch } from './signal';
+/**
+ * Base document reducer that wraps a custom document reducer and handles
+ * document-level actions such as undo, redo, prune, and set name.
+ *
+ * @template T - The type of the state of the custom reducer.
+ * @template A - The type of the actions of the custom reducer.
+ * @param state - The current state of the document.
+ * @param action - The action object to apply to the state.
+ * @param customReducer - The custom reducer that implements the application logic
+ * specific to the document's state.
+ * @returns The new state of the document.
+ */
+export declare function baseReducer<T, A extends Action, L>(document: Document<T, A, L>, action: A | BaseAction, customReducer: ImmutableStateReducer<T, A, L>, dispatch?: SignalDispatch, options?: ReducerOptions): Document<T, A, L>;

package/dist/src/document/schema/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export * as z from './zod';

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

@@ -0,0 +1,180 @@
+import { OperationScope } from '..';
+export type Maybe<T> = T | null;
+export type InputMaybe<T> = T | null | undefined;
+export type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]?: Maybe<T[SubKey]>;
+};
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]: Maybe<T[SubKey]>;
+};
+export type MakeEmpty<T extends {
+    [key: string]: unknown;
+}, K extends keyof T> = {
+    [_ in K]?: never;
+};
+export type Incremental<T> = T | {
+    [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never;
+};
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+    ID: {
+        input: string;
+        output: string;
+    };
+    String: {
+        input: string;
+        output: string;
+    };
+    Boolean: {
+        input: boolean;
+        output: boolean;
+    };
+    Int: {
+        input: number;
+        output: number;
+    };
+    Float: {
+        input: number;
+        output: number;
+    };
+    Address: {
+        input: `${string}:0x${string}`;
+        output: `${string}:0x${string}`;
+    };
+    Attachment: {
+        input: string;
+        output: string;
+    };
+    DateTime: {
+        input: string;
+        output: string;
+    };
+    Unknown: {
+        input: unknown;
+        output: unknown;
+    };
+};
+export type Action = IAction & {
+    __typename?: 'Action';
+    type: Scalars['String']['output'];
+};
+export type BaseAction = LoadStateAction | PruneAction | RedoAction | SetNameAction | UndoAction | NOOPAction;
+export type DocumentFile = {
+    __typename?: 'DocumentFile';
+    data: Scalars['String']['output'];
+    extension: Maybe<Scalars['String']['output']>;
+    fileName: Maybe<Scalars['String']['output']>;
+    mimeType: Scalars['String']['output'];
+};
+export type IAction = {
+    type: Scalars['String']['output'];
+};
+export type IDocument = {
+    created: Scalars['DateTime']['output'];
+    documentType: Scalars['String']['output'];
+    lastModified: Scalars['DateTime']['output'];
+    name: Scalars['String']['output'];
+    operations: Array<IOperation>;
+    revision: Scalars['Int']['output'];
+};
+export type IOperation = {
+    hash: Scalars['String']['output'];
+    index: Scalars['Int']['output'];
+    timestamp: Scalars['DateTime']['output'];
+    type: Scalars['String']['output'];
+};
+export type Load_State = 'LOAD_STATE';
+export type LoadStateAction = {
+    input: LoadStateActionInput;
+    type: Load_State | `${Load_State}`;
+    scope: OperationScope;
+};
+export type LoadStateActionInput = {
+    operations: Scalars['Int']['input'];
+    state: LoadStateActionStateInput;
+};
+export type LoadStateActionStateInput = {
+    data?: InputMaybe<Scalars['Unknown']['input']>;
+    name: Scalars['String']['input'];
+};
+export type Mutation = {
+    __typename?: 'Mutation';
+    loadState: Maybe<IDocument>;
+    prune: Maybe<IDocument>;
+    redo: Maybe<IDocument>;
+    setName: Maybe<IDocument>;
+    undo: Maybe<IDocument>;
+};
+export type MutationLoadStateArgs = {
+    input: LoadStateAction;
+};
+export type MutationPruneArgs = {
+    input: PruneAction;
+};
+export type MutationRedoArgs = {
+    input: RedoAction;
+};
+export type MutationSetNameArgs = {
+    input: SetNameAction;
+};
+export type MutationUndoArgs = {
+    input: UndoAction;
+};
+export type Operation = IOperation & {
+    __typename?: 'Operation';
+    hash: Scalars['String']['output'];
+    index: Scalars['Int']['output'];
+    timestamp: Scalars['DateTime']['output'];
+    type: Scalars['String']['output'];
+};
+export type Prune = 'PRUNE';
+export type PruneAction = {
+    input: PruneActionInput;
+    type: Prune | `${Prune}`;
+    scope: OperationScope;
+};
+export type PruneActionInput = {
+    end?: InputMaybe<Scalars['Int']['input']>;
+    start?: InputMaybe<Scalars['Int']['input']>;
+};
+export type Query = {
+    __typename?: 'Query';
+    document: Maybe<IDocument>;
+};
+export type Redo = 'REDO';
+export type RedoAction = {
+    input: Scalars['Int']['input'];
+    type: Redo | `${Redo}`;
+    scope: OperationScope;
+};
+export type Set_Name = 'SET_NAME';
+export type SetNameAction = {
+    input: Scalars['String']['input'];
+    type: Set_Name | `${Set_Name}`;
+    scope: 'global';
+};
+export type SetNameOperation = IOperation & {
+    __typename?: 'SetNameOperation';
+    hash: Scalars['String']['output'];
+    index: Scalars['Int']['output'];
+    input: Scalars['String']['output'];
+    timestamp: Scalars['DateTime']['output'];
+    type: Scalars['String']['output'];
+};
+export type Undo = 'UNDO';
+export type UndoAction = {
+    input: Scalars['Int']['input'];
+    type: Undo | `${Undo}`;
+    scope: OperationScope;
+};
+export type NOOP = 'NOOP';
+export type NOOPAction = {
+    input: Scalars['Unknown']['input'];
+    type: NOOP | `${NOOP}`;
+    scope: OperationScope;
+};