@univerjs-pro/collaboration-client 0.1.9

package/lib/index.css

@@ -0,0 +1 @@
+.univer-online-status-icon{display:flex;margin-right:8px;font-size:20px}.univer-online-status-title{font-size:14px;line-height:32px;color:rgb(var(--grey-600))}.univer-online-status.univer-online .univer-online-status-icon{color:rgb(var(--green-500))}.univer-online-status.univer-offline .univer-online-status-icon{color:rgb(var(--red-500))}

package/lib/types/controllers/collab-cursor/__tests__/doc-collab-cursor.controller.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/types/controllers/collab-cursor/__tests__/serialize-text-ranges.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/types/controllers/collab-cursor/__tests__/sheet-collab-cursor.controller.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/types/controllers/collab-cursor/collab-cursor.controller.d.ts

@@ -0,0 +1,24 @@
+import { CollaborationSessionService } from '../../services/collaboration-session/collaboration-session.service';
+import { IDocCollabCursor, ISheetCollabCursor } from '../../models/cursor';
+import { Observable } from 'rxjs';
+import { Injector } from '@wendellhu/redi';
+import { IUniverInstanceService, RxDisposable } from '@univerjs/core';
+
+/**
+ * This controller adds collaboration cursors to Univer. It works with `CollabCursorRenderController`.
+ *
+ * This controller is also responsible for managing online collaborators' data.
+ */
+export declare class CollabCursorController extends RxDisposable {
+    private readonly _univerInstanceService;
+    private readonly _injector;
+    private readonly _collabSessionService;
+    private readonly _entities;
+    private readonly _entityInit$;
+    constructor(_univerInstanceService: IUniverInstanceService, _injector: Injector, _collabSessionService: CollaborationSessionService);
+    dispose(): void;
+    getCollabCursors$(unitID: string): Observable<Map<string, ISheetCollabCursor> | Map<string, IDocCollabCursor>>;
+    private _init;
+    private _startSheetCollabCursor;
+    private _startDocCollabCursor;
+}

package/lib/types/controllers/collab-cursor/doc-collab-cursor-entity.d.ts

@@ -0,0 +1,40 @@
+import { DocSyncEditingCollabCursorService } from '../../services/sync-editing-collab-cursor/doc-sync-editing-collab-cursor.service';
+import { MemberService } from '../../services/member/member.service';
+import { ColorAssignService } from '../../services/color-assign/color-assign.service';
+import { CollaborationSession } from '../../services/collaboration-session/collaboration-session.service';
+import { IDocCollabCursor } from '../../models/cursor';
+import { Injector } from '@wendellhu/redi';
+import { ICollaborationUser, ITransformService } from '@univerjs-pro/collaboration';
+import { ICommandService, IUniverInstanceService, RxDisposable } from '@univerjs/core';
+
+/**
+ * Each univer document instance would map to an `CollabCursorEntity` to handle collaborated editing events.
+ */
+export declare class DocCollabCursorEntity extends RxDisposable {
+    readonly unitID: string;
+    private readonly _session;
+    private readonly _injector;
+    private readonly _colorAssignService;
+    private readonly _memberService;
+    private readonly _syncEditingCollabCursorService;
+    private readonly _transformService;
+    private readonly _univerInstanceService;
+    private readonly _commandService;
+    private _online;
+    private _init;
+    /** Cursor info of the collaboration room members. The key would be the memberID. */
+    private _cursorInfo$;
+    cursorInfo$: import('rxjs').Observable<Map<string, IDocCollabCursor>>;
+    get cursorInfo(): Readonly<Map<string, IDocCollabCursor>>;
+    private _roomMembers$;
+    roomMembers$: import('rxjs').Observable<ICollaborationUser[]>;
+    get roomMembers(): Readonly<ICollaborationUser[]>;
+    constructor(unitID: string, _session: CollaborationSession, _injector: Injector, _colorAssignService: ColorAssignService, _memberService: MemberService, _syncEditingCollabCursorService: DocSyncEditingCollabCursorService, _transformService: ITransformService, _univerInstanceService: IUniverInstanceService, _commandService: ICommandService);
+    dispose(): void;
+    init(): void;
+    private _onCursorUpdate;
+    private _onCursorDelete;
+    private _updateLocalCursor;
+    private _toggleOnline;
+    private _toggleOffline;
+}

package/lib/types/controllers/collab-cursor/doc-collab-cursor-render.controller.d.ts

@@ -0,0 +1,22 @@
+import { CollabCursorController } from './collab-cursor.controller';
+import { DocSkeletonManagerService } from '@univerjs/docs';
+import { IRenderManagerService } from '@univerjs/engine-render';
+import { IUniverInstanceService, RxDisposable, ThemeService } from '@univerjs/core';
+
+/**
+ * This controller works with `CollabCursorController` to render doc collaboration cursors.
+ */
+export declare class DocCollabCursorRenderController extends RxDisposable {
+    private readonly _collabCursorController;
+    private readonly _univerInstanceService;
+    private readonly _renderManagerService;
+    private readonly _docSkeletonManagerService;
+    private readonly _themeService;
+    /** Cursors stored for different Workbooks.  */
+    private _cursors;
+    constructor(_collabCursorController: CollabCursorController, _univerInstanceService: IUniverInstanceService, _renderManagerService: IRenderManagerService, _docSkeletonManagerService: DocSkeletonManagerService, _themeService: ThemeService);
+    private _init;
+    private _updateCollabCursors;
+    private _removeCollabCursors;
+    private _getDocObject;
+}

package/lib/types/controllers/collab-cursor/serialize-text-ranges.d.ts

@@ -0,0 +1,4 @@
+import { ITextRangeWithStyle } from '@univerjs/engine-render';
+
+export declare function serializeDocTextRanges(ranges: ITextRangeWithStyle[]): string;
+export declare function deserializeDocTextRanges(serializedTextRanges: string): ITextRangeWithStyle[];

package/lib/types/controllers/collab-cursor/sheet-collab-cursor-entity.d.ts

@@ -0,0 +1,41 @@
+import { MemberService } from '../../services/member/member.service';
+import { ColorAssignService } from '../../services/color-assign/color-assign.service';
+import { CollaborationSession } from '../../services/collaboration-session/collaboration-session.service';
+import { ISheetCollabCursor } from '../../models/cursor';
+import { Injector } from '@wendellhu/redi';
+import { ICollaborationUser } from '@univerjs-pro/collaboration';
+import { RefRangeService } from '@univerjs/sheets';
+import { ICommandService, IUniverInstanceService, RxDisposable } from '@univerjs/core';
+
+/**
+ * Each univer document instance would map to an `CollabCursorEntity` to handle collaborated editing events.
+ */
+export declare class SheetCollabCursorEntity extends RxDisposable {
+    readonly unitID: string;
+    private readonly _session;
+    private readonly _injector;
+    private readonly _colorAssignService;
+    private readonly _memberService;
+    private readonly _univerInstanceService;
+    private readonly _commandService;
+    private _refRangeService;
+    private _online;
+    private _init;
+    /** Cursor info of the collaboration room members. The key would be the memberID. */
+    private _cursorInfo$;
+    cursorInfo$: import('rxjs').Observable<Map<string, ISheetCollabCursor>>;
+    get cursorInfo(): Readonly<Map<string, ISheetCollabCursor>>;
+    private _roomMembers$;
+    roomMembers$: import('rxjs').Observable<ICollaborationUser[]>;
+    get roomMembers(): Readonly<ICollaborationUser[]>;
+    constructor(unitID: string, _session: CollaborationSession, _injector: Injector, _colorAssignService: ColorAssignService, _memberService: MemberService, _univerInstanceService: IUniverInstanceService, _commandService: ICommandService, _refRangeService: RefRangeService);
+    dispose(): void;
+    init(): void;
+    private _onCursorUpdate;
+    private _onCursorDelete;
+    private _getMergeRange;
+    private _onRefRangeChange;
+    private _updateLocalCursor;
+    private _toggleOnline;
+    private _toggleOffline;
+}

package/lib/types/controllers/collab-cursor/sheet-collab-cursor-render.controller.d.ts

@@ -0,0 +1,23 @@
+import { CollabCursorController } from './collab-cursor.controller';
+import { SheetSkeletonManagerService } from '@univerjs/sheets-ui';
+import { IRenderManagerService } from '@univerjs/engine-render';
+import { IUniverInstanceService, RxDisposable, ThemeService } from '@univerjs/core';
+
+/**
+ * This controller works with `CollabCursorController` to render sheet collaboration cursors.
+ */
+export declare class SheetCollabCursorRenderController extends RxDisposable {
+    private readonly _collabCursorController;
+    private readonly _univerInstanceService;
+    private readonly _renderManagerService;
+    private readonly _sheetSkeletonManagerService;
+    private readonly _themeService;
+    /** Cursors stored for different Workbooks.  */
+    private _cursors;
+    private _lastPointer;
+    constructor(_collabCursorController: CollabCursorController, _univerInstanceService: IUniverInstanceService, _renderManagerService: IRenderManagerService, _sheetSkeletonManagerService: SheetSkeletonManagerService, _themeService: ThemeService);
+    private _init;
+    private _updateCollabCursors;
+    private _removeCollabCursors;
+    private _getSheetObject;
+}

package/lib/types/controllers/collab-status/collab-status.controller.d.ts

@@ -0,0 +1,18 @@
+import { CollaborationController } from '../collaboration/collaboration.controller';
+import { Injector } from '@wendellhu/redi';
+import { IDesktopUIController } from '@univerjs/ui';
+import { Disposable, IUniverInstanceService } from '@univerjs/core';
+
+/**
+ * This controller is responsible for monitoring the collaboration status of the currently focused unit.
+ */
+export declare class DesktopCollaborationStatusDisplayController extends Disposable {
+    private readonly _uiController;
+    private readonly _univerInstanceService;
+    private readonly _injector;
+    private readonly _collaborationController;
+    private readonly _status$;
+    constructor(_uiController: IDesktopUIController, _univerInstanceService: IUniverInstanceService, _injector: Injector, _collaborationController: CollaborationController);
+    private _mountOnlineHint;
+    private _initStatusListener;
+}

package/lib/types/controllers/collaboration/__tests__/collaboration.controller.spec.d.ts

@@ -0,0 +1,5 @@
+import { IWorkbookData } from '@univerjs/core';
+
+export declare const TEST_UNIT_ID = "test";
+export declare const ANOTHER_TEST_UNIT_ID = "test2";
+export declare function getTestSheetData(id?: string): IWorkbookData;

package/lib/types/controllers/collaboration/__tests__/mock-text-selection-render-manager.service.d.ts

@@ -0,0 +1,10 @@
+import { ITextSelectionInnerParam } from '@univerjs/engine-render';
+import { Nullable } from '@univerjs/core';
+
+export declare class TextSelectionRenderManager {
+    private readonly _textSelectionInner$;
+    readonly textSelectionInner$: import('rxjs').Observable<Nullable<ITextSelectionInnerParam>>;
+    removeAllTextRanges(): void;
+    addTextRanges(): void;
+}
+export declare const ITextSelectionRenderManager: import('@wendellhu/redi').IdentifierDecorator<TextSelectionRenderManager>;

package/lib/types/controllers/collaboration/__tests__/mocks.d.ts

@@ -0,0 +1,55 @@
+import { ICollaborationSocket, ICollaborationSocketService } from '../../../services/socket/collaboration-socket.service';
+import { Subject } from 'rxjs';
+import { IDisposable } from '@wendellhu/redi';
+import { ICombResponseEvent } from '@univerjs-pro/collaboration';
+import { IBeforeCloseService, IMessageService, INotificationService } from '@univerjs/ui';
+import { IMessageMethodOptions, IMessageProps } from '@univerjs/design';
+import { ILocalStorageService, Nullable, ILogService } from '@univerjs/core';
+
+/**
+ * The handler object for a mocked socket connection. You can terminate, send messages / error through this object.
+ */
+export interface IMockCollabSessionSocketHandler extends ICollaborationSocket {
+    socket: ICollaborationSocket;
+    close$: Subject<CloseEvent>;
+    error$: Subject<Event>;
+    open$: Subject<Event>;
+    message$: Subject<ICombResponseEvent>;
+}
+/**
+ * This service provides a mocked
+ */
+export declare class MockCollaborationSocketService implements ICollaborationSocketService {
+    private readonly _logService;
+    private readonly _handlers;
+    constructor(_logService: ILogService);
+    createSocket(url: string): Nullable<ICollaborationSocket>;
+    /** Test scripts could get the session handler from this method to mock network events. */
+    getHandler(url: string): Nullable<IMockCollabSessionSocketHandler>;
+}
+export declare class MockBeforeCloseService implements IBeforeCloseService {
+    private _onCloseCallbacks;
+    private _beforeCloseCallbacks;
+    registerBeforeClose(callback: () => string | undefined): IDisposable;
+    registerOnClose(callback: () => void): IDisposable;
+}
+/**
+ * A mocked local storage service which use in-memory storage.
+ */
+export declare class MockLocalStorageService implements ILocalStorageService {
+    private readonly _inMemoryCache;
+    getItem<T>(key: string): Promise<T | null>;
+    setItem<T>(key: string, value: T): Promise<T>;
+    removeItem(key: string): Promise<void>;
+    clear(): Promise<void>;
+    key(index: number): Promise<string | null>;
+    keys(): Promise<string[]>;
+    iterate<T, U>(iteratee: (value: T, key: string, iterationNumber: number) => U): Promise<U>;
+}
+export declare class MockMessageService implements IMessageService {
+    show(options: IMessageMethodOptions & Omit<IMessageProps, 'key'>): IDisposable;
+    setContainer(container: HTMLElement): void;
+}
+export declare class MockNotificationService implements INotificationService {
+    show(): IDisposable;
+}

package/lib/types/controllers/collaboration/collaboration-state.d.ts

@@ -0,0 +1,266 @@
+import { ICollabEditingCursor } from '../../services/sync-editing-collab-cursor/doc-sync-editing-collab-cursor.service';
+import { ICollaborativeUndoRedoService } from '../../services/undoredo/collaborative-undoredo.service';
+import { MemberService } from '../../services/member/member.service';
+import { LocalCacheService } from '../../services/local-cache/local-cache.service';
+import { Injector } from '@wendellhu/redi';
+import { UniverType } from '@univerjs/protocol';
+import { IAcknowledgedChangeset, IChangeset, ITransformService, RevisionService } from '@univerjs-pro/collaboration';
+import { INotificationService } from '@univerjs/ui';
+import { IMutationInfo, Nullable, ICommandService, IConfigService, ILogService, IUniverInstanceService, LocaleService, UniverPermissionService } from '@univerjs/core';
+
+/**
+ * Determines how often should we send changesets.
+ */
+export declare const SEND_CHANGESET_TIMEOUT_KEY = "SEND_CHANGESET_TIMEOUT";
+/** Provide both states when and after changing, so the parent could examine if state transition is correct. */
+export type StateChangeHandler = (before: CollaborationState, after: CollaborationState) => void;
+/** A network interface to send changeset and  */
+export type SendChangesetHandler = (changeset: IChangeset) => void;
+export type MissingChangesetsHandler = (params: {
+    from: number;
+    to: number;
+}) => void;
+export type TransformSelectionsHandler = (changeset: IChangeset) => void;
+export type TransformIMEHandler = (changeset: IChangeset) => void;
+export type SyncEditingCollabCursorHandler = (params: ICollabEditingCursor) => void;
+export type TransformRemoteChangesetByIMECache = (changeset: IChangeset) => IChangeset;
+export interface ICollaborationStateHandler {
+    onStateChange: StateChangeHandler;
+    onSendChangeset: SendChangesetHandler;
+    onMissingChangesets: MissingChangesetsHandler;
+    onTransformSelections?: TransformSelectionsHandler;
+    onTransformIME?: TransformIMEHandler;
+    onSyncEditingCollabCursor?: SyncEditingCollabCursorHandler;
+    onTransformRemoteChangesetByIMECache?: TransformRemoteChangesetByIMECache;
+}
+export declare enum CollaborationStatus {
+    NOT_COLLAB = "not_collab",
+    SYNCED = "synced",
+    PENDING = "pending",
+    AWAITING = "awaiting",
+    AWAITING_WITH_PENDING = "awaiting_with_pending",
+    FETCH_MISS = "fetch_missing",
+    CONFLICT = "conflict",
+    OFFLINE = "offline"
+}
+/**
+ * Use state machine to manage syncing states.
+ * An explanation to how these states are transformed to each other.
+ */
+export declare abstract class CollaborationState {
+    readonly unitID: string;
+    readonly type: UniverType;
+    /** State may change internally. Parent module should provide a callback to handle this event.  */
+    protected readonly _handler: ICollaborationStateHandler;
+    protected readonly _commandService: ICommandService;
+    protected readonly _undoRedoService: ICollaborativeUndoRedoService;
+    protected readonly _revisionService: RevisionService;
+    protected readonly _localCacheService: LocalCacheService;
+    abstract readonly status: CollaborationStatus;
+    /** Mutations that has been sent to the server but not yet acknowledged by the server.  */
+    protected _awaitingChangeset: Nullable<IChangeset>;
+    /** Mutations that has not been sent to the server. */
+    protected _pendingMutations: IMutationInfo[];
+    constructor(unitID: string, type: UniverType, awaitingChangeset: Nullable<IChangeset>, pendingMutations: IMutationInfo[], 
+    /** State may change internally. Parent module should provide a callback to handle this event.  */
+    _handler: ICollaborationStateHandler, _commandService: ICommandService, _undoRedoService: ICollaborativeUndoRedoService, _revisionService: RevisionService, _localCacheService: LocalCacheService);
+    abstract resend(): void;
+    /**
+     * Append a location mutation to collaboration queue.
+     *
+     * @param mutation a mutation that happened locally and should be broadcasted to other peers
+     */
+    abstract appendMutation(mutation: IMutationInfo): CollaborationState;
+    /**
+     * Received a changeset from the server.
+     * @param changeset
+     */
+    abstract onRemoteChangeset(changeset: IChangeset): CollaborationState;
+    /**
+     * Received an acknowledgement from the server.
+     */
+    abstract onRemoteAck(changeset: IAcknowledgedChangeset): CollaborationState;
+    /**
+     * Received a rejection from the server, meaning that conflict could be resolved by the algorithm.
+     */
+    abstract onRemoteRej(): CollaborationState;
+    abstract toggleOffline(): CollaborationState;
+    abstract toggleOnline(): CollaborationState;
+    /**
+     * Check if there are some changesets missing. If true, the state should abort this changeset and request
+     * for missing changesets. Missing changesets will later be passed to `onRemoteChangeset` method.
+     *
+     * @param changeset The changeset sent from the remote collaboration server.
+     * @returns There is some changeset missing.
+     */
+    protected _checkMissing(changeset: IChangeset | IAcknowledgedChangeset): boolean;
+    /** Transform undo redo mutations in the undo redo stack.  */
+    protected _transformUndoredo(changeset: IChangeset): void;
+    /** Transform selections by calling the selection manager service. */
+    protected _transformSelections(changeset: IChangeset): void;
+    protected _transformIMECache(changeset: IChangeset): void | undefined;
+    protected _transformRemoteChangesetByIMECache(changeset: IChangeset): IChangeset;
+    protected _syncEditingCollabCursor(changeset: IChangeset): void;
+    /** @internal */
+    _updateLocalCache(): void;
+    protected _getCurrentRevision(): number;
+    protected _incrementRevisionNumber(): void;
+    protected _executeRemoteChangeset(changeset: IChangeset): void;
+}
+/**
+ * All local changesets are sent to and acknowledged by the server.
+ */
+export declare class SyncedState extends CollaborationState {
+    private readonly _injector;
+    private readonly _logService;
+    readonly status = CollaborationStatus.SYNCED;
+    constructor(unitID: string, type: UniverType, handler: ICollaborationStateHandler, revisionService: RevisionService, localCacheService: LocalCacheService, _injector: Injector, undoRedoService: ICollaborativeUndoRedoService, commandService: ICommandService, _logService: ILogService);
+    appendMutation(mutation: IMutationInfo): CollaborationState;
+    onRemoteChangeset(changeset: IChangeset): CollaborationState;
+    onRemoteAck(): never;
+    onRemoteRej(): CollaborationState;
+    toggleOffline(): CollaborationState;
+    toggleOnline(): CollaborationState;
+    resend(): void;
+}
+/**
+ * Some local changes are waiting to be sent to the server. But no changesets are waiting for acknowledgement.
+ *
+ * You should call schedule task after you create a `PendingState`.
+ */
+export declare class PendingState extends CollaborationState {
+    private readonly _injector;
+    private readonly _memberService;
+    private readonly _logService;
+    private readonly _configService;
+    private readonly _transformService;
+    private readonly _univerInstanceService;
+    readonly status = CollaborationStatus.PENDING;
+    private _scheduleTimestamp;
+    private _sendingTimer;
+    constructor(unitID: string, type: UniverType, pendingMutations: IMutationInfo[], handler: ICollaborationStateHandler, _injector: Injector, _revisionService: RevisionService, _localCacheService: LocalCacheService, _memberService: MemberService, _logService: ILogService, commandService: ICommandService, _configService: IConfigService, _transformService: ITransformService, _univerInstanceService: IUniverInstanceService, _undoRedoService: ICollaborativeUndoRedoService);
+    appendMutation(mutation: IMutationInfo): CollaborationState;
+    onRemoteChangeset(changeset: IChangeset): CollaborationState;
+    onRemoteAck(): CollaborationState;
+    onRemoteRej(): CollaborationState;
+    toggleOffline(): CollaborationState;
+    toggleOnline(): CollaborationState;
+    /**
+     * Schedule a task to send changeset to the server.
+     *
+     * @internal
+     */
+    _schedule(timeout?: number): void;
+    private _getSendChangesetTimeout;
+    resend(): void;
+    private _clearScheduledTask;
+    private _onConflict;
+}
+/**
+ * All local mutations are sent to the server and waiting for acknowledgement.
+ */
+export declare class AwaitingState extends CollaborationState {
+    private readonly _injector;
+    private readonly _logService;
+    private readonly _transformService;
+    readonly status = CollaborationStatus.AWAITING;
+    constructor(unitID: string, type: UniverType, awaitingChangeset: IChangeset, handler: ICollaborationStateHandler, _injector: Injector, revisionService: RevisionService, localCacheService: LocalCacheService, commandService: ICommandService, _logService: ILogService, _transformService: ITransformService, undoRedoService: ICollaborativeUndoRedoService);
+    appendMutation(mutation: IMutationInfo): CollaborationState;
+    onRemoteChangeset(changeset: IChangeset): CollaborationState;
+    onRemoteAck(changeset: IAcknowledgedChangeset): CollaborationState;
+    onRemoteRej(): CollaborationState;
+    toggleOffline(): CollaborationState;
+    toggleOnline(): CollaborationState;
+    resend(): void;
+    private _onConflict;
+}
+/**
+ * Some local mutations are sent to the server and waiting for acknowledgement, yet still some local mutations
+ * are waiting to be sent to the server.
+ */
+export declare class AwaitingWithPendingState extends CollaborationState {
+    private readonly _injector;
+    private readonly _logService;
+    private readonly _transformService;
+    readonly status = CollaborationStatus.AWAITING_WITH_PENDING;
+    constructor(unitID: string, type: UniverType, awaitingChangeset: IChangeset, pendingMutations: IMutationInfo[], handler: ICollaborationStateHandler, _injector: Injector, revisionService: RevisionService, localCacheService: LocalCacheService, commandService: ICommandService, _logService: ILogService, _transformService: ITransformService, undoRedoService: ICollaborativeUndoRedoService);
+    appendMutation(mutation: IMutationInfo): CollaborationState;
+    onRemoteChangeset(changeset: IChangeset): CollaborationState;
+    onRemoteAck(changeset: IAcknowledgedChangeset): CollaborationState;
+    onRemoteRej(): CollaborationState;
+    toggleOffline(): CollaborationState;
+    toggleOnline(): CollaborationState;
+    resend(): void;
+    private _onConflict;
+}
+/**
+ * This state is special for handling collaboration conflicts.
+ *
+ * `ConflictState` is a dead end state. It cannot transit to any other state. User could only reload the page to
+ * reload the document.
+ */
+export declare class ConflictState extends CollaborationState {
+    private readonly _univerPermissionService;
+    private readonly _localeService;
+    private readonly _notificationService;
+    readonly status = CollaborationStatus.CONFLICT;
+    constructor(unitID: string, type: UniverType, awaitingChangeset: Nullable<IChangeset>, pendingMutations: IMutationInfo[], handler: ICollaborationStateHandler, _univerPermissionService: UniverPermissionService, commandService: ICommandService, undoRedoService: ICollaborativeUndoRedoService, localCacheService: LocalCacheService, revisionService: RevisionService, _localeService: LocaleService, _notificationService: INotificationService);
+    appendMutation(): CollaborationState;
+    onRemoteChangeset(): CollaborationState;
+    onRemoteAck(): CollaborationState;
+    onRemoteRej(): CollaborationState;
+    toggleOffline(): CollaborationState;
+    toggleOnline(): CollaborationState;
+    resend(): void;
+    private _clearLocalCache;
+    private _showConflictNotification;
+    private _disableEditing;
+}
+export declare class OfflineState extends CollaborationState {
+    private readonly _injector;
+    readonly status = CollaborationStatus.OFFLINE;
+    constructor(unitID: string, type: UniverType, awaitingChangeset: Nullable<IChangeset>, pendingMutations: IMutationInfo[], handler: ICollaborationStateHandler, _injector: Injector, revisionService: RevisionService, localCacheService: LocalCacheService, commandService: ICommandService, undoRedoService: ICollaborativeUndoRedoService);
+    appendMutation(mutation: IMutationInfo): CollaborationState;
+    onRemoteChangeset(_changeset: IChangeset): CollaborationState;
+    onRemoteAck(): CollaborationState;
+    onRemoteRej(): CollaborationState;
+    toggleOffline(): CollaborationState;
+    toggleOnline(): CollaborationState;
+    resend(): void;
+}
+/**
+ * When the client is trying to fetch missed changesets:
+ *
+ * 1. local changesets would not be send to the server until the missed changesets are fetched
+ * 2. remote changesets would not be applied util the missed changesets are fetched and applied
+ */
+export declare class FetchingMissState extends CollaborationState {
+    /**
+     * The awaiting changeset may have been acknowledged when missing is detected.
+     * We need to transform missing changeset against this acknowledged changeset,
+     * so other state should pass this acknowledged changeset to this parameter.
+     */
+    private _acknowledgedAwaitingChangeset;
+    private readonly _queuedRemoteChangesets;
+    private readonly _injector;
+    private readonly _logService;
+    private readonly _transformService;
+    readonly status = CollaborationStatus.FETCH_MISS;
+    constructor(unitID: string, type: UniverType, awaitingChangeset: Nullable<IChangeset>, pendingMutations: IMutationInfo[], 
+    /**
+     * The awaiting changeset may have been acknowledged when missing is detected.
+     * We need to transform missing changeset against this acknowledged changeset,
+     * so other state should pass this acknowledged changeset to this parameter.
+     */
+    _acknowledgedAwaitingChangeset: Nullable<IChangeset>, _queuedRemoteChangesets: IChangeset[], handler: ICollaborationStateHandler, _injector: Injector, revisionService: RevisionService, localCacheService: LocalCacheService, _logService: ILogService, commandService: ICommandService, undoRedoService: ICollaborativeUndoRedoService, _transformService: ITransformService);
+    onMissedChangesetFetched(changesets: IChangeset[]): CollaborationState;
+    resend(): void;
+    appendMutation(mutation: IMutationInfo<object>): CollaborationState;
+    onRemoteChangeset(changeset: IChangeset): CollaborationState;
+    onRemoteAck(changeset: IAcknowledgedChangeset): CollaborationState;
+    onRemoteRej(): CollaborationState;
+    toggleOffline(): CollaborationState;
+    toggleOnline(): CollaborationState;
+    private _onConflict;
+}
+export declare function createOnlineState(injector: Injector, unitID: string, type: UniverType, awaitingChangeset: Nullable<IChangeset>, mutations: IMutationInfo[], handler: ICollaborationStateHandler): SyncedState | PendingState | AwaitingState | AwaitingWithPendingState;

package/lib/types/controllers/collaboration/collaboration.controller.d.ts

@@ -0,0 +1,110 @@
+import { CollaborationState, ICollaborationStateHandler, CollaborationStatus } from './collaboration-state';
+import { SheetTransformSelectionsService } from '../../services/range-selection/sheet-transform-selections.service';
+import { DocSyncEditingCollabCursorService } from '../../services/sync-editing-collab-cursor/doc-sync-editing-collab-cursor.service';
+import { DocTransformSelectionsService } from '../../services/text-selection/doc-transform-selections.service';
+import { DocTransformIMECacheService } from '../../services/ime-cache-transform/doc-transform-ime-cache.service';
+import { ISingleActiveUnitService } from '../../services/single-active-unit/single-active-unit.service';
+import { LocalCacheService } from '../../services/local-cache/local-cache.service';
+import { CollaborationSession, CollaborationSessionService } from '../../services/collaboration-session/collaboration-session.service';
+import { DocStateChangeManagerService } from '@univerjs/docs';
+import { Observable, BehaviorSubject } from 'rxjs';
+import { IDisposable, Injector } from '@wendellhu/redi';
+import { UniverType } from '@univerjs/protocol';
+import { CompressMutationService, RevisionService } from '@univerjs-pro/collaboration';
+import { IMessageService } from '@univerjs/ui';
+import { IMutationInfo, Nullable, ICommandService, ILogService, IUniverInstanceService, LocaleService, RxDisposable, UniverPermissionService } from '@univerjs/core';
+
+export declare class CollaborationController extends RxDisposable {
+    private readonly _injector;
+    private readonly _collabSessionService;
+    private readonly _univerInstanceService;
+    private readonly _entities;
+    private readonly _entityInit$;
+    constructor(_injector: Injector, _collabSessionService: CollaborationSessionService, _univerInstanceService: IUniverInstanceService);
+    dispose(): void;
+    getCollabEntity(id: string): Nullable<CollaborationEntity>;
+    getCollabEntity$(id: string): Observable<CollaborationEntity>;
+    private _init;
+    /**
+     * Start collaboration on a document.
+     *
+     * @param unitID ID of the document to start collaboration.
+     * @returns A disposable to stop collaboration.
+     */
+    private _startCollaboration;
+    private _getCtorByUniverType;
+}
+/**
+ * Each univer document instance would map to an `CollaborationEntity` to handle collaborated editing events.
+ */
+export declare abstract class CollaborationEntity extends RxDisposable {
+    readonly unitID: string;
+    protected readonly _type: UniverType;
+    protected readonly _session: CollaborationSession;
+    protected readonly _injector: Injector;
+    protected readonly _localCacheService: LocalCacheService;
+    protected readonly _univerPermissionService: UniverPermissionService;
+    protected readonly _compressMutationService: CompressMutationService;
+    protected readonly _localeService: LocaleService;
+    protected readonly _revisionService: RevisionService;
+    protected readonly _logService: ILogService;
+    protected readonly _commandService: ICommandService;
+    protected readonly _messageService: IMessageService;
+    protected readonly _singleActiveUnitService?: ISingleActiveUnitService | undefined;
+    protected _state$: BehaviorSubject<Nullable<CollaborationState>>;
+    readonly state$: Observable<Nullable<CollaborationState>>;
+    protected _state: CollaborationState;
+    get state(): CollaborationState;
+    protected _collaborationPaused: boolean;
+    readonly status$: Observable<CollaborationStatus>;
+    constructor(unitID: string, _type: UniverType, _session: CollaborationSession, _injector: Injector, _localCacheService: LocalCacheService, _univerPermissionService: UniverPermissionService, _compressMutationService: CompressMutationService, _localeService: LocaleService, _revisionService: RevisionService, _logService: ILogService, _commandService: ICommandService, _messageService: IMessageService, _singleActiveUnitService?: ISingleActiveUnitService | undefined);
+    init(): Promise<void>;
+    /**
+     * Pause collaboration on the document. Remote changesets would be inserted to a queue and wait for resuming.
+     * @returns a disposable which will resume collaboration when called.
+     */
+    pauseCollaboration(): IDisposable;
+    private _updateState;
+    protected _init(): Promise<CollaborationState>;
+    /**
+     * Could not transit the state twice at the same time. So we put a lock here in case of implementation fault.
+     */
+    private _transitionLocked;
+    private _unlockTransition;
+    private _lockTransition;
+    protected _onLocalMutation(command: IMutationInfo): void;
+    private _remoteChangesetQueue;
+    private _onRemoteChangeset;
+    private _exhaustRemoteChangesetQueue;
+    private _applyRemoteChangeset;
+    private _onRemoteACK;
+    private _onRemoteRejected;
+    private _onFetchMissResult;
+    private _toggleOffline;
+    private _toggleOnline;
+    private _createInitialState;
+    protected _createHandler(): ICollaborationStateHandler;
+    private _createInitialStateImpl;
+    private _replayCachedMutations;
+}
+export declare class DocCollaborationEntity extends CollaborationEntity {
+    readonly unitID: string;
+    readonly type: UniverType;
+    readonly session: CollaborationSession;
+    private readonly _docStateChangeManagerService;
+    private readonly _docTransformIMECacheService;
+    private readonly _docTransformSelectionsService;
+    private readonly _docSyncEditingCollabCursorService;
+    constructor(unitID: string, type: UniverType, session: CollaborationSession, injector: Injector, localCacheService: LocalCacheService, univerPermissionService: UniverPermissionService, compressMutationService: CompressMutationService, localeService: LocaleService, revisionService: RevisionService, _docStateChangeManagerService: DocStateChangeManagerService, _docTransformIMECacheService: DocTransformIMECacheService, _docTransformSelectionsService: DocTransformSelectionsService, _docSyncEditingCollabCursorService: DocSyncEditingCollabCursorService, logService: ILogService, commandService: ICommandService, messageService: IMessageService, singleActiveUnitService?: ISingleActiveUnitService);
+    protected _createHandler(): ICollaborationStateHandler;
+    protected _init(): Promise<CollaborationState>;
+}
+export declare class SheetCollaborationEntity extends CollaborationEntity {
+    readonly unitID: string;
+    readonly type: UniverType;
+    readonly session: CollaborationSession;
+    private readonly _sheetTransformSelectionsService;
+    constructor(unitID: string, type: UniverType, session: CollaborationSession, injector: Injector, localCacheService: LocalCacheService, univerPermissionService: UniverPermissionService, compressMutationService: CompressMutationService, localeService: LocaleService, revisionService: RevisionService, _sheetTransformSelectionsService: SheetTransformSelectionsService, logService: ILogService, commandService: ICommandService, messageService: IMessageService, singleActiveUnitService?: ISingleActiveUnitService);
+    protected _createHandler(): ICollaborationStateHandler;
+    protected _init(): Promise<CollaborationState>;
+}