@fileverse-dev/ddoc 2.3.0-patch-13-customisation-4 → 2.3.0-rtc-patch-1

package/dist/index.es.js

@@ -1,4 +1,4 @@
-import { D as d, E as r, P as s, R as a, h as t, u as i } from "./index-DnFRu9cp.mjs";
+import { D as d, E as r, P as s, R as a, h as t, u as i } from "./index-BYTPU5Y7.mjs";
 export {
   d as DdocEditor,
   r as Editor,

package/dist/package/components/presentation-mode/presentation-mode.d.ts

@@ -1,5 +1,5 @@
 import { Editor } from '@tiptap/react';
-import { IpfsImageFetchPayload, DdocProps } from '../../types';
+import { IpfsImageFetchPayload } from '../../types';
 
 interface PresentationModeProps {
     editor: Editor;
@@ -20,7 +20,6 @@ interface PresentationModeProps {
         url: string;
         file: File;
     }>;
-    documentStyling?: DdocProps['documentStyling'];
 }
-export declare const PresentationMode: ({ editor, onClose, isFullscreen, setIsFullscreen, onError, setCommentDrawerOpen, sharedSlidesLink, isPreviewMode, documentName, onSlidesShare, slides, setSlides, renderThemeToggle, isContentLoading, ipfsImageFetchFn, documentStyling, }: PresentationModeProps) => import("react/jsx-runtime").JSX.Element | null;
+export declare const PresentationMode: ({ editor, onClose, isFullscreen, setIsFullscreen, onError, setCommentDrawerOpen, sharedSlidesLink, isPreviewMode, documentName, onSlidesShare, slides, setSlides, renderThemeToggle, isContentLoading, ipfsImageFetchFn, }: PresentationModeProps) => import("react/jsx-runtime").JSX.Element | null;
 export {};

package/dist/package/components/presentation-mode/preview-panel.d.ts

@@ -1,10 +1,7 @@
-import { DdocProps } from '../../types';
-
 interface PreviewPanelProps {
     slides: string[];
     currentSlide: number;
     setCurrentSlide: (index: number) => void;
-    documentStyling?: DdocProps['documentStyling'];
 }
-export declare const PreviewPanel: ({ slides, currentSlide, setCurrentSlide, documentStyling, }: PreviewPanelProps) => import("react/jsx-runtime").JSX.Element;
+export declare const PreviewPanel: ({ slides, currentSlide, setCurrentSlide, }: PreviewPanelProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/package/context/editor-context.d.ts

@@ -1,17 +1,14 @@
 import { default as React, ReactNode } from 'react';
-import { DocumentStyling } from '../types';
 
 interface EditorContextType {
     collapsedHeadings: Set<string>;
     setCollapsedHeadings: (updater: (prev: Set<string>) => Set<string>) => void;
     isHeadingCollapsed: (id: string) => boolean;
     expandMultipleHeadings: (ids: string[]) => void;
-    documentStyling?: DocumentStyling;
 }
 export declare const EditorContext: React.Context<EditorContextType | null>;
 export declare const useEditorContext: () => EditorContextType;
 export declare const EditorProvider: React.FC<{
     children: ReactNode;
-    documentStyling?: DocumentStyling;
 }>;
 export {};

package/dist/package/extensions/sync-cursor.d.ts

@@ -0,0 +1,28 @@
+import { Extension } from '@tiptap/core';
+
+type CollaborationCursorStorage = {
+    users: {
+        clientId: number;
+        [key: string]: any;
+    }[];
+};
+export interface CollaborationCursorOptions {
+    provider: any;
+    user: Record<string, any>;
+    render(user: Record<string, any>): HTMLElement;
+    selectionRender(user: Record<string, any>): any;
+    onUpdate: (users: {
+        clientId: number;
+        [key: string]: any;
+    }[]) => null;
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        collaborationCursor: {
+            updateUser: (attributes: Record<string, any>) => ReturnType;
+            user: (attributes: Record<string, any>) => ReturnType;
+        };
+    }
+}
+export declare const SyncCursor: Extension<CollaborationCursorOptions, CollaborationCursorStorage>;
+export {};

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

@@ -0,0 +1,127 @@
+import { SyncMachineContext, SyncMachinEvent } from '../types';
+import { SocketClient } from '../socketClient';
+
+import * as awarenessProtocol from 'y-protocols/awareness';
+export declare const awarenessUpdateHandler: (context: SyncMachineContext, event: SyncMachinEvent) => {};
+export declare const initAwarenessHandler: (context: SyncMachineContext) => {
+    awareness: awarenessProtocol.Awareness;
+    _awarenessUpdateHandler: ({ added, updated, removed, }: {
+        added: number[];
+        updated: number[];
+        removed: number[];
+    }) => void;
+};
+export declare const updateConnectionStateHandler: (context: SyncMachineContext) => {
+    isConnected: boolean;
+};
+export declare const websocketInitializer: (context: SyncMachineContext, event: SyncMachinEvent) => {
+    socketClient: SocketClient;
+    username: any;
+    initialUpdate: any;
+    roomKey: any;
+    roomId: any;
+    isOwner: any;
+    isEns: any;
+};
+export declare const yjsUpdateHandler: (context: SyncMachineContext, event: SyncMachinEvent) => {
+    uncommittedUpdatesIdList?: undefined;
+} | {
+    uncommittedUpdatesIdList: any[];
+};
+export declare const roomMemberUpdateHandler: (context: SyncMachineContext) => {
+    roomMembers: import('../types').RoomMember[];
+};
+export declare const stateResetHandler: () => {
+    roomMembers: never[];
+    isConnected: boolean;
+    awareness: null;
+    _awarenessUpdateHandler: null;
+    socketClient: null;
+};
+export declare const registerUpdateHandler: (context: SyncMachineContext, event: SyncMachinEvent) => {
+    uncommittedUpdatesIdList?: undefined;
+} | {
+    uncommittedUpdatesIdList: any[];
+};
+export declare const removeLastProcessedUpdate: (context: SyncMachineContext, event: SyncMachinEvent) => {
+    updateQueue: Uint8Array<ArrayBufferLike>[];
+};
+export declare const clearUncommitedUpdatesHandler: (_context: SyncMachineContext, event: SyncMachinEvent) => {
+    uncommittedUpdatesIdList: never[];
+};
+export declare const addUpdateToQueueHandler: (context: SyncMachineContext, event: SyncMachinEvent) => {
+    updateQueue: any[];
+};
+export declare const updateConnectionReadyStateHandler: (_context: SyncMachineContext, event: SyncMachinEvent) => {
+    isReady: any;
+};
+export declare const setNewDocFlagHandler: (_context: SyncMachineContext, event: SyncMachinEvent) => {
+    isNewDoc: any;
+};
+export declare const commitUncommittedIdsHandler: (_context: SyncMachineContext, event: SyncMachinEvent) => {
+    uncommittedUpdatesIdList: any;
+};
+export declare const setConnectionActiveStateHandler: (context: SyncMachineContext) => {
+    isConnected: boolean;
+};
+export declare const setMachineReadyStateHandler: () => {
+    isReady: boolean;
+};
+export declare const addRemoteContentToQueueHandler: (context: SyncMachineContext, event: SyncMachinEvent) => {
+    contentTobeAppliedQueue: any[];
+};
+export declare const applyContentsFromRemote: (context: SyncMachineContext) => {
+    contentTobeAppliedQueue?: undefined;
+} | {
+    contentTobeAppliedQueue: never[];
+};
+export declare const clearErrorCountHandler: () => {
+    errorCount: number;
+    errorMessage: string;
+};
+export declare const updateErrorCountHandler: (context: SyncMachineContext) => {
+    errorCount: number;
+};
+export declare const setCommitMessageErrorHandler: (_context: SyncMachineContext, event: SyncMachinEvent) => {
+    errorMessage: string;
+};
+export declare const setUpdateErrorMessageHandler: (_context: SyncMachineContext, event: SyncMachinEvent) => {
+    errorMessage: string;
+};
+export declare const setConnectionErrorMessageHandler: (_context: SyncMachineContext, event: SyncMachinEvent) => {
+    errorMessage: string;
+};
+export declare const setIpfsQueryErrorMessageHandler: (_context: SyncMachineContext, event: SyncMachinEvent) => {
+    errorMessage: string;
+};
+export declare const setInitialCommitErrorMessageHandler: (_context: SyncMachineContext, event: SyncMachinEvent) => {
+    errorMessage: string;
+};
+export declare const setInitialUpdateErrorMessageHandler: (_context: SyncMachineContext, event: SyncMachinEvent) => {
+    errorMessage: string;
+};
+export declare const disconnectedStateHandler: () => {
+    socketClient: null;
+    roomMembers: never[];
+    isConnected: boolean;
+    awareness: null;
+    _awarenessUpdateHandler: null;
+    uncommittedUpdatesIdList: never[];
+    updateQueue: never[];
+};
+export declare const handleDisconnectionDueToError: (context: SyncMachineContext, event: SyncMachinEvent) => {
+    errorCount: number;
+    errorMessage: any;
+} | {
+    errorCount?: undefined;
+    errorMessage?: undefined;
+};
+export declare const terminateSessionHandler: (context: SyncMachineContext) => {
+    socketClient: null;
+    roomMembers: never[];
+    isConnected: boolean;
+    awareness: null;
+    _awarenessUpdateHandler: null;
+    uncommittedUpdatesIdList: never[];
+    updateQueue: never[];
+};

package/dist/package/sync-local/actions/syncMachineActions.d.ts

@@ -0,0 +1 @@
+export declare const syncMachineActions: Record<any, any>;

package/dist/package/sync-local/constants/config.d.ts

@@ -0,0 +1,7 @@
+export declare const WEBSOCKET_CONFIG: {
+    maxReconnectionDelay: number;
+    minReconnectionDelay: number;
+    reconnectionDelayGrowFactor: number;
+    connectionTimeout: number;
+    maxRetries: number;
+};

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

@@ -0,0 +1,5 @@
+import { SyncMachineContext } from '../types';
+
+export declare const initialContext: SyncMachineContext;
+export declare const STORAGE_API = "https://dev-fileverse-storage.herokuapp.com/upload/public";
+export declare const IPFS_GATEWAYS: string[];

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

@@ -0,0 +1,6 @@
+export declare const crypto: {
+    generateKeyPair: () => import('@fileverse/crypto/ecies').EciesKeyPairBytes;
+    encryptData: (key: Uint8Array, message: Uint8Array) => string;
+    decryptData: (key: Uint8Array, message: string) => Uint8Array<ArrayBufferLike>;
+    generateRandomBytes: <E extends import('@fileverse/crypto/types').EncodingType = "bytes">(length?: number, encoding?: E) => import('@fileverse/crypto/types').EncodedReturnType<E>;
+};

package/dist/package/sync-local/guards/syncMachineGuards.d.ts

@@ -0,0 +1,10 @@
+import { SyncMachineContext } from '../types';
+
+export declare const syncMachineGuards: {
+    isUserConnected: (context: SyncMachineContext) => boolean;
+    hasMoreUpdates: (context: SyncMachineContext) => boolean;
+    isOwner: (context: SyncMachineContext) => boolean;
+    errorIsLessThanRetryCount: (context: SyncMachineContext) => boolean;
+    shouldRetryConnection: (context: SyncMachineContext) => boolean;
+    shouldRefetchCommit: (context: SyncMachineContext) => boolean;
+};

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

@@ -0,0 +1,6 @@
+import { default as syncMachine } from './syncMachine';
+import { SyncMachineContext } from './types';
+
+export { useSyncMachine } from './useSyncMachine';
+export { syncMachine };
+export type { SyncMachineContext };

package/dist/package/sync-local/services/syncMachineServices.d.ts

@@ -0,0 +1,19 @@
+import { Sender } from 'xstate';
+import { SyncMachineContext, SyncMachinEvent } from '../types';
+
+export declare const syncMachineServices: {
+    connectSocket: (context: SyncMachineContext) => (send: Sender<SyncMachinEvent>) => Promise<void>;
+    disconnectSocket: (context: SyncMachineContext) => () => Promise<void>;
+    processNextUpdate: (context: SyncMachineContext) => () => Promise<{
+        updateId: string | undefined;
+        queueOffset: number;
+    } | undefined>;
+    processCommit: (context: SyncMachineContext) => (send: Sender<SyncMachinEvent>) => Promise<void>;
+    syncLatestCommitFromIpfs: (context: SyncMachineContext) => () => Promise<{
+        ids: string[];
+        unbroadcastedUpdate: string | null;
+    }>;
+    broadcastLocalContents: (context: SyncMachineContext, event: SyncMachinEvent) => () => Promise<boolean>;
+    commitLocalContents: (context: SyncMachineContext, event: SyncMachinEvent) => (send: Sender<SyncMachinEvent>) => Promise<string | undefined>;
+    verifyConnectionState: (context: SyncMachineContext) => (send: Sender<SyncMachinEvent>) => Promise<void>;
+};

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

@@ -0,0 +1,59 @@
+import { UrlProvider } from 'partysocket/ws';
+import { ISocketInitConfig, RoomMember, SocketStatusEnum, SendUpdateResponse, CommitResponse } from './types';
+
+interface ISocketClientConfig {
+    wsUrl: UrlProvider;
+    roomKey: string;
+    ownerEdSecret?: string;
+    contractAddress?: string;
+    ownerAddress?: string;
+}
+export declare class SocketClient {
+    private _websocketUrl;
+    private _machineEventHandler;
+    private _onConnect;
+    private _onDisconnection;
+    private _sequenceCallbackMap;
+    _webSocketStatus: SocketStatusEnum;
+    private _webSocket;
+    private _websocketServiceDid;
+    private roomId;
+    private clientUsername;
+    roomMembers: RoomMember[];
+    private collaborationKeyPair;
+    private ownerKeyPair?;
+    private contractAddress?;
+    private ownerUcan?;
+    private ownerAddress?;
+    _onError: ISocketInitConfig['onError'] | null;
+    constructor(config: ISocketClientConfig);
+    private _getSequenceIdCallback;
+    private _removeSequenceIdFromMap;
+    private _registerSequenceCallback;
+    private _sendNetworkRequest;
+    private _fetchRoomMembers;
+    sendUpdate({ update }: {
+        update: string;
+    }): Promise<SendUpdateResponse>;
+    commitUpdates({ updates, cid }: {
+        updates: string[];
+        cid: string;
+    }): Promise<CommitResponse>;
+    fetchLatestCommit(): Promise<any>;
+    getUncommittedChanges(): Promise<any>;
+    broadcastAwareness(awarenessUpdate: string): Promise<any>;
+    disconnect: () => void;
+    terminateSession: () => Promise<void>;
+    private _buildRequest;
+    private getCollaborationKeyPair;
+    private getOwnerToken;
+    private buildToken;
+    private _handleHandShake;
+    private _executeRequestCallback;
+    private _dispatchEventHandler;
+    private _processMessage;
+    private _clearSequenceCallbackMap;
+    connectSocket(): Promise<void> | undefined;
+    init(config: ISocketInitConfig): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,13 @@
+import { SyncMachineContext } from './types';
+
+declare const syncMachine: import('xstate').StateMachine<SyncMachineContext, any, {
+    type: string;
+    data: any;
+}, {
+    value: any;
+    context: SyncMachineContext;
+}, import('xstate').BaseActionObject, import('xstate').ServiceMap, import('xstate').ResolveTypegenMeta<import('xstate').TypegenDisabled, {
+    type: string;
+    data: any;
+}, import('xstate').BaseActionObject, import('xstate').ServiceMap>>;
+export default syncMachine;

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

@@ -0,0 +1,163 @@
+import { SocketClient } from '../socketClient';
+
+import * as Y from 'yjs';
+export interface IRoomMember {
+    userId: string;
+    username: string;
+    role: 'owner' | 'editor';
+}
+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;
+}
+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;
+}
+export interface SyncMachineContext {
+    ydoc: Y.Doc;
+    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: string) => 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;
+    cryptoUtils: {
+        generateKeyPair: () => {
+            publicKey: Uint8Array;
+            privateKey: Uint8Array;
+        };
+        encryptData: (data: Uint8Array, key: Uint8Array) => Uint8Array;
+        decryptData: (data: Uint8Array, key: Uint8Array) => Uint8Array;
+        generateRandomBytes: (length: number) => Uint8Array;
+    };
+}
+export interface ErrorResponseMessage {
+    status: boolean;
+    statusCode: number;
+    seqId: string | null;
+    is_handshake_response: boolean;
+    err: string;
+    err_detail: {
+        [key: string]: any;
+    } | null;
+}
+export interface SuccessResponseMessage {
+    status: boolean;
+    statusCode: number;
+    seqId: string | null;
+    is_handshake_response: boolean;
+    data: {
+        [key: string]: any;
+    };
+}
+export interface EventMessage {
+    type: string;
+    event_type: string;
+    event: {
+        data: any;
+        roomId: 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 {
+    onConnect: ConnectHandler;
+    onDisconnect: DisconnectHandler;
+    onError: (err: string) => void;
+    onWsEvent: EventHandler;
+    roomId: string;
+    username: string;
+}
+export declare enum SocketStatusEnum {
+    CLOSED = "CLOSED",
+    CONNECTED = "CONNECTED",
+    CONNECTING = "CONNECTING",
+    DISCONNECTING = "DISCONNECTING",
+    DISCONNECTED = "DISCONNECTED"
+}
+export interface RoomMember {
+    username: string;
+    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 {
+    username: string;
+    collaborationToken: string;
+    documentId: string;
+    ownerToken?: string;
+    ownerAddress?: string;
+    contractAddress?: string;
+    collaborationDid?: string;
+}

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

@@ -0,0 +1,51 @@
+import { SyncMachineContext } from '.';
+
+interface IConnectConf {
+    username: string;
+    roomKey: string;
+    roomId: string;
+    isOwner: boolean;
+    ownerEdSecret?: string;
+    contractAddress?: string;
+    ownerAddress?: string;
+    isEns?: boolean;
+}
+export declare const useSyncMachine: (config: Partial<SyncMachineContext>) => {
+    machine: (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>> | ((event: import("xstate").SCXML.Event<{
+        type: string;
+        data: any;
+    }> | import('xstate').SingleOrArray<import('xstate').Event<{
+        type: string;
+        data: any;
+    }>>, payload?: import('xstate').EventData) => 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>>))[];
+    connect: (connectConfig: IConnectConf) => void;
+    disconnect: () => void;
+    isConnected: boolean;
+    isReady: boolean;
+    getYjsEncodedState: () => string;
+    applyYjsEncodedState: (update: string) => void;
+    error: {
+        message: string;
+    } | null;
+    context: any;
+    terminateSession: () => void;
+};
+export {};

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

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

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

@@ -0,0 +1 @@
+export declare function fetchIpfsJsonContent(cid: string): Promise<any>;

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

@@ -0,0 +1 @@
+export declare const objectToFile: (data: Record<string, unknown>, fileName: string) => File;

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

@@ -0,0 +1,3 @@
+import { IpfsUploadResponse } from '../types';
+
+export declare const uploadFileToIPFS: (file: File) => Promise<IpfsUploadResponse>;

package/dist/package/types.d.ts

@@ -32,36 +32,6 @@ export interface CustomModel {
     apiKey: string;
     systemPrompt: string;
 }
-/**
- * Document styling configuration interface
- * @description Defines the styling options available for customizing the document editor appearance
- */
-export interface DocumentStyling {
-    /**
-     * Outer page/document background
-     * @description Controls the background of the entire editor area. Supports solid colors and CSS gradients.
-     * @example "#f8f9fa" | "linear-gradient(135deg, #667eea 0%, #764ba2 100%)"
-     */
-    background?: string;
-    /**
-     * Editor content area background
-     * @description Controls the background color of the actual editor content where text is written. Should be solid colors for readability.
-     * @example "#ffffff" | "#f5f5f5"
-     */
-    canvasBackground?: string;
-    /**
-     * Text color
-     * @description Controls the color of the text content in the editor.
-     * @example "#000000" | "#1a1a1a"
-     */
-    textColor?: string;
-    /**
-     * Font family
-     * @description Controls the font family used for the editor content.
-     * @example "Inter" | "Arial" | "Georgia"
-     */
-    fontFamily?: string;
-}
 export interface DdocProps extends CommentAccountProps {
     isCollabDocumentPublished?: boolean;
     ipfsImageFetchFn?: (_data: IpfsImageFetchPayload) => Promise<{
@@ -142,11 +112,20 @@ export interface DdocProps extends CommentAccountProps {
     activeModel?: CustomModel;
     maxTokens?: number;
     isAIAgentEnabled?: boolean;
-    /**
-     * Document styling configuration
-     * @description Customize the appearance of the document editor
-     */
-    documentStyling?: DocumentStyling;
+    collaborationKey?: CryptoKey | null;
+    collaborationKeyPair?: {
+        publicKey: string;
+        privateKey: string;
+    };
+    collabConfig?: {
+        roomKey: string;
+        collaborationId: string;
+        username: string;
+        isOwner: boolean;
+        ownerEdSecret?: string;
+        contractAddress?: string;
+        ownerAddress?: string;
+    };
 }
 export interface IEditorSelectionData {
     from: number;

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

@@ -1,11 +1,10 @@
 import { DdocProps } from './types';
 
 import * as Y from 'yjs';
-export declare const useDdocEditor: ({ isPreviewMode, initialContent, enableCollaboration, collaborationId, walletAddress, username, onChange, onCollaboratorChange, onCommentInteraction, ensResolutionUrl, onError, setCharacterCount, setWordCount, ipfsImageUploadFn, ddocId, enableIndexeddbSync, unFocused, zoomLevel, onInvalidContentError, ignoreCorruptedData, isPresentationMode, proExtensions, metadataProxyUrl, extensions: externalExtensions, onCopyHeadingLink, ipfsImageFetchFn, isConnected, activeModel, maxTokens, isAIAgentEnabled, }: Partial<DdocProps>) => {
+export declare const useDdocEditor: ({ isPreviewMode, initialContent, enableCollaboration, walletAddress, onChange, onCollaboratorChange, onCommentInteraction, ensResolutionUrl, onError, setCharacterCount, setWordCount, ipfsImageUploadFn, ddocId, enableIndexeddbSync, unFocused, zoomLevel, onInvalidContentError, ignoreCorruptedData, isPresentationMode, proExtensions, metadataProxyUrl, extensions: externalExtensions, onCopyHeadingLink, ipfsImageFetchFn, isConnected, activeModel, maxTokens, isAIAgentEnabled, collabConfig, }: Partial<DdocProps>) => {
     editor: import('@tiptap/core').Editor | null;
     isContentLoading: boolean;
     ref: import('react').RefObject<HTMLDivElement>;
-    connect: (username: string | null | undefined, isEns?: boolean) => () => void;
     ydoc: Y.Doc;
     refreshYjsIndexedDbProvider: () => Promise<void>;
     activeCommentId: string | null;
@@ -15,4 +14,5 @@ export declare const useDdocEditor: ({ isPreviewMode, initialContent, enableColl
     setSlides: import('react').Dispatch<import('react').SetStateAction<string[]>>;
     tocItems: any[];
     setTocItems: import('react').Dispatch<import('react').SetStateAction<any[]>>;
+    terminateSession: () => void;
 };