@univerjs-pro/collaboration-client 0.1.9

package/lib/types/controllers/collaboration/utils/changeset-utils.d.ts

@@ -0,0 +1,17 @@
+import { MemberService } from '../../../services/member/member.service';
+import { IChangeset, RevisionService } from '@univerjs-pro/collaboration';
+import { IMutationInfo, IUniverInstanceService } from '@univerjs/core';
+
+export interface IAssembledChangeset {
+    changeset: IChangeset;
+    pendingMutations: IMutationInfo[];
+}
+/**
+ * Mutations those should be assembled into a single changeset.
+ */
+export declare const SINGLE_CHANGESET_MUTATIONS: Set<string>;
+/**
+ * Assemble a changeset from a list of mutations.
+ */
+export declare function assembleSheetChangeset(pendingMutations: IMutationInfo[], unitID: string, univerInstanceService: IUniverInstanceService, revisionService: RevisionService, memberService: MemberService): IAssembledChangeset;
+export declare function assembleDocChangeset(pendingMutations: IMutationInfo[], unitID: string, univerInstanceService: IUniverInstanceService, revisionService: RevisionService, memberService: MemberService): IAssembledChangeset;

package/lib/types/controllers/data-loader/__tests__/data-loader.controller.spec.d.ts

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

package/lib/types/controllers/data-loader/data-loader.controller.d.ts

@@ -0,0 +1,23 @@
+import { IURLService } from '../../services/url/url.service';
+import { LocalCacheService } from '../../services/local-cache/local-cache.service';
+import { SnapshotService } from '@univerjs-pro/collaboration';
+import { IRemoteInstanceService } from '@univerjs/rpc';
+import { ICommandService, ILogService, RxDisposable } from '@univerjs/core';
+
+/**
+ * This controller loads data from the server.
+ */
+export declare class DataLoaderController extends RxDisposable {
+    private _urlService;
+    private readonly _logService;
+    private readonly _commandService;
+    private readonly _localCacheService;
+    private readonly _snapshotService;
+    constructor(_urlService: IURLService, _logService: ILogService, _commandService: ICommandService, _localCacheService: LocalCacheService, _snapshotService: SnapshotService, remoteInstanceService?: IRemoteInstanceService);
+    private _init;
+    private _setupSubUnitSync;
+    private _updateURLWithCurrentState;
+    private _updateSubUnitFromURLParams;
+    private _loadSheet;
+    private _loadDoc;
+}

package/lib/types/controllers/file-name/file-name.controller.d.ts

@@ -0,0 +1,13 @@
+import { Disposable, IConfigService, IUniverInstanceService } from '@univerjs/core';
+
+export declare const DEFAULT_FILE_NAME_KEY = "DEFAULT_FILE_NAME";
+/**
+ * This controller would change the current tab's title to the
+ * currently focused unit's name.
+ */
+export declare class FileNameController extends Disposable {
+    private readonly _univerInstanceService;
+    private readonly _configService;
+    constructor(_univerInstanceService: IUniverInstanceService, _configService: IConfigService);
+    private _init;
+}

package/lib/types/index.d.ts

@@ -0,0 +1,11 @@
+export { CollaborationController } from './controllers/collaboration/collaboration.controller';
+export { SEND_CHANGESET_TIMEOUT_KEY } from './controllers/collaboration/collaboration-state';
+export { CollaborationClientPlugin, type ICollaborationClientPluginConfig } from './plugin';
+export { COLLAB_WEB_SOCKET_URL_KEY, CollaborationSession, CollaborationSessionService, HEARTBEAT_INTERVAL_KEY, HEARTBEAT_TIMEOUT_KEY, SessionStatus, } from './services/collaboration-session/collaboration-session.service';
+export { LOCAL_CACHE_INTERVAL_KEY } from './services/local-cache/local-cache.service';
+export { SNAPSHOT_SERVER_URL_KEY } from './services/snapshot-server/snapshot-server.service';
+export type { ICollaborationSocket } from './services/socket/collaboration-socket.service';
+export { COLLAB_SUBMIT_CHANGESET_URL_KEY, CollaborationSocketService, ICollaborationSocketService, } from './services/socket/collaboration-socket.service';
+export { LOGIN_URL_KEY } from './services/auth-server/auth-server.service';
+export { deserializeToCombResponse, serializeCombRequest } from './services/socket/serialize';
+export { enUS, zhCN } from './locale';

package/lib/types/locale/en-US.d.ts

@@ -0,0 +1,4 @@
+import { default as zhCN } from './zh-CN';
+
+declare const locale: typeof zhCN;
+export default locale;

package/lib/types/locale/index.d.ts

@@ -0,0 +1,2 @@
+export { default as enUS } from './en-US';
+export { default as zhCN } from './zh-CN';

package/lib/types/locale/zh-CN.d.ts

@@ -0,0 +1,29 @@
+declare const locales: {
+    collabStatus: {
+        fetchMiss: string;
+        conflict: string;
+        notCollab: string;
+        synced: string;
+        syncing: string;
+        offline: string;
+    };
+    session: {
+        'connection-failed': string;
+        'will-retry': string;
+        'room-full': string;
+        'collaboration-timeout': string;
+    };
+    conflict: {
+        title: string;
+        content: string;
+    };
+    collaboration: {
+        'single-unit': {
+            warning: string;
+        };
+    };
+    auth: {
+        needGotoLoginAlert: string;
+    };
+};
+export default locales;

package/lib/types/models/cursor.d.ts

@@ -0,0 +1,29 @@
+import { ITextRangeWithStyle } from '@univerjs/engine-render';
+import { IRange } from '@univerjs/core';
+
+/**
+ * The data structure to store collab cursor info of sheet.
+ */
+export interface ISheetCollabCursor {
+    /** Background color of this collab cursor */
+    color: string;
+    /** Position of this cursor */
+    range: IRange;
+    /** Displayed user name of this cursor */
+    name: string;
+    /** The serialized range to check if two cursor are on the same position. */
+    selection: string;
+    /** Worksheet ID */
+    sheetID: string;
+}
+/**
+ * The data structure to store collab cursor info of doc.
+ */
+export interface IDocCollabCursor {
+    /** Background color of this collab cursor */
+    color: string;
+    /** Displayed user name of this cursor */
+    name: string;
+    /** The deserialized ranges of collab cursor. */
+    ranges: ITextRangeWithStyle[];
+}

package/lib/types/plugin.d.ts

@@ -0,0 +1,20 @@
+import { ICollaborationSocketService } from './services/socket/collaboration-socket.service';
+import { Ctor, Injector } from '@wendellhu/redi';
+import { LocaleService, Plugin, UniverInstanceType } from '@univerjs/core';
+
+export interface ICollaborationClientPluginConfig {
+    socketService?: Ctor<ICollaborationSocketService>;
+    enableOfflineEditing?: boolean;
+    enableSingleActiveInstanceLock?: boolean;
+    collaborationUniverTypes?: UniverInstanceType[];
+    enableAuthServer?: boolean;
+}
+export declare class CollaborationClientPlugin extends Plugin {
+    private readonly _config;
+    protected _injector: Injector;
+    private readonly _localeService;
+    static pluginName: string;
+    constructor(_config: ICollaborationClientPluginConfig | undefined, _injector: Injector, _localeService: LocaleService);
+    onStarting(injector: Injector): void;
+    private _initModules;
+}

package/lib/types/services/auth-server/auth-server.service.d.ts

@@ -0,0 +1,15 @@
+import { HTTPService } from '@univerjs/network';
+import { IConfigService, LocaleService } from '@univerjs/core';
+
+/**
+ * The config key to determined the URL provided by the auth server
+ */
+export declare const LOGIN_URL_KEY = "LOGIN_URL_KEY";
+export declare class AuthServerService {
+    private readonly _configService;
+    private readonly _httpService;
+    private readonly localeService;
+    constructor(_configService: IConfigService, _httpService: HTTPService, localeService: LocaleService);
+    init(): void;
+    private _getLoginPath;
+}

package/lib/types/services/collaboration-session/collaboration-session.service.d.ts

@@ -0,0 +1,107 @@
+import { ICollaborationSocket, ICollaborationSocketService } from '../socket/collaboration-socket.service';
+import { MemberService } from '../member/member.service';
+import { Observable } from 'rxjs';
+import { IDisposable, Injector } from '@wendellhu/redi';
+import { ICollaborationEvent } from '@univerjs-pro/collaboration';
+import { IBeforeCloseService, IMessageService } from '@univerjs/ui';
+import { Nullable, Disposable, IConfigService, ILogService, LocaleService, RxDisposable } from '@univerjs/core';
+
+export declare enum SessionStatus {
+    IDLE = 0,
+    JOINING = 1,
+    OFFLINE = 2,
+    ONLINE = 3
+}
+export declare const COLLAB_WEB_SOCKET_URL_KEY = "COLLAB_WEB_SOCKET_URL";
+export declare const DEFAULT_COLLAB_WEB_SOCKET_URL = "ws://127.0.0.1:8000/universer-api/comb/connect";
+/** The heartbeat interval in milliseconds. */
+export declare const HEARTBEAT_INTERVAL_KEY = "HEARTBEAT_INTERVAL";
+export declare const HEARTBEAT_TIMEOUT_KEY = "HEARTBEAT_TIMEOUT";
+export declare const RETRY_CONNECTING_INTERVAL_KEY = "RETRY_CONNECTING_INTERVAL";
+export declare const RETRY_CONNECTING_MAX_COUNT_KEY = "RETRY_CONNECTING_MAX_COUNT";
+/**
+ * The data structure to represent a collaboration session. It also manages the collaborator's identity.
+ *
+ * An collaboration session maps to a unit.
+ */
+export declare class CollaborationSession extends RxDisposable implements IDisposable {
+    private readonly _unitID;
+    private readonly _logService;
+    private readonly _beforeCloseService;
+    private readonly _messageService;
+    private readonly _configService;
+    private readonly _localeService;
+    private readonly _memberService;
+    private readonly _sessionStatus$;
+    readonly sessionStatus$: Observable<SessionStatus>;
+    get sessionStatus(): SessionStatus;
+    private readonly _event$;
+    readonly event$: Observable<ICollaborationEvent>;
+    private _socket;
+    private _socketMessageSubscription;
+    constructor(_unitID: string, socket$: Observable<Nullable<ICollaborationSocket>>, _logService: ILogService, _beforeCloseService: IBeforeCloseService, _messageService: IMessageService, _configService: IConfigService, _localeService: LocaleService, _memberService: MemberService);
+    getMemberID(): string | null;
+    dispose(): void;
+    private _onCombEvent;
+    private _joinRoom;
+    private _onJoinRoomEvent;
+    private _onRecvEvent;
+    private _onUserJoin;
+    private _onUserLeave;
+    /**
+     * Send event to the collaboration server.
+     */
+    send(event: ICollaborationEvent, unitID: string): Promise<void>;
+    private _collaborationTimeoutTimer;
+    private _scheduleCollaborationTimeoutTimer;
+    private _clearCollaborationTimeoutTimer;
+}
+/**
+ * This service provide collaboration sessions to univer instances. A collaboration session
+ * may be used by different controllers of different features.
+ */
+export declare class CollaborationSessionService extends Disposable {
+    private readonly _injector;
+    private readonly _localeService;
+    private readonly _messageService;
+    private readonly _logService;
+    private readonly _configService;
+    private readonly _socketService;
+    /**
+     * Socket for collaboration sessions. Session are by unitID but the socket is share by collaboration sessions.
+     */
+    private _socket$;
+    private get _socket();
+    private _sessions;
+    private _status$;
+    status$: Observable<SessionStatus>;
+    private _socketReady;
+    private _sendHeartbeatTimer;
+    private _timeoutTimer;
+    private _retryConnectingTimer;
+    private _retryCount;
+    constructor(_injector: Injector, _localeService: LocaleService, _messageService: IMessageService, _logService: ILogService, _configService: IConfigService, _socketService: ICollaborationSocketService);
+    dispose(): void;
+    /**
+     * Require a collaboration session.
+     * @param unitID
+     * @returns a collaboration session.
+     */
+    requireSession(unitID: string): Promise<CollaborationSession>;
+    private _createSocket;
+    /**
+     * Try to establish connection to the collaboration server.
+     *
+     * Will send heartbeat channel to the server to keep the connection alive.
+     */
+    private _tryEnsureSocket;
+    private _onConnectionOpen;
+    private _onConnectionFailed;
+    private _scheduleReconnection;
+    private _rescheduleHeartbeatEvent;
+    private _sendHeartbeat;
+    private _waitForHeartbeatResponse;
+    private _onMessage;
+    private _clearHeartbeatTimer;
+    private _clearTimeoutTimer;
+}

package/lib/types/services/color-assign/color-assign.service.d.ts

@@ -0,0 +1,11 @@
+import { Disposable } from '@univerjs/core';
+
+export declare const BACKGROUND_TOKENS: string[];
+/**
+ * This service assign a color to each collaboration member.
+ */
+export declare class ColorAssignService extends Disposable {
+    private _assignedColors;
+    private _colorIndex;
+    assignAColorForMemberID(memberID: string): string;
+}

package/lib/types/services/ime-cache-transform/doc-transform-ime-cache.service.d.ts

@@ -0,0 +1,12 @@
+import { Injector } from '@wendellhu/redi';
+import { ITransformService, IChangeset } from '@univerjs-pro/collaboration';
+
+export declare class DocTransformIMECacheService {
+    private readonly _injector;
+    private readonly _transformService;
+    constructor(_injector: Injector, _transformService: ITransformService);
+    transformIMECache(changeset: IChangeset): void;
+    transformRemoteChangeset(changeset: IChangeset): IChangeset;
+    private _transformUndoRedoStack;
+    private _transformPreviousActiveRange;
+}

package/lib/types/services/local-cache/local-cache.service.d.ts

@@ -0,0 +1,43 @@
+import { UniverType } from '@univerjs/protocol';
+import { IChangeset, RevisionService } from '@univerjs-pro/collaboration';
+import { IBeforeCloseService } from '@univerjs/ui';
+import { IMutationInfo, Nullable, Disposable, IConfigService, ILocalStorageService, LocaleService } from '@univerjs/core';
+
+export interface IUnitCacheData {
+    unitID: string;
+    type: UniverType;
+    rev: number;
+    awaitingChangeset: Nullable<IChangeset>;
+    mutations: IMutationInfo[];
+}
+/**
+ * A config key to determine how often should Univer save local edits.
+ */
+export declare const LOCAL_CACHE_INTERVAL_KEY = "LOCAL_CACHE_INTERVAL";
+export declare const LOCAL_CACHE_INTERVAL = 1000;
+/**
+ * This service provide caching to the collaboration controller.
+ */
+export declare class LocalCacheService extends Disposable {
+    private readonly _configService;
+    private readonly _localStorageService;
+    private readonly _beforeCloseService;
+    private readonly _localeService;
+    private readonly _revisionService;
+    private _cachedData;
+    private _saveTaskMap;
+    private _disabled;
+    constructor(_configService: IConfigService, _localStorageService: ILocalStorageService, _beforeCloseService: IBeforeCloseService, _localeService: LocaleService, _revisionService: RevisionService);
+    disableLocalCache(): void;
+    enableLocalCache(): void;
+    dispose(): void;
+    loadOfflineData(unitID: string): Promise<Nullable<IUnitCacheData>>;
+    saveOfflineData(unitID: string, data: IUnitCacheData): Promise<boolean>;
+    updateOfflineData(unitID: string, type: UniverType, awaitingChangeset: Nullable<IChangeset>, pendingMutations: IMutationInfo[]): void;
+    private _scheduleSaving;
+    private _getSaveTimeout;
+    private _saveCache;
+    private _exhaustSavingTask;
+    private _setupBeforeClosingHandler;
+}
+export declare function getLocalCacheKey(unitID: string): string;

package/lib/types/services/member/member.service.d.ts

@@ -0,0 +1,33 @@
+import { IMember } from '@univerjs/protocol';
+import { Nullable, Disposable, IUniverInstanceService } from '@univerjs/core';
+
+export interface IUser extends IMember {
+    userID: string;
+}
+/**
+ * This services manages members is each rooms.
+ */
+export declare class MemberService extends Disposable {
+    private readonly _univerInstanceService;
+    private _roomMembers;
+    private _currentUser;
+    constructor(_univerInstanceService: IUniverInstanceService);
+    setCurrentUser(user: IUser): void;
+    getCurrentUser(): Nullable<IUser>;
+    updateMember(roomID: string, member: IMember): void;
+    removeMember(roomID: string, memberID: string): void;
+    getRoom(roomID: string): RoomMember | undefined;
+    getMember(roomID: string, memberID: string): IMember | undefined;
+    private _removeRoom;
+    dispose(): void;
+}
+/**
+ * This class manages members is a single room.
+ */
+export declare class RoomMember extends Disposable {
+    private readonly _members;
+    dispose(): void;
+    updateMember(member: IMember): void;
+    removeMember(memberID: string): void;
+    getMember(memberID: string): IMember | undefined;
+}

package/lib/types/services/range-selection/sheet-transform-selections.service.d.ts

@@ -0,0 +1,9 @@
+import { Injector } from '@wendellhu/redi';
+import { IChangeset, ITransformService } from '@univerjs-pro/collaboration';
+
+export declare class SheetTransformSelectionsService {
+    private readonly _injector;
+    private readonly _transformService;
+    constructor(_injector: Injector, _transformService: ITransformService);
+    transformSelections(changeset: IChangeset): void;
+}

package/lib/types/services/single-active-unit/single-active-unit.service.d.ts

@@ -0,0 +1,40 @@
+import { Observable } from 'rxjs';
+import { Disposable } from '@univerjs/core';
+
+/**
+ * It is not recommended to open multiple units in different browser tabs at the same time,
+ * especially when the there is not access to the internet. There is a great chance of loosing
+ * offline data! So we should make there is only one active unit at a time.
+ */
+export declare const ISingleActiveUnitService: import('@wendellhu/redi').IdentifierDecorator<ISingleActiveUnitService>;
+export interface ISingleActiveUnitService {
+    editingUnit: (unitID: string) => void;
+    getUnitStatus$: (unitID: string) => Observable<UnitStatus>;
+}
+export declare enum UnitStatus {
+    NO_OTHER_CLIENTS_EDITING = 0,
+    OTHER_CLIENTS_EDITING = 1
+}
+export declare class WebBrowserSingleActiveUnitService extends Disposable implements ISingleActiveUnitService {
+    private _id;
+    private _selfUnitIDs;
+    private _unitOnClients;
+    private _heartbeatTimer;
+    private _clearOtherTimers;
+    private _unitStatus;
+    constructor();
+    dispose(): void;
+    getUnitStatus$(unitID: string): Observable<UnitStatus>;
+    editingUnit(unitID: string): void;
+    disposeUnit(unitID: string): void;
+    private _init;
+    private _handleEvent;
+    private _handleJoinEvent;
+    private _scheduleClearOtherTimer;
+    private _removeClearOtherTimer;
+    private _handleLeaveEvent;
+    private _handleHeartbeatEvent;
+    private _send;
+    private _scheduleHeartbeat;
+    private _ensureSubject;
+}

package/lib/types/services/snapshot-server/snapshot-server.service.d.ts

@@ -0,0 +1,22 @@
+import { IFetchMissingChangesetsRequest, IFetchMissingChangesetsResponse, IGetResourcesRequest, IGetResourcesResponse, IGetSheetBlockRequest, IGetSheetBlockResponse, IGetUnitOnRevRequest, IGetUnitOnRevResponse, ISaveChangesetResponse, ISaveSheetBlockResponse, ISaveSnapshotResponse } from '@univerjs/protocol';
+import { HTTPService } from '@univerjs/network';
+import { ILogContext, ISnapshotServerService, IConfigService } from '@univerjs/core';
+
+/**
+ * The config key to determined the URL provided by the snapshot server
+ * to load snapshot. The URL should not ends with a slash.
+ */
+export declare const SNAPSHOT_SERVER_URL_KEY = "SNAPSHOT_SERVER_URL_KEY";
+export declare class SnapshotServerOverHTTPService implements ISnapshotServerService {
+    private readonly _configService;
+    private readonly _httpService;
+    constructor(_configService: IConfigService, _httpService: HTTPService);
+    getUnitOnRev(_context: ILogContext, params: IGetUnitOnRevRequest): Promise<IGetUnitOnRevResponse>;
+    getSheetBlock(_context: ILogContext, params: IGetSheetBlockRequest): Promise<IGetSheetBlockResponse>;
+    fetchMissingChangesets(_context: ILogContext, params: IFetchMissingChangesetsRequest): Promise<IFetchMissingChangesetsResponse>;
+    private _getAPIPrefixPath;
+    getResourcesRequest(_context: ILogContext, params: IGetResourcesRequest): Promise<IGetResourcesResponse>;
+    saveSnapshot(): Promise<ISaveSnapshotResponse>;
+    saveSheetBlock(): Promise<ISaveSheetBlockResponse>;
+    saveChangeset(): Promise<ISaveChangesetResponse>;
+}

package/lib/types/services/socket/collaboration-socket.service.d.ts

@@ -0,0 +1,36 @@
+import { Observable } from 'rxjs';
+import { IChangeset } from '@univerjs/protocol';
+import { ICombRequestEvent, ICombResponseEvent, IFetchingMissEvent, ISubmitChangesetEvent } from '@univerjs-pro/collaboration';
+import { ISocket, HTTPService, WebSocketService } from '@univerjs/network';
+import { Nullable, IConfigService, ILogService, ISnapshotServerService } from '@univerjs/core';
+
+export interface ICollaborationSocket extends Pick<ISocket, 'open$' | 'error$' | 'close$'> {
+    memberID: string;
+    message$: Observable<ICombResponseEvent>;
+    send: (event: ICombRequestEvent) => void;
+    close: () => void;
+}
+/**
+ * This service provides a socket that can be used to communicate with the remote collaboration server.
+ */
+export interface ICollaborationSocketService {
+    createSocket: (url: string) => Nullable<ICollaborationSocket>;
+}
+export declare const ICollaborationSocketService: import('@wendellhu/redi').IdentifierDecorator<ICollaborationSocketService>;
+export declare const COLLAB_SUBMIT_CHANGESET_URL_KEY = "COLLAB_SUBMIT_CHANGESET_URL";
+export declare class CollaborationSocketService implements ICollaborationSocketService {
+    protected readonly _http: HTTPService;
+    protected readonly _ws: WebSocketService;
+    protected readonly _configService: IConfigService;
+    protected readonly _logService: ILogService;
+    protected readonly _snapshotServerService: ISnapshotServerService;
+    constructor(_http: HTTPService, _ws: WebSocketService, _configService: IConfigService, _logService: ILogService, _snapshotServerService: ISnapshotServerService);
+    /**
+     * Create a socket that would connect to the remote collaboration server. It would throw an error when the socket cannot be created.
+     *
+     * @param URL The URL of the remote server.
+     */
+    createSocket(URL: string): Nullable<ICollaborationSocket>;
+    protected _submitChangeset(socket: ICollaborationSocket, event: ISubmitChangesetEvent): Promise<void>;
+    protected _fetchMissChangesets(event: IFetchingMissEvent): Promise<IChangeset[]>;
+}

package/lib/types/services/socket/serialize.d.ts

@@ -0,0 +1,4 @@
+import { ICombRequestEvent, ICombResponseEvent } from '@univerjs-pro/collaboration';
+
+export declare function deserializeToCombResponse(event: MessageEvent): ICombResponseEvent;
+export declare function serializeCombRequest(event: ICombRequestEvent): string;

package/lib/types/services/sync-editing-collab-cursor/doc-sync-editing-collab-cursor.service.d.ts

@@ -0,0 +1,14 @@
+import { ITextRangeWithStyle } from '@univerjs/engine-render';
+import { Nullable, RxDisposable } from '@univerjs/core';
+import { IUpdateCursor } from '@univerjs/protocol';
+
+export interface ICollabEditingCursor {
+    unitID: string;
+    memberID: string;
+    textRanges: ITextRangeWithStyle[];
+}
+export declare class DocSyncEditingCollabCursorService extends RxDisposable {
+    private readonly _collabCursorState$;
+    readonly collabCursorState$: import('rxjs').Observable<Nullable<IUpdateCursor>>;
+    syncEditingCollabCursor(collabCursor: ICollabEditingCursor): void;
+}

package/lib/types/services/text-selection/doc-transform-selections.service.d.ts

@@ -0,0 +1,9 @@
+import { Injector } from '@wendellhu/redi';
+import { IChangeset, ITransformService } from '@univerjs-pro/collaboration';
+
+export declare class DocTransformSelectionsService {
+    private readonly _injector;
+    private readonly _transformService;
+    constructor(_injector: Injector, _transformService: ITransformService);
+    transformSelections(changeset: IChangeset): void;
+}

package/lib/types/services/undoredo/collaborative-undoredo.service.d.ts

@@ -0,0 +1,20 @@
+import { IChangeset, ITransformService } from '@univerjs-pro/collaboration';
+import { IUndoRedoService, ICommandService, IContextService, ILogService, IUniverInstanceService, LocalUndoRedoService } from '@univerjs/core';
+
+/**
+ * `LocalUndoRedoService` cannot transform mutations in the undo redo stack under collaboration conditions.
+ */
+export interface ICollaborativeUndoRedoService extends IUndoRedoService {
+    transformUndoRedo: (unitID: string, changeset: IChangeset) => void;
+}
+export declare class CollaborativeUndoRedoService extends LocalUndoRedoService implements ICollaborativeUndoRedoService {
+    private readonly _transformService;
+    private readonly _logService;
+    constructor(_currentUniverSheet: IUniverInstanceService, _commandService: ICommandService, _contextService: IContextService, _transformService: ITransformService, _logService: ILogService);
+    transformUndoRedo(unitID: string, changesets: IChangeset): void;
+    private _clearUndo;
+    private _clearRedo;
+    private _substituteUndoStack;
+    private _substituteRedoStack;
+    private _transformStack;
+}

package/lib/types/services/url/url.service.d.ts

@@ -0,0 +1,13 @@
+import { Observable } from 'rxjs';
+
+/**
+ * This service reads the url from the host platform and return url parts,
+ * such as queries, hashes and path.
+ */
+export interface IURLService {
+    getParam: (key: string) => string | undefined;
+    setParam: (key: string, value: string, useReplace?: boolean) => void;
+    removeParam: (key: string, useReplace?: boolean) => void;
+    urlChange$: Observable<void>;
+}
+export declare const IURLService: import('@wendellhu/redi').IdentifierDecorator<IURLService>;

package/lib/types/services/url/web-url.service.d.ts

@@ -0,0 +1,11 @@
+import { IURLService } from './url.service';
+import { Observable } from 'rxjs';
+import { RxDisposable } from '@univerjs/core';
+
+export declare class WebURLService extends RxDisposable implements IURLService {
+    readonly urlChange$: Observable<void>;
+    constructor();
+    setParam(key: string, value: string, useReplace?: boolean): void;
+    removeParam(key: string, useReplace?: boolean): void;
+    getParam(key: string): string | undefined;
+}

package/lib/types/views/components/CollabStatus.d.ts

@@ -0,0 +1,14 @@
+import { CollaborationStatus } from '../../controllers/collaboration/collaboration-state';
+import { Observable } from 'rxjs';
+
+export interface IOnlineStatusProps {
+    /** The collaboration state of the currently focused unit. */
+    status$: Observable<CollaborationStatus>;
+}
+/**
+ * A component to display collaboration status to users.
+ *
+ * @param props
+ * @returns
+ */
+export declare function CollaborationStatusDisplay(props: Readonly<IOnlineStatusProps>): JSX.Element;

package/lib/types/views/components/CollabStatus.stories.d.ts

@@ -0,0 +1,9 @@
+import { CollaborationStatusDisplay } from './CollabStatus';
+import { default as React } from 'react';
+import { Meta } from '@storybook/react';
+
+declare const meta: Meta<typeof CollaborationStatusDisplay>;
+export default meta;
+export declare const Playground: {
+    render: () => React.JSX.Element;
+};

package/lib/types/views/shapes/doc-collab-cursor.d.ts

@@ -0,0 +1,27 @@
+import { IDocCollabCursor } from '../../models/cursor';
+import { Documents, DocumentSkeleton, Scene } from '@univerjs/engine-render';
+
+/**
+ * Render a single collaborated cursor on the canvas.
+ */
+export declare class DocCollabCursor {
+    private _cursor;
+    private _scene;
+    private _docSkeleton;
+    private _document;
+    private _shapes;
+    private _anchor;
+    private _textBubble;
+    private _anchorDot;
+    private _hideTimer;
+    private _eventUnsubscribe;
+    constructor(_cursor: IDocCollabCursor, _scene: Scene, _docSkeleton: DocumentSkeleton, _document: Documents);
+    private set _hover(value);
+    dispose(): void;
+    private _render;
+    private _drawAnchor;
+    private _handleHover;
+    private _drawRange;
+    private _getAnchorBounding;
+    private _getScale;
+}