@fileverse-dev/ddoc 3.0.62 → 3.0.64-rtc-patch-1

package/dist/package/extensions/mardown-paste-handler/mark-down-html-guard-plugin.d.ts

@@ -0,0 +1,3 @@
+import { default as MarkdownIt } from 'markdown-it';
+
+export declare function markdownHtmlGuardPlugin(md: MarkdownIt): 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 { IConnectConf } from '../sync-local/useSyncMachine';
+import { ConnectConfig } from '../sync-local/types';
 
 import * as Y from 'yjs';
 interface UseTabEditorArgs {
@@ -38,7 +38,7 @@ interface UseTabEditorArgs {
     onInvalidContentError?: DdocProps['onInvalidContentError'];
     ignoreCorruptedData?: boolean;
     onCollaboratorChange?: DdocProps['onCollaboratorChange'];
-    onConnect: (connectConfig: IConnectConf) => void;
+    onConnect: (connectConfig: ConnectConfig) => void;
     hasCollabContentInitialised?: boolean;
     initialiseYjsIndexedDbProvider: () => Promise<void>;
     externalExtensions?: Record<string, AnyExtension>;

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

@@ -14,12 +14,12 @@ interface UseYjsSetupArgs {
     onCollabSessionTermination?: () => void;
     onUnMergedUpdates?: (state: boolean) => void;
 }
-export declare const useYjsSetup: ({ onChange, enableIndexeddbSync, ddocId, enableCollaboration, onIndexedDbError, onCollabError, onCollaborationConnectCallback, onCollaborationCommit, onFetchCommitContent, onCollabSessionTermination, onUnMergedUpdates, }: UseYjsSetupArgs) => {
+export declare const useYjsSetup: ({ onChange, enableIndexeddbSync, ddocId, onIndexedDbError, onCollabError, onCollaborationConnectCallback, onCollaborationCommit, onFetchCommitContent, onCollabSessionTermination, onUnMergedUpdates, }: UseYjsSetupArgs) => {
     ydoc: Y.Doc;
-    onConnect: (connectConfig: import('../sync-local/useSyncMachine').IConnectConf) => void;
+    onConnect: (connectConfig: import('../sync-local').ConnectConfig) => void;
     isReady: boolean;
     terminateSession: () => void;
-    awareness: any;
+    awareness: import('y-protocols/awareness.js').Awareness | null;
     hasCollabContentInitialised: boolean;
     initialiseYjsIndexedDbProvider: () => Promise<void>;
     refreshYjsIndexedDbProvider: () => Promise<void>;

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

@@ -0,0 +1,52 @@
+import { SyncManagerConfig, ConnectConfig, SyncManagerSnapshot } from './types';
+
+export declare class SyncManager {
+    private onStateChange;
+    private _status;
+    private _isConnected;
+    private _isReady;
+    private _errorMessage;
+    private _awareness;
+    private _initialDocumentDecryptionState;
+    private socketClient;
+    private roomKey;
+    private roomKeyBytes;
+    private isOwner;
+    private updateQueue;
+    private uncommittedUpdatesIdList;
+    private contentTobeAppliedQueue;
+    private isProcessing;
+    private errorCount;
+    private _awarenessUpdateHandler;
+    private ydoc;
+    private onError?;
+    private onCollaborationConnectCallback?;
+    private onCollaborationCommit?;
+    private onFetchCommitContent?;
+    private onSessionTerminated?;
+    private onUnMergedUpdates?;
+    private onLocalUpdate?;
+    constructor(config: SyncManagerConfig, onStateChange: (snapshot: SyncManagerSnapshot) => void);
+    private notify;
+    private setStatus;
+    connect(config: ConnectConfig): Promise<void>;
+    disconnect(): Promise<void>;
+    terminateSession(): Promise<void>;
+    enqueueLocalUpdate(update: Uint8Array): void;
+    initializeAwareness(): void;
+    forceCleanup(): void;
+    private handleReconnection;
+    private connectSocket;
+    private syncLatestCommit;
+    private commitLocalContents;
+    private broadcastLocalContents;
+    private processUpdateQueue;
+    private processNextUpdate;
+    private processCommit;
+    private handleRemoteContentUpdate;
+    private applyRemoteYjsUpdate;
+    private applyQueuedRemoteContents;
+    private withRetry;
+    private disconnectInternal;
+    private reset;
+}

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

@@ -1,6 +1,3 @@
-import { default as syncMachine } from './syncMachine';
-import { SyncMachineContext } from './types';
-
-export { useSyncMachine } from './useSyncMachine';
-export { syncMachine };
-export type { SyncMachineContext };
+export { useSyncManager } from './useSyncManager';
+export { SyncManager } from './SyncManager';
+export type { SyncManagerConfig, ConnectConfig, SyncStatus, SyncManagerSnapshot, } from './types';

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

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

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

@@ -1,130 +1,108 @@
 import { Data } from '../../types';
-import { SocketClient } from '../socketClient';
+import { Awareness } from 'y-protocols/awareness';
 
 import * as Y from 'yjs';
-export interface IRoomMember {
-    userId: string;
-    username: string;
-    role: 'owner' | 'editor';
+export declare enum SyncStatus {
+    DISCONNECTED = "disconnected",
+    CONNECTING = "connecting",
+    SYNCING = "syncing",
+    CONNECTED = "connected",
+    PROCESSING = "processing",
+    DISCONNECTING = "disconnecting"
 }
-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 SyncManagerConfig {
+    ydoc: Y.Doc;
+    onError?: (e: Error) => void;
+    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 interface CommitResponse {
-    data: {
-        agent_id: string;
-        cid: string;
-        created_at: number;
-        data: any | null;
-        documentId: string;
-        updates: string[];
+export interface ConnectConfig {
+    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;
     };
-    is_handshake_response: boolean;
-    status: boolean;
-    statusCode: number;
 }
-export interface SyncMachineContext {
-    ydoc: Y.Doc;
-    socketClient: SocketClient | null;
-    roomId: string;
-    username: string;
-    roomMembers: IRoomMember[];
+export interface SyncManagerSnapshot {
+    status: SyncStatus;
     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;
+    awareness: Awareness | null;
+    initialDocumentDecryptionState: 'done' | 'pending';
 }
-export interface ErrorResponseMessage {
-    status: boolean;
-    statusCode: number;
-    seqId: string | null;
-    is_handshake_response: boolean;
-    err: string;
-    err_detail: {
-        [key: string]: any;
-    } | null;
+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 SuccessResponseMessage {
+export interface AckResponse<T = Record<string, any>> {
     status: boolean;
     statusCode: number;
-    seqId: string | null;
-    is_handshake_response: boolean;
-    data: {
-        [key: string]: any;
-    };
+    data?: T;
+    error?: string;
+    errorCode?: ServerErrorCode;
 }
-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 interface SendUpdateResponse extends AckResponse<{
+    id: string;
+    documentId: string;
+    data: string;
+    updateType: string;
+    commitCid: string | null;
+    createdAt: number;
+}> {
 }
-export type SequenceResponseCB = (data: RequestResponse) => void;
-export interface SequenceToRequestMapValue {
-    callback: SequenceResponseCB;
+export interface CommitResponse extends AckResponse<{
+    cid: string;
+    createdAt: number;
+    documentId: string;
+    updates: string[];
+}> {
 }
-export type SequenceToRequestMap = {
-    [key: string]: SequenceToRequestMapValue;
-};
-export type Update = Uint8Array;
 export interface ISocketInitConfig {
-    onConnect: ConnectHandler;
-    onDisconnect: DisconnectHandler;
+    onConnect: () => void;
+    onDisconnect: () => void;
     onError: (err: Error) => void;
-    onWsEvent: EventHandler;
     onHandShakeError: (err: Error) => void;
-    roomId: string;
+    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;
 }
 export declare enum SocketStatusEnum {
     CLOSED = "CLOSED",
@@ -138,19 +116,6 @@ 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/useSyncManager.d.ts

@@ -0,0 +1,13 @@
+import { SyncManagerConfig, SyncStatus, ConnectConfig } from './types';
+
+export declare const useSyncManager: (config: SyncManagerConfig) => {
+    connect: (connectConfig: ConnectConfig) => void;
+    disconnect: () => void;
+    terminateSession: () => void;
+    isConnected: boolean;
+    isReady: boolean;
+    error: string;
+    awareness: import('y-protocols/awareness.js').Awareness | null;
+    hasCollabContentInitialised: boolean;
+    status: SyncStatus;
+};

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

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

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

@@ -3,7 +3,7 @@ import { Editor } from '@tiptap/react';
 
 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: any;
+    awareness: import('y-protocols/awareness.js').Awareness | null;
     refreshYjsIndexedDbProvider: () => Promise<void>;
     terminateSession: () => void;
     isContentLoading: boolean;
@@ -21,7 +21,7 @@ export declare const useDdocEditor: ({ isPreviewMode, initialContent, versionHis
     }) => void;
     duplicateTab: (tabId: string) => string | undefined;
     orderTab: (destinationTabId: string, movedTabId: string) => void;
-    onConnect: (connectConfig: import('./sync-local/useSyncMachine').IConnectConf) => void;
+    onConnect: (connectConfig: import('./sync-local').ConnectConfig) => void;
     isReady: boolean;
     hasCollabContentInitialised: boolean;
     initialiseYjsIndexedDbProvider: () => Promise<void>;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@fileverse-dev/ddoc",
   "private": false,
   "description": "DDoc",
-  "version": "3.0.62",
+  "version": "3.0.64-rtc-patch-1",
   "main": "dist/index.es.js",
   "module": "dist/index.es.js",
   "exports": {
@@ -76,8 +76,6 @@
     "@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",
@@ -95,7 +93,7 @@
     "mammoth": "^1.10.0",
     "markdown-it-footnote": "^4.0.0",
     "ollama": "^0.5.14",
-    "partysocket": "^1.0.2",
+    "socket.io-client": "^4.7.5",
     "platform": "^1.3.6",
     "prosemirror-model": "^1.21.0",
     "prosemirror-state": "^1.4.3",
@@ -111,8 +109,6 @@
     "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",

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

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

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

@@ -1,137 +0,0 @@
-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

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

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

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

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

@@ -1,5 +0,0 @@
-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[];