document-model 1.0.20 → 1.0.21

package/dist/node/document/actions/creators.d.ts

@@ -1,46 +0,0 @@
-import { ExtendedState, OperationScope } from '../types';
-import { LoadStateAction, PruneAction, RedoAction, SetNameAction, UndoAction } from './types';
-/**
- * Changes the name of the document.
- *
- * @param name - The name to be set in the document.
- * @category Actions
- */
-export declare const setName: (name: string) => SetNameAction;
-/**
- * Cancels the last `count` operations.
- *
- * @param count - Number of operations to cancel
- * @category Actions
- */
-export declare const undo: (count?: number, scope?: OperationScope) => UndoAction;
-/**
- * Cancels the last `count` {@link undo | UNDO} operations.
- *
- * @param count - Number of UNDO operations to cancel
- * @category Actions
- */
-export declare const redo: (count?: number, scope?: OperationScope) => RedoAction;
-/**
- * Joins multiple operations into a single {@link loadState | LOAD_STATE} operation.
- *
- * @remarks
- * Useful to keep operations history smaller. Operations to prune are selected by index,
- * similar to the {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice | slice} method in Arrays.
- *
- * @param start - Index of the first operation to prune
- * @param end - Index of the last operation to prune
- * @category Actions
- */
-export declare const prune: (start?: number | undefined, end?: number | undefined, scope?: OperationScope) => PruneAction;
-/**
- * Replaces the state of the document.
- *
- * @remarks
- * This action shouldn't be used directly. It is dispatched by the {@link prune} action.
- *
- * @param state - State to be set in the document.
- * @param operations - Number of operations that were removed from the previous state.
- * @category Actions
- */
-export declare const loadState: <S, T>(state: Pick<ExtendedState<S, T>, "name" | "state">, operations: number) => LoadStateAction;

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

@@ -1,10 +0,0 @@
-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/node/document/actions/types.d.ts

@@ -1,8 +0,0 @@
-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, } from '../types';
-export type { BaseAction };

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

@@ -1,6 +0,0 @@
-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/node/document/object.d.ts

@@ -1,391 +0,0 @@
-import type { BaseAction } from './actions/types';
-import type { SignalDispatch } from './signal';
-import type { Action, AttachmentRef, Document, ExtendedState, OperationScope, Reducer } 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): 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 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 input: number;
-            readonly type: "REDO";
-            readonly scope: OperationScope;
-            readonly index: number;
-            readonly timestamp: string;
-            readonly hash: string;
-        } | {
-            readonly input: string;
-            readonly type: "SET_NAME";
-            readonly scope: "global";
-            readonly index: number;
-            readonly timestamp: string;
-            readonly hash: string;
-        } | {
-            readonly input: number;
-            readonly type: "UNDO";
-            readonly scope: OperationScope;
-            readonly index: number;
-            readonly timestamp: string;
-            readonly hash: string;
-        } | import("immer").Immutable<A & {
-            index: number;
-            timestamp: string;
-            hash: string;
-        }>)[];
-        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 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 input: number;
-            readonly type: "REDO";
-            readonly scope: OperationScope;
-            readonly index: number;
-            readonly timestamp: string;
-            readonly hash: string;
-        } | {
-            readonly input: string;
-            readonly type: "SET_NAME";
-            readonly scope: "global";
-            readonly index: number;
-            readonly timestamp: string;
-            readonly hash: string;
-        } | {
-            readonly input: number;
-            readonly type: "UNDO";
-            readonly scope: OperationScope;
-            readonly index: number;
-            readonly timestamp: string;
-            readonly hash: string;
-        } | import("immer").Immutable<A & {
-            index: number;
-            timestamp: string;
-            hash: string;
-        }>)[];
-    };
-    /**
-     * 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 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 input: number;
-                readonly type: "REDO";
-                readonly scope: OperationScope;
-                readonly index: number;
-                readonly timestamp: string;
-                readonly hash: string;
-            } | {
-                readonly input: string;
-                readonly type: "SET_NAME";
-                readonly scope: "global";
-                readonly index: number;
-                readonly timestamp: string;
-                readonly hash: string;
-            } | {
-                readonly input: number;
-                readonly type: "UNDO";
-                readonly scope: OperationScope;
-                readonly index: number;
-                readonly timestamp: string;
-                readonly hash: string;
-            } | import("immer").Immutable<A & {
-                index: number;
-                timestamp: string;
-                hash: string;
-            }>)[];
-            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 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 input: number;
-                readonly type: "REDO";
-                readonly scope: OperationScope;
-                readonly index: number;
-                readonly timestamp: string;
-                readonly hash: string;
-            } | {
-                readonly input: string;
-                readonly type: "SET_NAME";
-                readonly scope: "global";
-                readonly index: number;
-                readonly timestamp: string;
-                readonly hash: string;
-            } | {
-                readonly input: number;
-                readonly type: "UNDO";
-                readonly scope: OperationScope;
-                readonly index: number;
-                readonly timestamp: string;
-                readonly hash: string;
-            } | import("immer").Immutable<A & {
-                index: number;
-                timestamp: string;
-                hash: string;
-            }>)[];
-        };
-        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/node/document/reducer.d.ts

@@ -1,16 +0,0 @@
-import { BaseAction } from './actions/types';
-import { Action, Document, ImmutableStateReducer } 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): Document<T, A, L>;

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

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

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

@@ -1,174 +0,0 @@
-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;
-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;
-};