document-model 1.6.0 → 1.8.0

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

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { Action, DocumentFile, LoadStateAction, LoadStateActionInput, LoadStateActionStateInput, Operation, PruneAction, PruneActionInput, RedoAction, SetNameAction, SetNameOperation, UndoAction } from '.';
+import { Action, DocumentFile, Load_State, LoadStateAction, LoadStateActionInput, LoadStateActionStateInput, Operation, Prune, PruneAction, PruneActionInput, Redo, RedoAction, Set_Name, SetNameAction, SetNameOperation, Undo, UndoAction } from '.';
 import { OperationScope } from '../types';
 
 type Properties<T> = Required<{
@@ -7,7 +7,7 @@ type Properties<T> = Required<{
 }>;
 type definedNonNullAny = {};
 export declare const isDefinedNonNullAny: (v: any) => v is definedNonNullAny;
-export declare const definedNonNullAnySchema: z.ZodEffects<z.ZodAny, any, any>;
+export declare const definedNonNullAnySchema: z.ZodEffects<z.ZodAny, definedNonNullAny, any>;
 export declare const Load_StateSchema: z.ZodEnum<["LOAD_STATE"]>;
 export declare const PruneSchema: z.ZodEnum<["PRUNE"]>;
 export declare const RedoSchema: z.ZodEnum<["REDO"]>;
@@ -21,11 +21,11 @@ export declare function BaseActionSchema(): z.ZodUnion<[z.ZodObject<Required<{
     scope: z.ZodType<OperationScope, any, OperationScope>;
 }>, z.UnknownKeysParam, z.ZodTypeAny, {
     input: LoadStateActionInput;
-    type: "LOAD_STATE";
+    type: Load_State;
     scope: OperationScope;
 }, {
     input: LoadStateActionInput;
-    type: "LOAD_STATE";
+    type: Load_State;
     scope: OperationScope;
 }>, z.ZodObject<Required<{
     input: z.ZodType<PruneActionInput, any, PruneActionInput>;
@@ -33,47 +33,47 @@ export declare function BaseActionSchema(): z.ZodUnion<[z.ZodObject<Required<{
     scope: z.ZodType<OperationScope, any, OperationScope>;
 }>, z.UnknownKeysParam, z.ZodTypeAny, {
     input: PruneActionInput;
-    type: "PRUNE";
+    type: Prune;
     scope: OperationScope;
 }, {
     input: PruneActionInput;
-    type: "PRUNE";
+    type: Prune;
     scope: OperationScope;
 }>, 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";
+    input: import('./types').Scalars["Int"]["input"];
+    type: Redo;
     scope: OperationScope;
 }, {
-    input: number;
-    type: "REDO";
+    input: import('./types').Scalars["Int"]["input"];
+    type: Redo;
     scope: OperationScope;
 }>, 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";
+    input: import('./types').Scalars["String"]["input"];
+    type: Set_Name;
     scope: "global";
 }, {
-    input: string;
-    type: "SET_NAME";
+    input: import('./types').Scalars["String"]["input"];
+    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";
+    input: import('./types').Scalars["Int"]["input"];
+    type: Undo;
     scope: OperationScope;
 }, {
-    input: number;
-    type: "UNDO";
+    input: import('./types').Scalars["Int"]["input"];
+    type: Undo;
     scope: OperationScope;
 }>]>;
 export declare function DocumentFileSchema(): z.ZodObject<Properties<DocumentFile>>;

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

@@ -11,6 +11,7 @@ export type * from './schema/types';
 export type { FileInput } from './utils';
 export type { BaseAction } from './actions/types';
 export type { Immutable } from 'mutative';
+export type Signature = [string, string, string, string, string];
 export type ActionSigner = {
     user: {
         address: string;
@@ -21,7 +22,7 @@ export type ActionSigner = {
         name: string;
         key: string;
     };
-    signature: string;
+    signatures: Signature[];
 };
 export type ActionContext = {
     signer?: ActionSigner;
@@ -170,6 +171,16 @@ export type MappedOperation<A extends Action> = {
     operation: Operation<A | BaseAction>;
 };
 export type DocumentOperationsIgnoreMap<A extends Action> = Required<Record<OperationScope, MappedOperation<A>[]>>;
+export type OperationSignatureContext = {
+    documentId: string;
+    signer: Omit<ActionSigner, 'signatures'> & {
+        signatures?: Signature[];
+    };
+    operation: Operation;
+    previousStateHash: string;
+};
+export type OperationSigningHandler = (message: Uint8Array) => Promise<Uint8Array>;
+export type OperationVerificationHandler = (publicKey: string, signature: Uint8Array, data: Uint8Array) => Promise<boolean>;
 /**
  * The base type of a document model.
  *
@@ -253,6 +264,7 @@ export type UndoRedoProcessResult<T, A extends Action, L> = {
     document: Document<T, A, L>;
     action: A | BaseAction;
     skip: number;
+    reuseLastOperationIndex: boolean;
 };
 export type ValidationError = {
     message: string;

package/dist/browser/src/document/utils/base.d.ts

@@ -1,9 +1,10 @@
 import { baseReducer, mutableBaseReducer } from '../reducer';
-import { Action, BaseAction, UndoRedoAction, Document, ExtendedState, ImmutableStateReducer, Reducer, OperationScope, State, CreateState, PartialState, DocumentOperations, DocumentHeader, DocumentOperationsIgnoreMap, Operation, MappedOperation, ReducerOptions } from '../types';
+import { Action, BaseAction, UndoRedoAction, Document, ExtendedState, ImmutableStateReducer, Reducer, OperationScope, State, CreateState, PartialState, DocumentOperations, DocumentHeader, DocumentOperationsIgnoreMap, Operation, MappedOperation, ReducerOptions, UndoAction } from '../types';
 import { SignalDispatch } from '../signal';
 
 export declare function isNoopOperation(op: Partial<Operation>): boolean;
 export declare function isUndoRedo(action: Action): action is UndoRedoAction;
+export declare function isUndo(action: Action): action is UndoAction;
 export declare function isBaseAction(action: Action): action is BaseAction;
 /**
  * Helper function to be used by action creators.
@@ -61,7 +62,7 @@ export declare const createExtendedState: <S, L>(initialState?: Partial<Extended
  * @returns The new document state.
  */
 export declare const createDocument: <S, A extends Action, L = unknown>(initialState?: Partial<ExtendedState<PartialState<S>, PartialState<L>>>, createState?: (state?: Partial<State<PartialState<S>, PartialState<L>>>) => State<S, L>) => Document<S, A, L>;
-export declare const hashDocument: (document: Pick<Document, 'state'>, scope?: OperationScope) => string;
+export declare const hashDocument: (document: Pick<Document, "state">, scope?: OperationScope) => string;
 export declare const hashKey: (date?: Date, randomLimit?: number) => string;
 export declare function readOnly<T>(value: T): Readonly<T>;
 /**
@@ -73,7 +74,6 @@ export declare function readOnly<T>(value: T): Readonly<T>;
  * @throws Error if the operation index is invalid and there are missing operations.
  */
 export declare function mapSkippedOperations<A extends Action>(operations: Operation<BaseAction | A>[], skippedHeadOperations?: number): MappedOperation<A>[];
-export declare function calculateSkipsLeft<A extends Action>(operations: Operation<BaseAction | A>[], currentIndex: number, skip: number): number;
 export declare function sortOperations<A extends Action>(operations: DocumentOperations<A>): Operation<BaseAction | A>[];
 export declare function sortMappedOperations<A extends Action>(operations: DocumentOperationsIgnoreMap<A>): MappedOperation<A>[];
 export declare function replayOperations<T, A extends Action, L>(initialState: ExtendedState<T, L>, clearedOperations: DocumentOperations<A>, reducer: ImmutableStateReducer<T, A, L>, dispatch?: SignalDispatch, header?: DocumentHeader, documentReducer?: typeof baseReducer, skipHeaderOperations?: SkipHeaderOperations, options?: ReducerOptions): Document<T, A, L>;

package/dist/browser/src/document/utils/crypto.d.ts

@@ -0,0 +1,10 @@
+import { Action, ActionSigner, BaseAction, Document, Operation, OperationSignatureContext, OperationSigningHandler, OperationVerificationHandler, Reducer, Signature } from '../types';
+
+export declare function getUnixTimestamp(date: Date | string): string;
+export declare function buildOperationSignatureParams({ documentId, signer, operation, previousStateHash, }: OperationSignatureContext): [string, string, string, string];
+export declare function buildOperationSignatureMessage(params: [string, string, string, string]): Uint8Array;
+export declare function ab2hex(ab: ArrayBuffer): string;
+export declare function hex2ab(hex: string): Uint8Array;
+export declare function buildOperationSignature(context: OperationSignatureContext, signMethod: OperationSigningHandler): Promise<Signature>;
+export declare function buildSignedOperation<T, A extends Action, L>(action: A | Operation<A>, reducer: Reducer<T, A, L>, document: Document<T, A, L>, context: Omit<OperationSignatureContext, 'operation' | 'previousStateHash'>, signHandler: OperationSigningHandler): Promise<Operation<A | BaseAction>>;
+export declare function verifyOperationSignature<T, A extends Action, L>(signature: Signature, signer: Omit<ActionSigner, 'signatures'>, verifyHandler: OperationVerificationHandler): Promise<boolean>;

package/dist/browser/src/document/utils/document-helpers.d.ts

@@ -61,4 +61,14 @@ export declare function garbageCollectDocumentOperations<A extends Action>(docum
  */
 export declare function filterDuplicatedOperations(targetOperations: Operation[], sourceOperations: Operation[]): Operation[];
 export declare function filterDocumentOperationsResultingState<A extends Action>(documentOperations?: DocumentOperations<A>): {};
+/**
+ * Calculates the difference between two arrays of operations.
+ * Returns an array of operations that are present in `clearedOperationsA` but not in `clearedOperationsB`.
+ *
+ * @template A - The type of the operations.
+ * @param {A[]} clearedOperationsA - The first array of operations.
+ * @param {A[]} clearedOperationsB - The second array of operations.
+ * @returns {A[]} - The difference between the two arrays of operations.
+ */
+export declare function diffOperations<A extends OperationIndex>(clearedOperationsA: A[], clearedOperationsB: A[]): A[];
 export {};

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

@@ -1,5 +1,6 @@
 export * from './base';
 export { createAction, createDocument, createExtendedState, createReducer, hashDocument, hashKey, isBaseAction, mapSkippedOperations, parseResultingState, readOnly, replayDocument, replayOperations, sortMappedOperations, sortOperations, } from './base';
+export * from './crypto';
 export * from './file';
 export * from './validation';
 export * as documentHelpers from './document-helpers';

package/dist/browser/src/document/utils/node.d.ts

@@ -1,4 +1,5 @@
-/// <reference types="node" />
+import { default as crypto } from 'crypto';
+
 export declare function writeFile(path: string, name: string, data: Uint8Array): Promise<string>;
 export declare function readFile(path: string): Buffer;
 export declare function fetchFile(url: string): Promise<{
@@ -6,4 +7,4 @@ export declare function fetchFile(url: string): Promise<{
     mimeType?: string;
 }>;
 export declare const getFile: (file: string) => Promise<Buffer>;
-export declare const hash: (data: string, algorithm?: string) => string;
+export declare const hash: (data: crypto.BinaryLike, algorithm?: string) => string;