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

package/dist/package/components/export-modal.d.ts

@@ -1,12 +1,12 @@
-interface ExportFormatOption {
+export interface ExportFormatOption {
     id: string;
     label: string;
 }
-interface ExportTabOption {
+export interface ExportTabOption {
     id: string;
     label: string;
 }
-interface ExportAsModalProps {
+export interface DdocExportModalProps {
     open: boolean;
     onOpenChange: (open: boolean) => void;
     onExport?: (data: {
@@ -18,5 +18,4 @@ interface ExportAsModalProps {
     initialFormat?: string;
     initialTab?: string;
 }
-export declare const ExportAsModal: ({ open, onOpenChange, onExport, formatOptions, tabOptions, initialFormat, initialTab, }: ExportAsModalProps) => import("react/jsx-runtime").JSX.Element;
-export {};
+export declare const DdocExportModal: ({ open, onOpenChange, onExport, formatOptions, tabOptions, initialFormat, initialTab, }: DdocExportModalProps) => import("react/jsx-runtime").JSX.Element;

package/dist/package/hooks/use-ddoc-export.d.ts

@@ -6,7 +6,7 @@ import * as Y from 'yjs';
 interface UseDdocExportArgs {
     editor: Editor | null;
     tabs: Tab[];
-    ydoc: Y.Doc;
+    ydoc: Y.Doc | null;
     exportOptions: (IEditorToolElement | null)[];
 }
 declare const useDdocExport: ({ editor, tabs, ydoc, exportOptions, }: UseDdocExportArgs) => {
@@ -20,5 +20,10 @@ declare const useDdocExport: ({ editor, tabs, ydoc, exportOptions, }: UseDdocExp
         tab: string;
         name?: string;
     }) => void;
+    handleExportAsync: ({ format, tab, name, }: {
+        format: string;
+        tab: string;
+        name?: string;
+    }) => Promise<void>;
 };
 export { useDdocExport };

package/dist/package/hooks/use-export-headless-editor-content.d.ts

@@ -0,0 +1,33 @@
+import { Editor, JSONContent } from '@tiptap/react';
+import { DdocExportModalProps } from '../components/export-modal';
+import { UseHeadlessEditorProps } from './use-headless-editor';
+
+import * as Y from 'yjs';
+export type HeadlessEditorExportFormat = 'pdf' | 'md' | 'html' | 'txt';
+export interface HeadlessEditorExportOption {
+    content: string;
+    fileName?: string;
+    initialFormat?: HeadlessEditorExportFormat;
+}
+export declare const useExportHeadlessEditorContent: (props?: UseHeadlessEditorProps & {
+    onExportError?: (error: unknown) => void;
+}) => {
+    exportContent: (option: HeadlessEditorExportOption) => void;
+    exportModalProps: DdocExportModalProps;
+    setContent: (initialContent: string | string[] | JSONContent, editor: Editor, ydoc: Y.Doc) => void;
+    getEditor: () => {
+        editor: Editor;
+        ydoc: Y.Doc;
+    };
+    getYjsConvertor: () => {
+        convertJSONContentToYjsEncodedString: (content: JSONContent) => string;
+        cleanup: () => void;
+    };
+    downloadContentAsMd: (content: string | string[] | JSONContent, title: string) => Promise<void>;
+    downloadContentAsHtml: (content: string | string[] | JSONContent, title: string) => Promise<void>;
+    downloadContentAsTxt: (content: string | string[] | JSONContent, title: string) => Promise<void>;
+    mergeYjsUpdates: (contents: string[]) => string;
+    handleMarkdownContent: typeof import('../extensions/mardown-paste-handler').handleMarkdownContent;
+    getYjsContentFromMarkdown: (file: File, ipfsImageUploadFn: (file: File) => Promise<import('../types').IpfsImageUploadResponse>) => Promise<string | null>;
+    getYjsContentFromDocx: (file: File, ipfsImageUploadFn: (file: File) => Promise<import('../types').IpfsImageUploadResponse>) => Promise<string | null>;
+};

package/dist/package/hooks/use-headless-editor.d.ts

@@ -3,9 +3,10 @@ import { handleMarkdownContent } from '../extensions/mardown-paste-handler';
 import { IpfsImageUploadResponse } from '../types';
 
 import * as Y from 'yjs';
-export declare const useHeadlessEditor: (props?: {
+export interface UseHeadlessEditorProps {
     optionalExtensions?: string[];
-}) => {
+}
+export declare const useHeadlessEditor: (props?: UseHeadlessEditorProps) => {
     setContent: (initialContent: string | string[] | JSONContent, editor: Editor, ydoc: Y.Doc) => void;
     getEditor: () => {
         editor: Editor;

package/dist/package/hooks/use-rtc-websocket-disconnector.d.ts

@@ -0,0 +1 @@
+export declare const useRtcWebsocketDisconnector: (syncState: any, enableCollaboration: boolean | undefined) => void;

package/dist/package/hooks/use-tab-editor.d.ts

@@ -2,7 +2,7 @@ import { Dispatch, MutableRefObject, SetStateAction } from 'react';
 import { DdocProps } from '../types';
 import { AnyExtension, Editor } from '@tiptap/react';
 import { ToCItemType } from '../components/toc/types';
-import { CollabConnectionConfig, CollaborationProps } from '../sync-local/types';
+import { IConnectConf } from '../sync-local/useSyncMachine';
 
 import * as Y from 'yjs';
 interface UseTabEditorArgs {
@@ -12,7 +12,8 @@ interface UseTabEditorArgs {
     versionId?: string;
     isPreviewMode?: boolean;
     initialContent: DdocProps['initialContent'];
-    collaboration?: CollaborationProps;
+    enableCollaboration?: boolean;
+    collabConfig?: DdocProps['collabConfig'];
     isReady?: boolean;
     awareness?: any;
     disableInlineComment?: boolean;
@@ -37,7 +38,7 @@ interface UseTabEditorArgs {
     onInvalidContentError?: DdocProps['onInvalidContentError'];
     ignoreCorruptedData?: boolean;
     onCollaboratorChange?: DdocProps['onCollaboratorChange'];
-    onConnect: (connectConfig: CollabConnectionConfig) => void;
+    onConnect: (connectConfig: IConnectConf) => void;
     hasCollabContentInitialised?: boolean;
     initialiseYjsIndexedDbProvider: () => Promise<void>;
     externalExtensions?: Record<string, AnyExtension>;
@@ -46,7 +47,7 @@ interface UseTabEditorArgs {
     theme?: 'dark' | 'light';
     editorRef?: MutableRefObject<Editor | null>;
 }
-export declare const useTabEditor: ({ ydoc, isVersionMode, hasTabState, versionId, isPreviewMode, initialContent, collaboration, isReady, awareness, disableInlineComment, onCommentInteraction, onError, ipfsImageUploadFn, metadataProxyUrl, onCopyHeadingLink, ipfsImageFetchFn, fetchV1ImageFn, isConnected, activeModel, maxTokens, isAIAgentEnabled, setCharacterCount, setWordCount, setIsContentLoading, setIsCollabContentLoading, unFocused, zoomLevel, isPresentationMode, onInvalidContentError, ignoreCorruptedData, onCollaboratorChange, onConnect, hasCollabContentInitialised, initialiseYjsIndexedDbProvider, externalExtensions, isContentLoading, activeTabId, theme, editorRef, }: UseTabEditorArgs) => {
+export declare const useTabEditor: ({ ydoc, isVersionMode, hasTabState, versionId, isPreviewMode, initialContent, enableCollaboration, collabConfig, isReady, awareness, disableInlineComment, onCommentInteraction, onError, ipfsImageUploadFn, metadataProxyUrl, onCopyHeadingLink, ipfsImageFetchFn, fetchV1ImageFn, isConnected, activeModel, maxTokens, isAIAgentEnabled, setCharacterCount, setWordCount, setIsContentLoading, setIsCollabContentLoading, unFocused, zoomLevel, isPresentationMode, onInvalidContentError, ignoreCorruptedData, onCollaboratorChange, onConnect, hasCollabContentInitialised, initialiseYjsIndexedDbProvider, externalExtensions, isContentLoading, activeTabId, theme, editorRef, }: UseTabEditorArgs) => {
     editor: Editor | null;
     ref: import('react').RefObject<HTMLDivElement>;
     slides: string[];

package/dist/package/hooks/use-tab-manager.d.ts

@@ -5,7 +5,7 @@ import * as Y from 'yjs';
 interface UseTabManagerArgs {
     ydoc: Y.Doc;
     initialContent: DdocProps['initialContent'];
-    enableCollaboration?: boolean;
+    enableCollaboration: DdocProps['enableCollaboration'];
     isDDocOwner: boolean;
     createDefaultTabIfMissing: boolean;
     shouldSyncActiveTab: boolean;

package/dist/package/hooks/use-yjs-setup.d.ts

@@ -1,22 +1,27 @@
 import { JSONContent } from '@tiptap/react';
-import { CollaborationProps } from '../sync-local/types';
+import { DdocProps } from '../types';
 import * as Y from 'yjs';
 interface UseYjsSetupArgs {
     onChange?: (updatedDocContent: string | JSONContent, updateChunk: string) => void;
     enableIndexeddbSync?: boolean;
     ddocId?: string;
-    collaboration?: CollaborationProps;
+    enableCollaboration?: boolean;
     onIndexedDbError?: (error: Error) => void;
+    onCollabError?: DdocProps['onCollabError'];
+    onCollaborationConnectCallback?: DdocProps['onCollaborationConnectCallback'];
+    onCollaborationCommit?: DdocProps['onCollaborationCommit'];
+    onFetchCommitContent?: DdocProps['onFetchCommitContent'];
+    onCollabSessionTermination?: () => void;
+    onUnMergedUpdates?: (state: boolean) => void;
 }
-export declare const useYjsSetup: ({ onChange, enableIndexeddbSync, ddocId, collaboration, onIndexedDbError, }: UseYjsSetupArgs) => {
+export declare const useYjsSetup: ({ onChange, enableIndexeddbSync, ddocId, enableCollaboration, onIndexedDbError, onCollabError, onCollaborationConnectCallback, onCollaborationCommit, onFetchCommitContent, onCollabSessionTermination, onUnMergedUpdates, }: UseYjsSetupArgs) => {
     ydoc: Y.Doc;
-    onConnect: (connectConfig: import('../types').CollabConnectionConfig) => void;
+    onConnect: (connectConfig: import('../sync-local/useSyncMachine').IConnectConf) => void;
     isReady: boolean;
     terminateSession: () => void;
-    awareness: import('y-protocols/awareness.js').Awareness | null;
+    awareness: any;
     hasCollabContentInitialised: boolean;
     initialiseYjsIndexedDbProvider: () => Promise<void>;
     refreshYjsIndexedDbProvider: () => Promise<void>;
-    collabState: import('../types').CollabState;
 };
 export {};

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

@@ -0,0 +1,137 @@
+import { SyncMachineContext, SyncMachinEvent } from '../types';
+import { SocketClient } from '../socketClient';
+
+import * as awarenessProtocol from 'y-protocols/awareness';
+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;
+    initialUpdate: any;
+    roomKey: any;
+    roomId: any;
+    isOwner: any;
+    isEns: any;
+    wsUrl: any;
+    onCollaborationCommit: (file: File) => Promise<string>;
+    onFetchCommitContent: (cid: string) => Promise<any>;
+    onSessionTerminated: () => void;
+    onUnMergedUpdates: (state: boolean) => void;
+    onLocalUpdate: ((updatedDocContent: import('../../types').Data["editorJSONData"], updateChunk: string) => void) | undefined;
+};
+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: () => {
+    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 terminateSessionHandler: (context: SyncMachineContext) => {
+    socketClient: null;
+    roomId: string;
+    roomMembers: never[];
+    isConnected: boolean;
+    awareness: null;
+    _awarenessUpdateHandler: null;
+    roomKey: string;
+    wsUrl: string;
+    uncommittedUpdatesIdList: never[];
+    updateQueue: never[];
+    isOwner: boolean;
+    isReady: boolean;
+    isNewDoc: boolean;
+    contentTobeAppliedQueue: never[];
+    initialUpdate: null;
+    errorCount: number;
+    errorMessage: string;
+};
+export declare const setDocumentDecryptionStateHandler: (_: SyncMachineContext, event: SyncMachinEvent) => {
+    initalDocumentDecryptionState: any;
+};

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/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

@@ -1,3 +1,6 @@
-export { useSyncManager } from './useSyncManager';
-export { SyncManager } from './SyncManager';
-export type { SyncManagerConfig, CollabConnectionConfig, CollabServices, CollabCallbacks, CollaborationProps, CollabSessionMeta, CollabStatus, CollabState, CollabError, CollabErrorCode, CollabEvent, CollabContext, } from './types';
+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) => (send: Sender<SyncMachinEvent>) => 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

@@ -1,17 +1,14 @@
-import { ISocketInitConfig, RoomMember, SocketStatusEnum, SendUpdateResponse, CommitResponse, AckResponse } from './types';
+import { UrlProvider } from 'partysocket/ws';
+import { ISocketInitConfig, RoomMember, SocketStatusEnum, SendUpdateResponse, CommitResponse } from './types';
 import { Awareness } from 'y-protocols/awareness.js';
 
 interface ISocketClientConfig {
-    wsUrl: string;
+    wsUrl: UrlProvider;
     roomKey: string;
-    roomId: string;
     ownerEdSecret?: string;
     contractAddress?: string;
     ownerAddress?: string;
-    onHandshakeData?: (response: {
-        data: AckResponse;
-        roomKey: string;
-    }) => void;
+    onCollaborationConnectCallback: (response: any) => void;
     roomInfo?: {
         documentTitle: string;
         portalAddress: string;
@@ -19,12 +16,14 @@ interface ISocketClientConfig {
     };
 }
 export declare class SocketClient {
-    private _socketUrl;
-    private _socket;
-    private _webSocketStatus;
-    private _isIntentionalDisconnect;
-    get isConnected(): boolean;
-    get status(): SocketStatusEnum;
+    private _websocketUrl;
+    private _machineEventHandler;
+    private _onConnect;
+    private _onDisconnection;
+    private _onHandShakeError;
+    private _sequenceCallbackMap;
+    _webSocketStatus: SocketStatusEnum;
+    private _webSocket;
     private _websocketServiceDid;
     private roomId;
     roomMembers: RoomMember[];
@@ -37,11 +36,14 @@ export declare class SocketClient {
     private roomKey;
     private roomInfo?;
     private awareness;
-    private connectionAttemptErrorCount;
-    private _onHandshakeData;
+    _onError: ISocketInitConfig['onError'] | null;
+    _onCollaborationConnectCallback: ISocketClientConfig['onCollaborationConnectCallback'] | null;
     constructor(config: ISocketClientConfig);
+    private _getSequenceIdCallback;
+    private _removeSequenceIdFromMap;
     registerAwareness(awareness: Awareness): void;
-    private _emitWithAck;
+    private _registerSequenceCallback;
+    private _sendNetworkRequest;
     private _fetchRoomMembers;
     sendUpdate({ update }: {
         update: string;
@@ -50,19 +52,24 @@ export declare class SocketClient {
         updates: string[];
         cid: string;
     }): Promise<CommitResponse>;
-    fetchLatestCommit(): Promise<AckResponse<any>>;
-    getUncommittedChanges(): Promise<AckResponse<any>>;
-    broadcastAwareness(awarenessUpdate: string): Promise<void>;
-    disconnect: () => void;
+    fetchLatestCommit(): Promise<any>;
+    getUncommittedChanges(): Promise<any>;
+    broadcastAwareness(awarenessUpdate: string): Promise<any>;
+    disconnect: (reason: string, code: number) => void;
     terminateSession: () => Promise<void>;
+    private _buildRequest;
     private getCollaborationKeyPair;
     private isUcanValid;
     private getOwnerToken;
     private buildSessionToken;
     private _handleHandShake;
-    private _handleAwarenessUpdate;
-    connectSocket(config: ISocketInitConfig): Promise<void>;
+    private _executeRequestCallback;
+    private _dispatchEventHandler;
     private _onSessionTerminated;
+    private _processMessage;
+    private _clearSequenceCallbackMap;
+    connectSocket(): Promise<void> | undefined;
+    init(config: ISocketInitConfig): Promise<void>;
     private resetSocketClient;
 }
 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;