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

package/dist/package/extensions/font-family-persistence.d.ts

@@ -0,0 +1,11 @@
+import { Extension } from '@tiptap/core';
+
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        fontFamilyPersistence: {
+            setFontFamily: (fontFamily: string) => ReturnType;
+            unsetFontFamily: () => ReturnType;
+        };
+    }
+}
+export declare const FontFamilyPersistence: Extension<any, any>;

package/dist/package/extensions/typography-persistence.d.ts

@@ -0,0 +1,22 @@
+import { Extension } from '@tiptap/core';
+
+/**
+ * TypographyPersistence consolidates fontFamily and fontSize persistence logic
+ * into a single extension with 3 plugins, replacing the 6 individual plugins
+ * that were split across FontFamilyPersistence and FontSize.
+ *
+ * Plugins:
+ * 1. typographyInheritance — when a new paragraph is inserted next to a styled
+ *    one, inherit fontFamily and fontSize in a single setNodeMarkup pass.
+ *    Skips trailing-node paragraphs (they inherit from the previous sibling
+ *    at creation time, but should not be overridden when the user clears them).
+ * 2. typographyStoredMarks — when selection moves into an empty styled
+ *    paragraph, restore storedMarks for both fontFamily and fontSize at once.
+ * 3. typographySyncNodeAttr — when storedMarks change on an empty paragraph,
+ *    update both node attributes in one setNodeMarkup call.
+ *    Clearing only happens when the textStyle mark itself explicitly has a null
+ *    value for the property — NOT when non-textStyle marks (bold, italic, etc.)
+ *    are stored, which was previously causing font attrs to be wiped on
+ *    bold/italic toggle.
+ */
+export declare const TypographyPersistence: Extension<any, any>;

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 { ConnectConfig } from '../sync-local/types';
+import { IConnectConf } from '../sync-local/useSyncMachine';
 
 import * as Y from 'yjs';
 interface UseTabEditorArgs {
@@ -38,7 +38,7 @@ interface UseTabEditorArgs {
     onInvalidContentError?: DdocProps['onInvalidContentError'];
     ignoreCorruptedData?: boolean;
     onCollaboratorChange?: DdocProps['onCollaboratorChange'];
-    onConnect: (connectConfig: ConnectConfig) => void;
+    onConnect: (connectConfig: IConnectConf) => 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, onIndexedDbError, onCollabError, onCollaborationConnectCallback, onCollaborationCommit, onFetchCommitContent, onCollabSessionTermination, onUnMergedUpdates, }: UseYjsSetupArgs) => {
+export declare const useYjsSetup: ({ onChange, enableIndexeddbSync, ddocId, enableCollaboration, onIndexedDbError, onCollabError, onCollaborationConnectCallback, onCollaborationCommit, onFetchCommitContent, onCollabSessionTermination, onUnMergedUpdates, }: UseYjsSetupArgs) => {
     ydoc: Y.Doc;
-    onConnect: (connectConfig: import('../sync-local').ConnectConfig) => 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>;

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, ConnectConfig, SyncStatus, SyncManagerSnapshot, } 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,15 +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;
     onCollaborationConnectCallback: (response: any) => void;
-    onError?: (e: Error) => void;
     roomInfo?: {
         documentTitle: string;
         portalAddress: string;
@@ -17,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[];
@@ -38,8 +39,11 @@ export declare class SocketClient {
     _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;
@@ -48,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;

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

@@ -1,108 +1,130 @@
 import { Data } from '../../types';
-import { Awareness } from 'y-protocols/awareness';
+import { SocketClient } from '../socketClient';
 
 import * as Y from 'yjs';
-export declare enum SyncStatus {
-    DISCONNECTED = "disconnected",
-    CONNECTING = "connecting",
-    SYNCING = "syncing",
-    CONNECTED = "connected",
-    PROCESSING = "processing",
-    DISCONNECTING = "disconnecting"
+export interface IRoomMember {
+    userId: string;
+    username: string;
+    role: 'owner' | 'editor';
 }
-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 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 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;
+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 SyncManagerSnapshot {
-    status: SyncStatus;
+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: 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;
-    awareness: Awareness | null;
-    initialDocumentDecryptionState: 'done' | 'pending';
+    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 {
-    onConnect: () => void;
-    onDisconnect: () => void;
+    onConnect: ConnectHandler;
+    onDisconnect: DisconnectHandler;
     onError: (err: Error) => void;
+    onWsEvent: EventHandler;
     onHandShakeError: (err: Error) => 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;
+    roomId: string;
 }
 export declare enum SocketStatusEnum {
     CLOSED = "CLOSED",
@@ -116,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;