@fileverse-dev/ddoc 3.0.69-rtc-patch-3 → 3.0.70

package/dist/package/sync-local/types/index.d.ts

@@ -1,176 +1,130 @@
-import { Data, IDocCollabUsers } from '../../types';
+import { Data } from '../../types';
+import { SocketClient } from '../socketClient';
 
 import * as Y from 'yjs';
-/** Connection identity — changes to these trigger reconnect */
-export interface CollabConnectionConfig {
-    roomKey: string;
-    roomId: string;
-    wsUrl: string;
-    isOwner: boolean;
-    ownerEdSecret?: string;
-    contractAddress?: string;
-    ownerAddress?: string;
-    roomInfo?: {
-        documentTitle: string;
-        portalAddress: string;
-        commentKey: string;
-    };
-}
-/** Session metadata — changes to these update awareness, NOT reconnect */
-export interface CollabSessionMeta {
+export interface IRoomMember {
+    userId: string;
     username: string;
-    isEns?: boolean;
-}
-/** Storage integrations the sync engine depends on */
-export interface CollabServices {
-    commitToStorage?: (file: File) => Promise<string>;
-    fetchFromStorage?: (cid: string) => Promise<any>;
+    role: 'owner' | 'editor';
 }
-export type CollabErrorCode = 'CONNECTION_FAILED' | 'AUTH_FAILED' | 'SYNC_FAILED' | 'TIMEOUT' | 'UNKNOWN';
-export type CollabError = {
-    code: CollabErrorCode;
-    message: string;
-    recoverable: boolean;
-};
-export type CollabStatus = 'idle' | 'connecting' | 'syncing' | 'ready' | 'reconnecting' | 'error' | 'terminated';
-export type CollabState = {
-    status: 'idle';
-} | {
-    status: 'connecting';
-} | {
-    status: 'syncing';
-    hasUnmergedPeerUpdates: boolean;
-} | {
-    status: 'ready';
-} | {
-    status: 'reconnecting';
-    attempt: number;
-    maxAttempts: number;
-} | {
-    status: 'error';
-    error: CollabError;
-} | {
-    status: 'terminated';
-    reason?: string;
-};
-export type CollabEvent = {
-    type: 'CONNECT';
-} | {
-    type: 'AUTH_SUCCESS';
-} | {
-    type: 'SYNC_COMPLETE';
-} | {
-    type: 'SET_UNMERGED_UPDATES';
-    hasUpdates: boolean;
-} | {
-    type: 'SOCKET_DROPPED';
-} | {
-    type: 'RECONNECTED';
-} | {
-    type: 'RETRY_EXHAUSTED';
-} | {
-    type: 'ERROR';
-    error: CollabError;
-} | {
-    type: 'SESSION_TERMINATED';
-    reason?: string;
-} | {
-    type: 'RESET';
-};
-export interface CollabContext {
-    hasUnmergedPeerUpdates: boolean;
-    reconnectAttempt: number;
-    maxReconnectAttempts: number;
-    error: CollabError | null;
-    terminationReason?: string;
+export interface SendUpdateResponse {
+    data: {
+        agent_id: string;
+        commitCid: string | null;
+        created_at: number;
+        data: string;
+        documentId: string;
+        id: string;
+        update_snapshot_ref: string | null;
+        updateType: string;
+    };
+    is_handshake_response: boolean;
+    status: boolean;
+    statusCode: number;
 }
-/** Event callbacks the consumer reacts to */
-export interface CollabCallbacks {
-    onStateChange?: (state: CollabState) => void;
-    onError?: (error: CollabError) => void;
-    onCollaboratorsChange?: (collaborators: IDocCollabUsers[]) => void;
-    onHandshakeData?: (data: {
-        data: AckResponse;
-        roomKey: string;
-    }) => void;
+export interface CommitResponse {
+    data: {
+        agent_id: string;
+        cid: string;
+        created_at: number;
+        data: any | null;
+        documentId: string;
+        updates: string[];
+    };
+    is_handshake_response: boolean;
+    status: boolean;
+    statusCode: number;
 }
-/** Discriminated union — TypeScript enforces config+services only when enabled */
-export type CollaborationProps = {
-    enabled: false;
-} | {
-    enabled: true;
-    connection: CollabConnectionConfig;
-    session: CollabSessionMeta;
-    services: CollabServices;
-    on?: CollabCallbacks;
-};
-export interface SyncManagerConfig {
+export interface SyncMachineContext {
     ydoc: Y.Doc;
-    services?: CollabServices;
-    callbacks?: CollabCallbacks;
+    socketClient: SocketClient | null;
+    roomId: string;
+    username: string;
+    roomMembers: IRoomMember[];
+    isConnected: boolean;
+    awareness: any;
+    _awarenessUpdateHandler: (({ added, updated, removed, }: {
+        added: number[];
+        updated: number[];
+        removed: number[];
+    }) => void) | null;
+    onError: ((e: Error) => void) | null;
+    roomKey: string;
+    wsUrl: string;
+    uncommittedUpdatesIdList: string[];
+    isOwner: boolean;
+    updateQueue: Uint8Array[];
+    isReady: boolean;
+    isNewDoc: boolean;
+    contentTobeAppliedQueue: string[];
+    initialUpdate: string | null;
+    errorCount: number;
+    errorMaxRetryCount: number;
+    errorMessage: string;
+    initalDocumentDecryptionState: 'done' | 'pending';
+    onCollaborationConnectCallback: (response: any) => void;
+    onCollaborationCommit: (file: File) => Promise<string>;
+    onFetchCommitContent: (cid: string) => Promise<any>;
+    onSessionTerminated: () => void;
+    onUnMergedUpdates: (state: boolean) => void;
     onLocalUpdate?: (updatedDocContent: Data['editorJSONData'], updateChunk: string) => void;
 }
-export declare enum ServerErrorCode {
-    AUTH_TOKEN_MISSING = "AUTH_TOKEN_MISSING",
-    AUTH_TOKEN_INVALID = "AUTH_TOKEN_INVALID",
-    SESSION_NOT_FOUND = "SESSION_NOT_FOUND",
-    SESSION_TERMINATED = "SESSION_TERMINATED",
-    SESSION_DID_MISSING = "SESSION_DID_MISSING",
-    DOCUMENT_ID_MISSING = "DOCUMENT_ID_MISSING",
-    UPDATE_DATA_MISSING = "UPDATE_DATA_MISSING",
-    COMMIT_UNAUTHORIZED = "COMMIT_UNAUTHORIZED",
-    COMMIT_MISSING_DATA = "COMMIT_MISSING_DATA",
-    INVALID_ADDRESS = "INVALID_ADDRESS",
-    NOT_AUTHENTICATED = "NOT_AUTHENTICATED",
-    DB_ERROR = "DB_ERROR",
-    INTERNAL_ERROR = "INTERNAL_ERROR"
+export interface ErrorResponseMessage {
+    status: boolean;
+    statusCode: number;
+    seqId: string | null;
+    is_handshake_response: boolean;
+    err: string;
+    err_detail: {
+        [key: string]: any;
+    } | null;
 }
-export interface AckResponse<T = Record<string, any>> {
+export interface SuccessResponseMessage {
     status: boolean;
     statusCode: number;
-    data?: T;
-    error?: string;
-    errorCode?: ServerErrorCode;
+    seqId: string | null;
+    is_handshake_response: boolean;
+    data: {
+        [key: string]: any;
+    };
 }
-export interface SendUpdateResponse extends AckResponse<{
-    id: string;
-    documentId: string;
-    data: string;
-    updateType: string;
-    commitCid: string | null;
-    createdAt: number;
-}> {
+export interface EventMessage {
+    type: string;
+    event_type: string;
+    event: {
+        data: any;
+        roomId: string;
+    };
 }
-export interface CommitResponse extends AckResponse<{
-    cid: string;
-    createdAt: number;
-    documentId: string;
-    updates: string[];
-}> {
+export type RequestResponse = ErrorResponseMessage | SuccessResponseMessage;
+export type OnMessagePayloadType = RequestResponse | EventMessage;
+export type EventHandler = (message: EventMessage) => void;
+export type DisconnectHandler = (e: CloseEvent | ErrorEvent) => void;
+export type ConnectHandler = () => void;
+export interface PartialRequest {
+    cmd: string;
+    args: {
+        [key: string]: any;
+    };
 }
+export interface RequestPayload extends PartialRequest {
+    seqId: string;
+}
+export type SequenceResponseCB = (data: RequestResponse) => void;
+export interface SequenceToRequestMapValue {
+    callback: SequenceResponseCB;
+}
+export type SequenceToRequestMap = {
+    [key: string]: SequenceToRequestMapValue;
+};
+export type Update = Uint8Array;
 export interface ISocketInitConfig {
-    onHandshakeSuccess: () => void;
-    onDisconnect: () => void;
-    onSocketDropped: () => void;
+    onConnect: ConnectHandler;
+    onDisconnect: DisconnectHandler;
     onError: (err: Error) => void;
-    onHandShakeError: (err: Error, statusCode?: number) => void;
-    onContentUpdate: (data: {
-        id: string;
-        data: string;
-        createdAt: number;
-        roomId: string;
-    }) => void;
-    onMembershipChange: (data: {
-        action: string;
-        user: {
-            role: string;
-        };
-        roomId: string;
-    }) => void;
-    onSessionTerminated: (data: {
-        roomId: string;
-    }) => void;
-    onReconnectFailed: () => void;
+    onWsEvent: EventHandler;
+    onHandShakeError: (err: Error) => void;
+    roomId: string;
 }
 export declare enum SocketStatusEnum {
     CLOSED = "CLOSED",
@@ -184,6 +138,19 @@ export interface RoomMember {
     userId: string;
     role: 'owner' | 'editor';
 }
+export type IAesKey = string;
+export type SyncMachinEvent = {
+    type: string;
+    data: any;
+};
+export interface IpfsUploadResponse {
+    ipfsUrl: string;
+    ipfsHash: string;
+    ipfsStorage: string;
+    cachedUrl: string;
+    fileSize: number;
+    mimetype: string;
+}
 export interface IAuthArgs {
     collaborationToken: string;
     documentId: string;

package/dist/package/sync-local/useSyncMachine.d.ts

@@ -0,0 +1,38 @@
+import { SyncMachineContext } from '.';
+
+export interface IConnectConf {
+    username?: string;
+    roomKey: string;
+    roomId: string;
+    isOwner: boolean;
+    ownerEdSecret?: string;
+    contractAddress?: string;
+    ownerAddress?: string;
+    isEns?: boolean;
+    wsUrl: string;
+    roomInfo?: {
+        documentTitle: string;
+        portalAddress: string;
+        commentKey: string;
+    };
+}
+export declare const useSyncMachine: (config: Partial<SyncMachineContext>) => {
+    connect: (connectConfig: IConnectConf) => void;
+    disconnect: () => void;
+    isConnected: any;
+    isReady: boolean;
+    error: any;
+    terminateSession: () => void;
+    awareness: any;
+    hasCollabContentInitialised: boolean;
+    state: import('xstate').State<SyncMachineContext, {
+        type: string;
+        data: any;
+    }, any, {
+        value: any;
+        context: SyncMachineContext;
+    }, import('xstate').ResolveTypegenMeta<import('xstate').TypegenDisabled, {
+        type: string;
+        data: any;
+    }, import('xstate').BaseActionObject, import('xstate').ServiceMap>>;
+};

package/dist/package/sync-local/utils/createAwarenessUpdateHandler.d.ts

@@ -1,8 +1,8 @@
 import { Awareness } from 'y-protocols/awareness';
-import { SocketClient } from '../socketClient';
+import { SyncMachineContext } from '../types';
 
-export declare const createAwarenessUpdateHandler: (awareness: Awareness, socketClient: SocketClient, roomKey: string) => ({ added, updated, removed, }: {
+export declare const createAwarenessUpdateHandler: (awareness: Awareness, context: SyncMachineContext) => ({ added, updated, removed, }: {
     added: number[];
     updated: number[];
     removed: number[];
-}, origin: any) => void;
+}) => void;

package/dist/package/types.d.ts

@@ -4,9 +4,7 @@ import { EditorProps } from '@tiptap/pm/view';
 import { Editor } from '@tiptap/react';
 import { default as React, SetStateAction } from 'react';
 import { IComment } from './extensions/comment';
-import { CollaborationProps } from './sync-local/types';
 
-export type { CollaborationProps, CollabConnectionConfig, CollabSessionMeta, CollabServices, CollabCallbacks, CollabState, CollabError, CollabErrorCode, CollabStatus, } from './sync-local/types';
 export declare const DdocEditorProps: EditorProps;
 export interface IDocCollabUsers {
     clientId: number;
@@ -115,7 +113,7 @@ export interface DdocProps extends CommentAccountProps {
     extensions?: Record<string, Extension | any>;
     selectedTags?: TagType[];
     setSelectedTags?: React.Dispatch<SetStateAction<TagType[]>>;
-    collaboration?: CollaborationProps;
+    enableCollaboration?: boolean | undefined;
     setIsCommentSectionOpen?: React.Dispatch<SetStateAction<boolean>>;
     inlineCommentData?: InlineCommentData;
     setInlineCommentData?: React.Dispatch<React.SetStateAction<InlineCommentData>>;
@@ -126,6 +124,7 @@ export interface DdocProps extends CommentAccountProps {
     setIsNavbarVisible: React.Dispatch<SetStateAction<boolean>>;
     editorCanvasClassNames?: string;
     isCommentSectionOpen?: boolean;
+    collaborationId?: string;
     isPreviewMode: boolean;
     ensResolutionUrl?: string;
     ipfsImageUploadFn?: (file: File) => Promise<IpfsImageUploadResponse>;
@@ -176,11 +175,24 @@ export interface DdocProps extends CommentAccountProps {
     activeModel?: CustomModel;
     maxTokens?: number;
     isAIAgentEnabled?: boolean;
+    collaborationKey?: CryptoKey | null;
+    collaborationKeyPair?: {
+        publicKey: string;
+        privateKey: string;
+    };
+    collabConfig?: ICollaborationConfig;
     /**
      * Document styling configuration
      * @description Customize the appearance of the document editor
      */
     documentStyling?: DocumentStyling;
+    onCollaborationConnectCallback?: (response: any) => void;
+    onCollaborationCommit?: (file: File) => Promise<string>;
+    onFetchCommitContent?: (cid: string) => Promise<any>;
+    onCollabSessionTermination?: () => void;
+    onUnMergedUpdates?: (state: boolean) => void;
+    onCollabError?: (error: any) => void;
+    isExistingCollabSession?: boolean;
     /**
      * Callback when IndexedDB initialization fails
      * @description Called when the IndexedDB persistence provider fails to initialize (e.g., private browsing, quota exceeded, corrupted DB). The editor will continue to function without local persistence.
@@ -217,3 +229,19 @@ export interface IpfsImageFetchPayload {
     mimeType: string;
     authTag: string;
 }
+export interface ICollaborationConfig {
+    roomKey: string;
+    collaborationId: string;
+    username: string;
+    isOwner: boolean;
+    ownerEdSecret?: string;
+    contractAddress?: string;
+    ownerAddress?: string;
+    wsUrl: string;
+    isEns?: boolean;
+    roomInfo?: {
+        documentTitle: string;
+        portalAddress: string;
+        commentKey: string;
+    };
+}

package/dist/package/use-ddoc-editor.d.ts

@@ -1,9 +1,9 @@
 import { DdocProps } from './types';
 import { Editor } from '@tiptap/react';
 
-export declare const useDdocEditor: ({ isPreviewMode, initialContent, versionHistoryState, collaboration, onChange, onCollaboratorChange, onCommentInteraction, onError, setCharacterCount, setWordCount, ipfsImageUploadFn, ddocId, enableIndexeddbSync, unFocused, theme, zoomLevel, onInvalidContentError, ignoreCorruptedData, isPresentationMode, metadataProxyUrl, extensions: externalExtensions, onCopyHeadingLink, ipfsImageFetchFn, fetchV1ImageFn, isConnected, activeModel, maxTokens, isAIAgentEnabled, onIndexedDbError, disableInlineComment, ...rest }: Partial<DdocProps>) => {
+export declare const useDdocEditor: ({ isPreviewMode, initialContent, versionHistoryState, enableCollaboration, onChange, onCollaboratorChange, onCommentInteraction, onError, setCharacterCount, setWordCount, ipfsImageUploadFn, ddocId, enableIndexeddbSync, unFocused, theme, zoomLevel, onInvalidContentError, ignoreCorruptedData, isPresentationMode, metadataProxyUrl, extensions: externalExtensions, onCopyHeadingLink, ipfsImageFetchFn, fetchV1ImageFn, isConnected, activeModel, maxTokens, isAIAgentEnabled, collabConfig, onIndexedDbError, disableInlineComment, ...rest }: Partial<DdocProps>) => {
     ydoc: import('yjs').Doc;
-    awareness: import('y-protocols/awareness.js').Awareness | null;
+    awareness: any;
     refreshYjsIndexedDbProvider: () => Promise<void>;
     terminateSession: () => void;
     isContentLoading: boolean;
@@ -21,11 +21,10 @@ export declare const useDdocEditor: ({ isPreviewMode, initialContent, versionHis
     }) => void;
     duplicateTab: (tabId: string) => string | undefined;
     orderTab: (destinationTabId: string, movedTabId: string) => void;
-    onConnect: (connectConfig: import('./types').CollabConnectionConfig) => void;
+    onConnect: (connectConfig: import('./sync-local/useSyncMachine').IConnectConf) => void;
     isReady: boolean;
     hasCollabContentInitialised: boolean;
     initialiseYjsIndexedDbProvider: () => Promise<void>;
-    collabState: import('./types').CollabState;
     editor: Editor | null;
     ref: import('react').RefObject<HTMLDivElement>;
     slides: string[];

package/package.json

@@ -2,7 +2,7 @@
   "name": "@fileverse-dev/ddoc",
   "private": false,
   "description": "DDoc",
-  "version": "3.0.69-rtc-patch-3",
+  "version": "3.0.70",
   "main": "dist/index.es.js",
   "module": "dist/index.es.js",
   "exports": {
@@ -76,6 +76,8 @@
     "@tiptap/suggestion": "^3.11.0",
     "@types/uuid": "^10.0.0",
     "@ucans/ucans": "^0.12.0",
+    "@xstate-ninja/react": "^1.1.3",
+    "@xstate/react": "^3.2.2",
     "base64-js": "^1.5.1",
     "classnames": "^2.5.1",
     "color": "^5.0.3",
@@ -93,7 +95,7 @@
     "mammoth": "^1.10.0",
     "markdown-it-footnote": "^4.0.0",
     "ollama": "^0.5.14",
-    "socket.io-client": "^4.7.5",
+    "partysocket": "^1.0.2",
     "platform": "^1.3.6",
     "prosemirror-model": "^1.21.0",
     "prosemirror-state": "^1.4.3",
@@ -109,6 +111,8 @@
     "vaul": "^0.9.1",
     "vite-plugin-dts": "^3.6.3",
     "ws": "^8.18.0",
+    "xstate": "^4.38.2",
+    "xstate-ninja": "^1.3.10",
     "y-indexeddb": "^9.0.12",
     "y-prosemirror": "^1.2.5",
     "y-protocols": "^1.0.6",
@@ -152,4 +156,4 @@
     "typescript": "^5.2.2",
     "vite": "^5.0.0"
   }
-}
+}

package/dist/package/sync-local/SyncManager.d.ts

@@ -1,55 +0,0 @@
-import { Awareness } from 'y-protocols/awareness.js';
-import { SyncManagerConfig, CollabConnectionConfig, CollabServices, CollabCallbacks, CollabStatus, CollabState } from './types';
-
-export declare class SyncManager {
-    private onCollabStateChange;
-    private _status;
-    private _context;
-    private _awareness;
-    private socketClient;
-    private roomKey;
-    private roomKeyBytes;
-    private isOwner;
-    private updateQueue;
-    private uncommittedUpdatesIdList;
-    private contentTobeAppliedQueue;
-    private isProcessing;
-    private _awarenessUpdateHandler;
-    private ydoc;
-    private servicesRef;
-    private callbacksRef;
-    private onLocalUpdate?;
-    constructor(config: SyncManagerConfig, onCollabStateChange: (state: CollabState) => void);
-    /** Called by useSyncManager on every render to keep refs fresh */
-    updateRefs(services: CollabServices | undefined, callbacks: CollabCallbacks | undefined, onLocalUpdate?: (updatedDocContent: string, updateChunk: string) => void): void;
-    get isConnected(): boolean;
-    get isReady(): boolean;
-    get awareness(): Awareness | null;
-    get status(): CollabStatus;
-    get collabState(): CollabState;
-    private send;
-    private runExitActions;
-    private runEntryActions;
-    connect(config: CollabConnectionConfig): Promise<void>;
-    disconnect(): Promise<void>;
-    terminateSession(): Promise<void>;
-    enqueueLocalUpdate(update: Uint8Array): void;
-    forceCleanup(): void;
-    private handleConnectionError;
-    private handleReconnection;
-    private connectSocket;
-    private syncLatestCommit;
-    private initializeAwareness;
-    private cleanupAwareness;
-    private commitLocalContents;
-    private broadcastLocalContents;
-    private processUpdateQueue;
-    private processNextUpdate;
-    private processCommit;
-    private handleRemoteContentUpdate;
-    private applyRemoteYjsUpdate;
-    private applyQueuedRemoteContents;
-    private withRetry;
-    private disconnectInternal;
-    private resetInternalState;
-}

package/dist/package/sync-local/collabStateMachine.d.ts

@@ -1,23 +0,0 @@
-import { CollabStatus, CollabEvent, CollabContext, CollabState, CollabErrorCode } from './types';
-
-export declare const INITIAL_CONTEXT: CollabContext;
-type TransitionResult = {
-    status: CollabStatus;
-    context: Partial<CollabContext>;
-} | null;
-/**
- * Transition map: (currentStatus, eventType) → nextStatus + context mutations.
- * Returns null if the transition is invalid.
- */
-export declare function transition(currentStatus: CollabStatus, event: CollabEvent, context: CollabContext): TransitionResult;
-/**
- * Derives the consumer-facing CollabState from internal status + context.
- */
-export declare function deriveCollabState(status: CollabStatus, context: CollabContext): CollabState;
-/** Helper to create a CollabError */
-export declare function createCollabError(code: CollabErrorCode, message: string, recoverable?: boolean): {
-    code: CollabErrorCode;
-    message: string;
-    recoverable: boolean;
-};
-export {};

package/dist/package/sync-local/useSyncManager.d.ts

@@ -1,11 +0,0 @@
-import { SyncManagerConfig, CollabConnectionConfig, CollabState } from './types';
-
-export declare const useSyncManager: (config: SyncManagerConfig) => {
-    state: CollabState;
-    connect: (connectConfig: CollabConnectionConfig) => void;
-    disconnect: () => void;
-    terminateSession: () => void;
-    isReady: boolean;
-    awareness: import('y-protocols/awareness.js').Awareness | null;
-    hasCollabContentInitialised: boolean;
-};