document-model 1.5.0 → 1.7.0

package/dist/browser/src/document/actions/creators.d.ts

@@ -44,5 +44,5 @@ export declare const prune: (start?: number | undefined, end?: number | undefine
  * @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>, 'state' | 'name'>, operations: number) => LoadStateAction;
+export declare const loadState: <S, T>(state: Pick<ExtendedState<S, T>, "state" | "name">, operations: number) => LoadStateAction;
 export declare const noop: (scope?: OperationScope) => NOOPAction;

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.
  *

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

@@ -61,7 +61,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>;
 /**

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

@@ -60,4 +60,5 @@ export declare function garbageCollectDocumentOperations<A extends Action>(docum
  * @returns An array of operations with duplicates filtered out.
  */
 export declare function filterDuplicatedOperations(targetOperations: Operation[], sourceOperations: Operation[]): Operation[];
+export declare function filterDocumentOperationsResultingState<A extends Action>(documentOperations?: DocumentOperations<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;