document-model 1.0.51 → 1.0.53

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

@@ -1,32 +0,0 @@
-import { BaseAction } from './actions/types';
-import { UndoRedoAction } from './schema';
-import { Action, Document, ImmutableStateReducer, Operation, ReducerOptions } from './types';
-import { SignalDispatch } from './signal';
-type UndoRedoProcessResult<T, A extends Action, L> = {
-    document: Document<T, A, L>;
-    action: A | BaseAction;
-    skip: number;
-};
-/**
- * Processes an UNDO or REDO action.
- *
- * @param document The current state of the document.
- * @param action The action being applied to the document.
- * @param skip The number of operations to skip before applying the action.
- * @returns The updated document, calculated skip value and transformed action (if apply).
- */
-export declare function processUndoRedo<T, A extends Action, L>(document: Document<T, A, L>, action: UndoRedoAction, skip: number): UndoRedoProcessResult<T, A, L>;
-/**
- * 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 | Operation, customReducer: ImmutableStateReducer<T, A, L>, dispatch?: SignalDispatch, options?: ReducerOptions): Document<T, A, L>;
-export {};

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

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

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

@@ -1,176 +0,0 @@
-import { OperationScope } from '..';
-export type Maybe<T> = T | null;
-export type InputMaybe<T> = T | null | undefined;
-export type Exact<T extends Record<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 Record<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 UndoRedoAction = RedoAction | 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;
-    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;
-    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;
-    scope: OperationScope;
-};
-export type Set_Name = 'SET_NAME';
-export type SetNameAction = {
-    input: Scalars['String']['input'];
-    type: 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;
-    scope: OperationScope;
-};
-export type NOOP = 'NOOP';
-export type NOOPAction = {
-    input: Scalars['Unknown']['input'];
-    type: NOOP;
-    scope: OperationScope;
-};

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

@@ -1,113 +0,0 @@
-import { z } from 'zod';
-import { Action, DocumentFile, LoadStateAction, LoadStateActionInput, LoadStateActionStateInput, Operation, PruneAction, PruneActionInput, RedoAction, SetNameAction, SetNameOperation, UndoAction } from '.';
-import { OperationScope } from '../types';
-type Properties<T> = Required<{
-    [K in keyof T]: z.ZodType<T[K], any, T[K]>;
-}>;
-type definedNonNullAny = {};
-export declare const isDefinedNonNullAny: (v: any) => v is definedNonNullAny;
-export declare const definedNonNullAnySchema: z.ZodEffects<z.ZodAny, any, any>;
-export declare const Load_StateSchema: z.ZodEnum<["LOAD_STATE"]>;
-export declare const PruneSchema: z.ZodEnum<["PRUNE"]>;
-export declare const RedoSchema: z.ZodEnum<["REDO"]>;
-export declare const Set_NameSchema: z.ZodEnum<["SET_NAME"]>;
-export declare const UndoSchema: z.ZodEnum<["UNDO"]>;
-export declare function ActionSchema(): z.ZodObject<Properties<Action>>;
-export declare function OperationScopeSchema(): z.ZodType<OperationScope>;
-export declare function BaseActionSchema(): z.ZodUnion<[z.ZodObject<Required<{
-    input: z.ZodType<LoadStateActionInput, any, LoadStateActionInput>;
-    type: z.ZodType<"LOAD_STATE", any, "LOAD_STATE">;
-    scope: z.ZodType<OperationScope, any, OperationScope>;
-}>, z.UnknownKeysParam, z.ZodTypeAny, {
-    input: LoadStateActionInput;
-    type: "LOAD_STATE";
-    scope: "global" | "local";
-}, {
-    input: LoadStateActionInput;
-    type: "LOAD_STATE";
-    scope: "global" | "local";
-}>, z.ZodObject<Required<{
-    input: z.ZodType<PruneActionInput, any, PruneActionInput>;
-    type: z.ZodType<"PRUNE", any, "PRUNE">;
-    scope: z.ZodType<OperationScope, any, OperationScope>;
-}>, z.UnknownKeysParam, z.ZodTypeAny, {
-    input: PruneActionInput;
-    type: "PRUNE";
-    scope: "global" | "local";
-}, {
-    input: PruneActionInput;
-    type: "PRUNE";
-    scope: "global" | "local";
-}>, z.ZodObject<Required<{
-    input: z.ZodType<number, any, number>;
-    type: z.ZodType<"REDO", any, "REDO">;
-    scope: z.ZodType<OperationScope, any, OperationScope>;
-}>, z.UnknownKeysParam, z.ZodTypeAny, {
-    input: number;
-    type: "REDO";
-    scope: "global" | "local";
-}, {
-    input: number;
-    type: "REDO";
-    scope: "global" | "local";
-}>, z.ZodObject<Required<{
-    input: z.ZodType<string, any, string>;
-    type: z.ZodType<"SET_NAME", any, "SET_NAME">;
-    scope: z.ZodType<"global", any, "global">;
-}>, z.UnknownKeysParam, z.ZodTypeAny, {
-    input: string;
-    type: "SET_NAME";
-    scope: "global";
-}, {
-    input: string;
-    type: "SET_NAME";
-    scope: "global";
-}>, z.ZodObject<Required<{
-    input: z.ZodType<number, any, number>;
-    type: z.ZodType<"UNDO", any, "UNDO">;
-    scope: z.ZodType<OperationScope, any, OperationScope>;
-}>, z.UnknownKeysParam, z.ZodTypeAny, {
-    input: number;
-    type: "UNDO";
-    scope: "global" | "local";
-}, {
-    input: number;
-    type: "UNDO";
-    scope: "global" | "local";
-}>]>;
-export declare function DocumentFileSchema(): z.ZodObject<Properties<DocumentFile>>;
-export declare function LoadStateActionSchema(): z.ZodObject<Properties<LoadStateAction>>;
-export declare function LoadStateActionInputSchema(): z.ZodObject<Properties<LoadStateActionInput>>;
-export declare function LoadStateActionStateInputSchema(): z.ZodObject<Properties<LoadStateActionStateInput>>;
-export declare function OperationSchema(): z.ZodObject<Properties<Operation>>;
-export declare function PruneActionSchema(): z.ZodObject<Properties<PruneAction>>;
-export declare function PruneActionInputSchema(): z.ZodObject<Properties<PruneActionInput>>;
-export declare const RedoActionInputSchema: (params?: ({
-    errorMap?: z.ZodErrorMap | undefined;
-    invalid_type_error?: string | undefined;
-    required_error?: string | undefined;
-    description?: string | undefined;
-} & {
-    coerce?: boolean | undefined;
-}) | undefined) => z.ZodNumber;
-export declare function RedoActionSchema(): z.ZodObject<Properties<RedoAction>>;
-export declare const SetNameActionInputSchema: (params?: ({
-    errorMap?: z.ZodErrorMap | undefined;
-    invalid_type_error?: string | undefined;
-    required_error?: string | undefined;
-    description?: string | undefined;
-} & {
-    coerce?: true | undefined;
-}) | undefined) => z.ZodString;
-export declare function SetNameActionSchema(): z.ZodObject<Properties<SetNameAction>>;
-export declare function SetNameOperationSchema(): z.ZodObject<Properties<SetNameOperation>>;
-export declare const UndoActionInputSchema: (params?: ({
-    errorMap?: z.ZodErrorMap | undefined;
-    invalid_type_error?: string | undefined;
-    required_error?: string | undefined;
-    description?: string | undefined;
-} & {
-    coerce?: boolean | undefined;
-}) | undefined) => z.ZodNumber;
-export declare function UndoActionSchema(): z.ZodObject<Properties<UndoAction>>;
-export {};

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

@@ -1,29 +0,0 @@
-import { Document, OperationScope } from './types';
-export interface ISignal<T extends string = string, I = unknown> {
-    type: T;
-    input: I;
-}
-export type SynchronizationUnit = {
-    syncId: string;
-    scope: OperationScope;
-    branch: string;
-};
-export type CreateChildDocumentInput = {
-    id: string;
-    documentType: string;
-    document?: Document;
-    synchronizationUnits: SynchronizationUnit[];
-};
-export type CreateChildDocumentSignal = ISignal<'CREATE_CHILD_DOCUMENT', CreateChildDocumentInput>;
-export type DeleteChildDocumentInput = {
-    id: string;
-};
-export type DeleteChildDocumentSignal = ISignal<'DELETE_CHILD_DOCUMENT', DeleteChildDocumentInput>;
-export type CopyChildDocumentInput = {
-    id: string;
-    newId: string;
-    synchronizationUnits: SynchronizationUnit[];
-};
-export type CopyChildDocumentSignal = ISignal<'COPY_CHILD_DOCUMENT', CopyChildDocumentInput>;
-export type Signal = CreateChildDocumentSignal | DeleteChildDocumentSignal | CopyChildDocumentSignal;
-export type SignalDispatch = (signal: Signal) => void;

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

@@ -1,247 +0,0 @@
-import type { Draft } from 'immer';
-import type { FC } from 'react';
-import type { DocumentModelState } from '../document-model/';
-import type { BaseAction } from './actions/types';
-import { BaseDocument } from './object';
-import { FileInput } from './utils';
-import { SignalDispatch } from './signal';
-export { z } from './schema';
-export type * from './schema/types';
-export type { FileInput } from './utils';
-export type { Immutable } from 'immer';
-export type { BaseAction } from './actions/types';
-export type ActionSigner = {
-    user: {
-        address: string;
-        networkId: string;
-        chainId: number;
-    };
-    app: {
-        name: string;
-        key: string;
-    };
-    signature: string;
-};
-export type ActionContext = {
-    signer?: ActionSigner;
-};
-/**
- * Defines the basic structure of an action.
- *
- * @typeParam T - The name of the action type. A `string` type by default.
- */
-export type Action<T extends string = string, I = unknown, S extends OperationScope = OperationScope> = {
-    /** The name of the action. */
-    type: T;
-    /** The payload of the action. */
-    input: I;
-    /** The scope of the action, can either be 'global' or 'local' */
-    scope: S;
-    /** The attachments included in the action. */
-    attachments?: AttachmentInput[] | undefined;
-    /** The context of the action. */
-    context?: ActionContext;
-};
-export type ActionWithAttachment<T extends string = string, I = unknown, S extends OperationScope = OperationScope> = Action<T, I, S> & {
-    attachments: AttachmentInput[];
-};
-export type ReducerOptions = {
-    /** The number of operations to skip before this new action is applied */
-    skip?: number;
-    /** When true the skip count is ignored and the action is applied regardless of the skip count */
-    ignoreSkipOperations?: boolean;
-    /** if true reuses the provided action hash  */
-    reuseHash?: boolean;
-};
-/**
- * A pure function that takes an action and the previous state
- * of the document and returns the new state.
- *
- * @typeParam State - The type of the document data.
- * @typeParam A - The type of the actions supported by the reducer.
- */
-export type Reducer<State, A extends Action, LocalState> = (state: Document<State, A, LocalState>, action: A | BaseAction, dispatch?: SignalDispatch, options?: ReducerOptions) => Document<State, A, LocalState>;
-/**
- * A {@link Reducer} that prevents mutable code from changing the previous state.
- *
- * @remarks
- * This reducer is wrapped with {@link https://immerjs.github.io/immer/ | Immer}.
- * This allows the reducer code to be mutable, making it simpler and
- * avoiding unintended changes in the provided state.
- * The returned state will always be a new object.
- *
- * @typeParam State - The type of the document data.
- * @typeParam A - The type of the actions supported by the reducer.
- */
-export type ImmutableReducer<State, A extends Action, LocalState> = (state: Draft<Document<State, A, LocalState>>, action: A | BaseAction, dispatch?: SignalDispatch) => Document<State, A, LocalState> | undefined;
-export type ImmutableStateReducer<S, A extends Action, L = unknown> = (state: Draft<State<S, L>>, action: A, dispatch?: SignalDispatch) => State<S, L> | undefined;
-/**
- * Scope of an operation.
- * Global: The operation is synchronized everywhere in the network. This is the default document operation.
- * Local: The operation is applied only locally (to a local state). Used for local settings such as a drive's local path
- */
-export type OperationScope = 'global' | 'local';
-/**
- * An operation that was applied to a {@link Document}.
- *
- * @remarks
- * Wraps an action with an index, to be added to the operations history of a Document.
- * The `index` field is used to keep all operations in order and enable replaying the
- * document's history from the beginning.
- *
- * @typeParam A - The type of the action.
- */
-export type Operation<A extends Action = Action> = A & {
-    /** Position of the operation in the history */
-    index: number;
-    /** Timestamp of when the operation was added */
-    timestamp: string;
-    /** Hash of the resulting document data after the operation */
-    hash: string;
-    /** The number of operations skipped with this Operation */
-    skip: number;
-};
-/**
- * The base attributes of a {@link Document}.
- */
-export type DocumentHeader = {
-    /** The name of the document. */
-    name: string;
-    /** The number of operations applied to the document. */
-    revision: Required<Record<OperationScope, number>>;
-    /** The type of the document model. */
-    documentType: string;
-    /** The timestamp of the creation date of the document. */
-    created: string;
-    /** The timestamp of the last change in the document. */
-    lastModified: string;
-};
-/**
- * The attributes stored for a file. Namely, attachments of a document.
- */
-export type Attachment = {
-    /** The binary data of the attachment in Base64 */
-    data: string;
-    /** The MIME type of the attachment */
-    mimeType: string;
-    extension?: string | null;
-    fileName?: string | null;
-};
-export type AttachmentInput = Attachment & {
-    hash: string;
-};
-/**
- * Object that indexes attachments of a Document.
- *
- * @remarks
- * This is used to reduce memory usage to avoid
- * multiple instances of the binary data of the attachments.
- *
- */
-export type FileRegistry = Record<AttachmentRef, Attachment>;
-export type State<GlobalState, LocalState> = {
-    global: GlobalState;
-    local: LocalState;
-};
-export type PartialState<S> = S | Partial<S>;
-export type CreateState<S, L> = (state?: Partial<State<PartialState<S>, PartialState<L>>>) => State<S, L>;
-export type ExtendedState<GlobalState, LocalState = unknown> = DocumentHeader & {
-    /** The document model specific state. */
-    state: State<GlobalState, LocalState>;
-    /** The index of document attachments. */
-    attachments: FileRegistry;
-};
-export type DocumentOperations<A extends Action> = Required<Record<OperationScope, Operation<A | BaseAction>[]>>;
-export type MappedOperation<A extends Action> = {
-    ignore: boolean;
-    operation: Operation<A | BaseAction>;
-};
-export type DocumentOperationsIgnoreMap<A extends Action> = Required<Record<OperationScope, MappedOperation<A>[]>>;
-/**
- * The base type of a document model.
- *
- * @remarks
- * This type is extended by all Document models.
- *
- * @typeParam Data - The type of the document data attribute.
- * @typeParam A - The type of the actions supported by the Document.
- */
-export type Document<GlobalState = unknown, A extends Action = Action, LocalState = unknown> = 
-/** The document model specific state. */
-ExtendedState<GlobalState, LocalState> & {
-    /** The operations history of the document. */
-    operations: DocumentOperations<A>;
-    /** The initial state of the document, enabling replaying operations. */
-    initialState: ExtendedState<GlobalState, LocalState>;
-    /** A list of undone operations */
-    clipboard: Operation<BaseAction | A>[];
-};
-/**
- * String type representing an attachment in a Document.
- *
- * @remarks
- * Attachment string is formatted as `attachment://<filename>`.
- */
-export type AttachmentRef = string;
-export interface DocumentClass<S, A extends Action = Action, L = unknown, C extends BaseDocument<S, A, L> = BaseDocument<S, A, L>> {
-    fileExtension: string;
-    fromFile: (path: string) => Promise<C>;
-    new (initialState?: ExtendedState<S, L>): C;
-}
-export type DocumentModelUtils<S = unknown, A extends Action = Action, L = unknown> = {
-    fileExtension: string;
-    createState: CreateState<S, L>;
-    createExtendedState: (extendedState?: Partial<ExtendedState<PartialState<S>, PartialState<L>>>, createState?: CreateState<S, L>) => ExtendedState<S, L>;
-    createDocument: (document?: Partial<ExtendedState<PartialState<S>, PartialState<L>>>, createState?: CreateState<S, L>) => Document<S, A, L>;
-    loadFromFile: (path: string) => Promise<Document<S, A, L>>;
-    loadFromInput: (input: FileInput) => Promise<Document<S, A, L>>;
-    saveToFile: (document: Document<S, A, L>, path: string, name?: string) => Promise<string>;
-    saveToFileHandle: (document: Document<S, A, L>, input: FileSystemFileHandle) => Promise<void>;
-};
-export type ActionCreator<A extends Action> = ((input: any) => A) | ((input: any, attachments: AttachmentInput[]) => A) | ((...input: any) => BaseAction);
-export type DocumentModel<S = unknown, A extends Action = Action, L = unknown, C extends BaseDocument<S, A, L> = BaseDocument<S, A, L>> = {
-    Document: DocumentClass<S, A, L, C>;
-    reducer: Reducer<S, A, L>;
-    actions: Record<string, ActionCreator<A>>;
-    utils: DocumentModelUtils<S, A, L>;
-    documentModel: DocumentModelState;
-};
-export type ENSInfo = {
-    name?: string;
-    avatarUrl?: string;
-};
-export type User = {
-    address: `0x${string}`;
-    networkId: string;
-    chainId: number;
-    ens?: ENSInfo;
-};
-export type EditorContext = {
-    theme: 'light' | 'dark';
-    debug?: boolean;
-    user?: User;
-};
-export type ActionErrorCallback = (error: unknown) => void;
-export type EditorProps<S, A extends Action, L> = {
-    document: Document<S, A, L>;
-    dispatch: (action: A | BaseAction, onErrorCallback?: ActionErrorCallback) => void;
-    context: EditorContext;
-    error?: unknown;
-};
-export type Editor<S = unknown, A extends Action = Action, L = unknown> = {
-    Component: FC<EditorProps<S, A, L>>;
-    documentTypes: string[];
-};
-export type DocumentModelLib = {
-    documentModels: DocumentModel[];
-    editors: Editor[];
-};
-export type UndoRedoProcessResult<T, A extends Action, L> = {
-    document: Document<T, A, L>;
-    action: A | BaseAction;
-    skip: number;
-};
-export type ValidationError = {
-    message: string;
-    details: object;
-};