@univerjs-pro/collaboration 0.5.0-alpha.0 → 0.5.0-beta.1

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

@@ -0,0 +1,20 @@
+import { ICommandInfo, IMutationInfo } from '@univerjs/core';
+import { IChangeset as IProtocolChangeset, ICommand as IProtocolCommand, IMutation as IProtocolMutation, UniverType } from '@univerjs/protocol';
+export interface IChangeset {
+    unitID: string;
+    type: UniverType;
+    baseRev: number;
+    revision: number;
+    userID: string;
+    mutations: IMutationInfo[];
+    memberID: string;
+    /** sid works with reqId, represent the id of a unit edit session */
+    sid?: string;
+    /** reqId works with sid, should be monotonically increasing and begin with 1 in the same edit session */
+    reqId?: number;
+}
+export declare function parseProtocolChangeset(protocolChangeset: IProtocolChangeset): IChangeset;
+export declare function parseProtocolCommand(protocolCommands: IProtocolCommand[]): ICommandInfo[];
+export declare function parseChangesetToProtocol(changeset: IChangeset): IProtocolChangeset;
+export declare function parseProtocolMutation(mutation: IProtocolMutation): IMutationInfo;
+export declare function parseMutationToProtocol(mutation: IMutationInfo): IProtocolMutation;

package/lib/types/models/collaboration-events.d.ts

@@ -0,0 +1,235 @@
+import { ICollaMsgErrorEvent, ICollaMsgJoin, ICollaMsgLeave, ICommentUpdate, ILiveShareNewHost, ILiveShareOperation, ILiveShareRequestHost, ILiveShareTerminate, IChangeset as IProtocolChangeset, IShouldCloseConn, IUpdateCursor, IUpdatePermissionObj, UniverType } from '@univerjs/protocol';
+import { IChangeset } from './changeset';
+/**
+ * Types of all possible collaboration events.
+ *
+ * CollaborationEvents is a subset of `CombEvent.RECV`.
+ */
+export declare enum CollaborationEvent {
+    /**
+     * When the collaboration session is created, the client may send this event to the server.
+     * In the payload, the client will tell the server the its local revision. The server
+     * could emit missing changesets to the client using event `NEW_CHANGESETS`.
+     */
+    FETCH_MISSING = "fetch_missing",
+    /**
+     * @internal
+     */
+    PSEUDO_FETCH_MISSING_RESULT = "pseudo_fetch_missing_result",
+    /**
+     * The client submit a changeset to the server.
+     */
+    SUBMIT_CHANGESET = "submit_changeset",
+    /**
+     * The submitted changeset is acknowledged by the server.
+     */
+    CHANGESET_ACK = "changeset_ack",
+    /**
+     * The submitted changeset could not be transformed by the server, so
+     * the changeset should be rejected.
+     */
+    CHANGESET_REJ = "changeset_rej",
+    /**
+     * The submitted changeset could not be acknowledged by unexpected server error, so
+     * the changeset should be resent.
+     */
+    CHANGESET_SHOULD_RETRY = "changeset_should_retry",
+    /**
+     * When a changeset sent by the client is acknowledged by the server,
+     * the server should broadcast this changeset to other clients.
+     *
+     * Note that this event would not be sent via the websocket but http.
+     */
+    NEW_CHANGESETS = "new_changesets",
+    /**
+     * When a client updates its cursor position, it would send this event to
+     * the server. The server would also broadcast this event to other peer
+     * clients.
+     */
+    UPDATE_CURSOR = "update_cursor",
+    /**
+     * When a client connect the collaboration session, the server should
+     * broadcast this event to all other clients.
+     */
+    USERS_ENTER = "users_enter",
+    /**
+     * When a client disconnect the collaboration session, the server should
+     * broadcast this event to all other clients.
+     */
+    USERS_LEAVE = "users_leave",
+    /**
+     * The collaboration unit is deleted on the server.
+     */
+    UNIT_DELETE = "unit_delete",
+    /**
+     * This client requests itself to be the live share host. Sent by clients.
+     */
+    LIVESHARE_REQUEST_HOST = "liveshare.request_host",
+    /**
+     * New host is elected. Sent by the server.
+     */
+    LIVESHARE_NEW_HOST = "liveshare.new_host",
+    /**
+     * A operation sent from the live share host. Sent by the host client and
+     * broadcasted by the server. For each `operation.id`, the server should
+     * cache let latest value for followers who come into the live share room
+     * later.
+     */
+    LIVESHARE_OPERATION = "liveshare.operation",
+    /**
+     * Fetch all operations from the live share host. for some scenarios:
+     * 1. when a client comes into the live share room, it should fetch all
+     * 2. when a client miss some operations, it should fetch all
+     */
+    LIVESHARE_FETCH_OPERATIONS = "liveshare.fetch_operations",
+    /**
+     * Send by the presenter to terminate live share. Should be broadcasted to
+     * all followers.
+     */
+    LIVESHARE_TERMINATE = "liveshare.terminate",
+    /**
+     * This type will be returned if an error is reported.
+     */
+    MSG_FOR_ERROR = "error_msg",
+    PERMISSION_REJ = "permission_rej",
+    COMMENT_UPDATE = "comment_update",
+    UPDATE_PERMISSION_OBJ = "update_permission_obj",
+    SHOULD_CLOSE_CONN = "should_close_conn"
+}
+/**
+ * Awaiting mutations were acknowledged by the server.
+ */
+export interface IAcknowledgedChangeset {
+    /** The rev of the document when this changeset is assembled. */
+    baseRev: number;
+    /** The rev version given by the server. */
+    revision: number;
+}
+/**
+ * Awaiting mutations were rejected by the server.
+ */
+export interface IRejectedChangeset {
+    baseRev: number;
+    revision: number;
+}
+/**
+ * When the collaboration session is created, it should send a handshake event to the server.
+ */
+export interface IFetchingMissEvent {
+    eventID: CollaborationEvent.FETCH_MISSING;
+    data: {
+        unitID: string;
+        unitType: UniverType;
+        from: number;
+        to: number;
+    };
+}
+export interface IPseudoFetchMissingResultEvent {
+    eventID: CollaborationEvent.PSEUDO_FETCH_MISSING_RESULT;
+    data: {
+        changesets: IProtocolChangeset[];
+    };
+}
+/** Receives a changeset from collaboration server. */
+export interface INewChangesetsEvent {
+    eventID: CollaborationEvent.NEW_CHANGESETS;
+    data: IProtocolChangeset;
+}
+/** Send a changeset to the collaboration sever. */
+export interface ISubmitChangesetEvent {
+    eventID: CollaborationEvent.SUBMIT_CHANGESET;
+    data: {
+        unitID: string;
+        unitType: UniverType;
+        memberID: string;
+        changeset: IChangeset;
+    };
+}
+export interface IAcknowledgementEvent {
+    eventID: CollaborationEvent.CHANGESET_ACK;
+    data: IProtocolChangeset;
+}
+export interface IRejectionEvent {
+    eventID: CollaborationEvent.CHANGESET_REJ;
+    data: {
+        unitID: string;
+        changeset: IRejectedChangeset;
+    };
+}
+export interface IRetryEvent {
+    eventID: CollaborationEvent.CHANGESET_SHOULD_RETRY;
+    data: IChangeset;
+}
+export interface ICollaborationUser {
+    userID: string;
+    memberID: string;
+    name: string;
+}
+export interface IUserSelectionEvent {
+    eventID: CollaborationEvent.UPDATE_CURSOR;
+    data: {
+        /** The selection is serialized. */
+        selection: string;
+        userID: string;
+        memberID: string;
+        unitID: string;
+    };
+}
+export interface IUpdateCursorEvent {
+    eventID: CollaborationEvent.UPDATE_CURSOR;
+    data: IUpdateCursor;
+}
+export interface IUserJoinEvent {
+    eventID: CollaborationEvent.USERS_ENTER;
+    data: ICollaMsgJoin;
+}
+export interface IUserLeaveEvent {
+    eventID: CollaborationEvent.USERS_LEAVE;
+    data: ICollaMsgLeave;
+}
+/**
+ * The special type for other features to reuse collaboration session.
+ */
+export interface ICustomEvent {
+    eventID: string;
+    data: any;
+}
+export interface IRequestHostEvent {
+    eventID: CollaborationEvent.LIVESHARE_REQUEST_HOST;
+    data: ILiveShareRequestHost;
+}
+export interface IFetchOperationsEvent {
+    eventID: CollaborationEvent.LIVESHARE_FETCH_OPERATIONS;
+}
+export interface ITerminateEvent {
+    eventID: CollaborationEvent.LIVESHARE_TERMINATE;
+    data: ILiveShareTerminate;
+}
+export interface INewHostEvent {
+    eventID: CollaborationEvent.LIVESHARE_NEW_HOST;
+    data: ILiveShareNewHost;
+}
+export interface IOperationEvent {
+    eventID: CollaborationEvent.LIVESHARE_OPERATION;
+    data: ILiveShareOperation;
+}
+export interface IMsgErrEvent {
+    eventID: CollaborationEvent.MSG_FOR_ERROR;
+    data: ICollaMsgErrorEvent;
+}
+export interface ICommentUpdateEvent {
+    eventID: CollaborationEvent.COMMENT_UPDATE;
+    data: ICommentUpdate;
+}
+export interface IPermissionUpdateEvent {
+    eventID: CollaborationEvent.UPDATE_PERMISSION_OBJ;
+    data: IUpdatePermissionObj;
+}
+export interface IShouldCloseConnEvent {
+    eventID: CollaborationEvent.SHOULD_CLOSE_CONN;
+    data: IShouldCloseConn;
+}
+/**
+ * A union type of all possible collaboration events.
+ */
+export type ICollaborationEvent = IAcknowledgementEvent | INewChangesetsEvent | IRejectionEvent | ISubmitChangesetEvent | IPseudoFetchMissingResultEvent | IUserSelectionEvent | IFetchingMissEvent | IUpdateCursorEvent | IUserJoinEvent | IUserLeaveEvent | ICustomEvent | IRequestHostEvent | IFetchOperationsEvent | ITerminateEvent | INewHostEvent | IOperationEvent | IMsgErrEvent | ICommentUpdateEvent | IPermissionUpdateEvent | IShouldCloseConnEvent;

package/lib/types/models/socket-events.d.ts

@@ -0,0 +1,53 @@
+import { CmdRspCode, CombCmd, ICombJoinRequest, ICombJoinResponse, ICombLeaveRequest } from '@univerjs/protocol';
+import { ICollaborationEvent } from './collaboration-events';
+interface ICombCmdRequest {
+    cmd: CombCmd;
+    routeKey: string;
+    routeType: string;
+    data?: unknown;
+}
+export interface IHelloRequestEvent extends ICombCmdRequest {
+    cmd: CombCmd.HELLO;
+}
+export interface IJoinRequestEvent extends ICombCmdRequest {
+    cmd: CombCmd.JOIN;
+    data: ICombJoinRequest;
+}
+export interface ILeaveRequestEvent extends ICombCmdRequest {
+    cmd: CombCmd.LEAVE;
+    data: ICombLeaveRequest;
+}
+export interface IIngestQuestEvent extends ICombCmdRequest {
+    cmd: CombCmd.INGEST;
+    data: ICollaborationEvent;
+}
+export interface IHeartbeatRequestEvent extends ICombCmdRequest {
+    cmd: CombCmd.HEARTBEAT;
+}
+export type ICombRequestEvent = IHelloRequestEvent | IJoinRequestEvent | ILeaveRequestEvent | IIngestQuestEvent | IHeartbeatRequestEvent;
+interface ICombCmdResponse {
+    cmd: CombCmd;
+    code: CmdRspCode;
+    routeKey: string;
+    data?: unknown;
+}
+export interface IHelloResponseEvent extends ICombCmdResponse {
+    cmd: CombCmd.HELLO;
+    /** The client will not send `data` but the server would respond with `data`. */
+    data: {
+        memberID: string;
+    };
+}
+export interface IJoinResponseEvent extends ICombCmdResponse {
+    cmd: CombCmd.JOIN;
+    data: ICombJoinResponse;
+}
+export interface IRecvResponseEvent extends ICombCmdResponse {
+    cmd: CombCmd.RECV;
+    data: ICollaborationEvent;
+}
+export interface IHeartbeatResponseEvent extends ICombCmdResponse {
+    cmd: CombCmd.HEARTBEAT;
+}
+export type ICombResponseEvent = IHelloResponseEvent | IJoinResponseEvent | IRecvResponseEvent | IHeartbeatResponseEvent;
+export {};

package/lib/types/plugin.d.ts

@@ -0,0 +1,10 @@
+import { IUniverCollaborationConfig } from './controllers/config.schema';
+import { IConfigService, Injector, Plugin } from '@univerjs/core';
+export declare class UniverCollaborationPlugin extends Plugin {
+    private readonly _config;
+    protected _injector: Injector;
+    private readonly _configService;
+    static pluginName: string;
+    constructor(_config: IUniverCollaborationConfig | undefined, _injector: Injector, _configService: IConfigService);
+    onStarting(): void;
+}

package/lib/types/services/compose-changesets/compose-changesets.service.d.ts

@@ -0,0 +1,5 @@
+import { IChangeset as IProtocolChangeset } from '@univerjs/protocol';
+import { IChangeset } from '../../models/changeset';
+export declare class ComposeChangesetsService {
+    composeDocChangesets(changesets: IProtocolChangeset[]): IChangeset;
+}

package/lib/types/services/compress-mutation/compress-mutation-service.d.ts

@@ -0,0 +1,19 @@
+import { InterceptorManager } from '@univerjs/core';
+/**
+ * During transmission, compression is performed for a specific operation,referencing during transport.
+ * Before send -> compress -> transmission -> ... -> node apply -> decompression -> apply.
+ * Before send -> compress -> transmission -> ... -> node transform -> decompression -> apply.
+ * Before send -> compress -> transmission -> ... -> take from server -> decompression -> apply.
+ * Before send -> compress -> save to local -> ... -> take from local -> decompression -> apply.
+ * @export
+ * @class CompressMutationService
+ */
+export declare class CompressMutationService {
+    interceptor: InterceptorManager<{
+        COMPRESS_MUTATION_APPLY: import('@univerjs/core').IInterceptor<import('@univerjs/core').IMutationInfo<object>[], null>;
+        COMPRESS_MUTATION_SEND: import('@univerjs/core').IInterceptor<import('@univerjs/core').IMutationInfo<object>[], null>;
+    }>;
+    constructor();
+    private _init;
+    private _initSetRangeValues;
+}

package/lib/types/services/compress-mutation/compress-mutations/__test__/set-range-values.spec.d.ts

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

package/lib/types/services/compress-mutation/compress-mutations/set-range-values.d.ts

@@ -0,0 +1,13 @@
+import { ICellData, IObjectMatrixPrimitiveType, Nullable } from '@univerjs/core';
+export declare const transformRefStyleFromCells: (matrix?: IObjectMatrixPrimitiveType<Nullable<ICellData>>) => {
+    cellValue: undefined;
+    styleRefMap: undefined;
+} | {
+    cellValue: IObjectMatrixPrimitiveType<Nullable<ICellData>>;
+    styleRefMap: {
+        [id: string]: Nullable<string | import('@univerjs/core').IStyleData>;
+    };
+};
+export declare const transformCellsFromRefStyle: (matrix?: IObjectMatrixPrimitiveType<Nullable<ICellData>>, styleRefMap?: {
+    [id: string]: ICellData["s"];
+}) => IObjectMatrixPrimitiveType<Nullable<ICellData>> | undefined;

package/lib/types/services/history/type.d.ts

@@ -0,0 +1,6 @@
+import { ICreateHistoryRequest, ICreateHistoryResponse } from '@univerjs/protocol';
+import { ILogContext } from '../../utils';
+export interface IHistoryIoService {
+    createHistory(config: ICreateHistoryRequest, context?: ILogContext): Promise<ICreateHistoryResponse>;
+}
+export declare const IHistoryIoService: import('@wendellhu/redi').IdentifierDecorator<IHistoryIoService>;

package/lib/types/services/rev/__tests__/rev.service.spec.d.ts

@@ -0,0 +1,18 @@
+import { Dependency, IWorkbookData, PluginCtor, Workbook, Injector, Plugin, Univer } from '@univerjs/core';
+export interface ITestBed {
+    univer: Univer;
+    get: Injector['get'];
+    sheet: Workbook;
+}
+export declare function createCollaborationTestBed(workbookData?: IWorkbookData, dependencies?: Dependency[], plugins?: Array<PluginCtor<Plugin>>): {
+    univer: Univer;
+    get: {
+        <T>(id: import('@wendellhu/redi').DependencyIdentifier<T>, lookUp?: import('@wendellhu/redi').LookUp): T;
+        <T>(id: import('@wendellhu/redi').DependencyIdentifier<T>, quantity: import("@wendellhu/redi").Quantity.MANY, lookUp?: import('@wendellhu/redi').LookUp): T[];
+        <T>(id: import('@wendellhu/redi').DependencyIdentifier<T>, quantity: import("@wendellhu/redi").Quantity.OPTIONAL, lookUp?: import('@wendellhu/redi').LookUp): T | null;
+        <T>(id: import('@wendellhu/redi').DependencyIdentifier<T>, quantity: import("@wendellhu/redi").Quantity.REQUIRED, lookUp?: import('@wendellhu/redi').LookUp): T;
+        <T>(id: import('@wendellhu/redi').DependencyIdentifier<T>, quantity?: import('@wendellhu/redi').Quantity, lookUp?: import('@wendellhu/redi').LookUp): T[] | T | null;
+        <T>(id: import('@wendellhu/redi').DependencyIdentifier<T>, quantityOrLookup?: import('@wendellhu/redi').Quantity | import('@wendellhu/redi').LookUp, lookUp?: import('@wendellhu/redi').LookUp): T[] | T | null;
+    };
+    sheet: Workbook;
+};

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

@@ -0,0 +1,23 @@
+import { IUniverInstanceService } from '@univerjs/core';
+/** Some special mutations. It a changeset contains the following mutations it should create a snapshot immediately. */
+export declare const SINGLE_SNAPSHOT_MUTATIONS: Set<string>;
+export declare const SINGLE_HISTORY_MUTATIONS: Set<string>;
+/**
+ * This service provide util functions to get revision number of a document or increment the revision number.
+ */
+export declare class RevisionService {
+    private readonly _univerInstanceService;
+    constructor(_univerInstanceService: IUniverInstanceService);
+    /**
+     * Get the current revision of a document.
+     * @param unitId
+     */
+    getCurrentRevOfUnit(unitId: string): number;
+    /**
+     * Increment the revision number of a document.
+     * @param unitId
+     * @returns The revision number after increment.
+     */
+    incrementRevOfUnit(unitId: string): number;
+    setRevOfUnit(unitId: string, rev: number): void;
+}

package/lib/types/services/snapshot/__tests__/snapshot-mock.d.ts

@@ -0,0 +1,27 @@
+import { IWorkbookData } from '@univerjs/core';
+import { ICopyFileMetaRequest, ICopyFileMetaResponse, IDeserializedSheetBlock, IFetchMissingChangesetsRequest, IFetchMissingChangesetsResponse, IGetDeserializedSheetBlockResponse, IGetLatestCsReqIdBySidRequest, IGetLatestCsReqIdBySidResponse, IGetResourcesRequest, IGetResourcesResponse, IGetSheetBlockRequest, IGetSheetBlockResponse, IGetUnitOnRevRequest, IGetUnitOnRevResponse, ISaveChangesetRequest, ISaveChangesetResponse, ISaveSheetBlockRequest, ISaveSheetBlockResponse, ISaveSnapshotRequest, ISaveSnapshotResponse, ISheetBlock, ISnapshot } from '@univerjs/protocol';
+import { ILogContext } from '../../../utils';
+import { ISnapshotServerService } from '../snapshot.service';
+export declare const testSnapshot: () => ISnapshot;
+export declare const testDeserializedSheetBlocks: () => IDeserializedSheetBlock[];
+export declare const testSheetBlocks: () => ISheetBlock[];
+export declare const testWorkbookData: () => IWorkbookData;
+export declare class MockSnapshotServerService implements ISnapshotServerService {
+    /** Load snapshot from a database. */
+    getUnitOnRev(context: ILogContext, params: IGetUnitOnRevRequest): Promise<IGetUnitOnRevResponse>;
+    /** Load sheet block from a database.  */
+    getSheetBlock(context: ILogContext, params: IGetSheetBlockRequest): Promise<IGetSheetBlockResponse>;
+    /** Load deserialized sheet block from a database.  */
+    getDeserializedSheetBlock(context: ILogContext, params: IGetSheetBlockRequest): Promise<IGetDeserializedSheetBlockResponse>;
+    /** Fetch missing changeset */
+    fetchMissingChangesets(context: ILogContext, params: IFetchMissingChangesetsRequest): Promise<IFetchMissingChangesetsResponse>;
+    getResourcesRequest(context: ILogContext, params: IGetResourcesRequest): Promise<IGetResourcesResponse>;
+    /** Save snapshot to a database. */
+    saveSnapshot(context: ILogContext, params: ISaveSnapshotRequest): Promise<ISaveSnapshotResponse>;
+    /** Save sheet block to a database. */
+    saveSheetBlock(context: ILogContext, params: ISaveSheetBlockRequest): Promise<ISaveSheetBlockResponse>;
+    /** Save changeset to a database. */
+    saveChangeset(context: ILogContext, params: ISaveChangesetRequest): Promise<ISaveChangesetResponse>;
+    copyFileMeta(context: ILogContext, params: ICopyFileMetaRequest): Promise<ICopyFileMetaResponse>;
+    getLatestCsReqIdBySid(context: ILogContext, params: IGetLatestCsReqIdBySidRequest): Promise<IGetLatestCsReqIdBySidResponse>;
+}

package/lib/types/services/snapshot/__tests__/snapshot-transform.spec.d.ts

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

package/lib/types/services/snapshot/__tests__/snapshot.service.spec.d.ts

@@ -0,0 +1,23 @@
+import { IRender, IRenderManagerService } from '@univerjs/engine-render';
+import { ICopyFileMetaRequest, ICopyFileMetaResponse, IFetchMissingChangesetsResponse, IGetDeserializedSheetBlockResponse, IGetLatestCsReqIdBySidResponse, IGetResourcesResponse, IGetSheetBlockRequest, IGetSheetBlockResponse, IGetUnitOnRevRequest, IGetUnitOnRevResponse, ISaveChangesetResponse, ISaveSheetBlockResponse, ISaveSnapshotResponse } from '@univerjs/protocol';
+import { Nullable } from 'vitest';
+import { ILogContext } from '../../../utils';
+import { Injector } from '@univerjs/core';
+import { ISnapshotServerService } from '../snapshot.service';
+export declare class MockRenderManagerService implements Pick<IRenderManagerService, 'getRenderById'> {
+    private readonly _injector;
+    constructor(_injector: Injector);
+    getRenderById(_unitId: string): Nullable<IRender>;
+}
+export declare class MockSnapshotServerService implements ISnapshotServerService {
+    getUnitOnRev(_context: ILogContext, params: IGetUnitOnRevRequest): Promise<IGetUnitOnRevResponse>;
+    getSheetBlock(_context: ILogContext, params: IGetSheetBlockRequest): Promise<IGetSheetBlockResponse>;
+    getDeserializedSheetBlock(_context: ILogContext, params: IGetSheetBlockRequest): Promise<IGetDeserializedSheetBlockResponse>;
+    fetchMissingChangesets(): Promise<IFetchMissingChangesetsResponse>;
+    getResourcesRequest(): Promise<IGetResourcesResponse>;
+    saveSnapshot(): Promise<ISaveSnapshotResponse>;
+    saveSheetBlock(): Promise<ISaveSheetBlockResponse>;
+    saveChangeset(): Promise<ISaveChangesetResponse>;
+    copyFileMeta(context: ILogContext, params: ICopyFileMetaRequest): Promise<ICopyFileMetaResponse>;
+    getLatestCsReqIdBySid(): Promise<IGetLatestCsReqIdBySidResponse>;
+}

package/lib/types/services/snapshot/snapshot-transform.d.ts

@@ -0,0 +1,30 @@
+import { IDocumentData, IWorkbookData } from '@univerjs/core';
+import { IDeserializedSheetBlock, ISheetBlock, ISnapshot } from '@univerjs/protocol';
+import { ILogContext } from '../../utils';
+import { ISnapshotServerService } from './snapshot.service';
+export declare function generateTempDocumentSnapshot(_context: ILogContext, document: IDocumentData, unitID: string, rev: number): Promise<{
+    snapshot: ISnapshot;
+}>;
+export declare function generateTemporarySnap(context: ILogContext, workbook: IWorkbookData, unitID: string, rev: number, snapshotService: ISnapshotServerService): Promise<{
+    snapshot: ISnapshot;
+}>;
+export declare function transformWorkbookDataToSnapshot(context: ILogContext, workbook: IWorkbookData, unitID: string, rev: number, snapshotService: ISnapshotServerService): Promise<{
+    snapshot: ISnapshot;
+}>;
+/**
+ * Assemble a snapshot to a workbook.
+ * @param snapshot
+ * @param sheetBlocks
+ */
+export declare function transformSnapshotToWorkbookData(snapshot: ISnapshot, sheetBlocks: (IDeserializedSheetBlock | ISheetBlock)[], _context?: ILogContext): IWorkbookData;
+export declare function transformSnapshotToDocumentData(snapshot: ISnapshot): IDocumentData;
+export declare function transformDocumentDataToSnapshot(context: ILogContext, document: IDocumentData, unitID: string, rev: number, snapshotService: ISnapshotServerService): Promise<{
+    snapshot: ISnapshot;
+}>;
+/**
+ *
+ * @param snapshot
+ * @param snapshotService
+ * @returns
+ */
+export declare function getSheetBlocksFromSnapshot(snapshot: ISnapshot, snapshotService: ISnapshotServerService): Promise<ISheetBlock[]>;

package/lib/types/services/snapshot/snapshot-utils.d.ts

@@ -0,0 +1,15 @@
+import { ICellData, IDocumentData, IObjectMatrixPrimitiveType, IWorkbookData, IWorksheetData } from '@univerjs/core';
+import { ISheetBlock } from '@univerjs/protocol';
+export declare const textEncoder: TextEncoder;
+export declare const textDecoder: TextDecoder;
+/**
+ * @param worksheet
+ */
+export declare function encodeWorksheetOtherMetas(worksheet: Partial<IWorksheetData>): Uint8Array;
+export declare function encodeWorkbookOtherMetas(workbook: IWorkbookData): Uint8Array;
+export declare function encodeDocOriginalMeta(document: IDocumentData): Uint8Array;
+export declare function decodeWorksheetOtherMetas(buffer: Uint8Array | string): Partial<IWorksheetData>;
+export declare function decodeWorkbookOtherMetas(buffer: Uint8Array | string): Partial<IWorkbookData>;
+export declare function decodePartOfCellData(buffer: Uint8Array | object): IObjectMatrixPrimitiveType<ICellData>;
+export declare function decodeDocOriginalMeta(buffer: Uint8Array | string): Partial<IDocumentData>;
+export declare function splitCellDataToBlocks(cellData: IObjectMatrixPrimitiveType<ICellData>, maxColumn: number): ISheetBlock[];

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

@@ -0,0 +1,46 @@
+import { DocumentDataModel, IDocumentData, IWorkbookData, Workbook, ICommandService, Injector, IResourceManagerService, IUniverInstanceService } from '@univerjs/core';
+import { ICopyFileMetaRequest, ICopyFileMetaResponse, IFetchMissingChangesetsRequest, IFetchMissingChangesetsResponse, IGetDeserializedSheetBlockResponse, IGetLatestCsReqIdBySidRequest, IGetLatestCsReqIdBySidResponse, IGetResourcesRequest, IGetResourcesResponse, IGetSheetBlockRequest, IGetSheetBlockResponse, IGetUnitOnRevRequest, IGetUnitOnRevResponse, ISaveChangesetRequest, ISaveChangesetResponse, ISaveSheetBlockRequest, ISaveSheetBlockResponse, ISaveSnapshotRequest, ISaveSnapshotResponse } from '@univerjs/protocol';
+import { ILogContext } from '../../utils';
+import { CompressMutationService } from '../compress-mutation/compress-mutation-service';
+import { RevisionService } from '../rev/rev.service';
+/**
+ * It provides implementations for server side controllers to load or save
+ * or load snapshots. This service should be implemented by the host environment.
+ * And it shouldn't contain any business logic.
+ */
+export declare const ISnapshotServerService: import('@wendellhu/redi').IdentifierDecorator<ISnapshotServerService>;
+export interface ISnapshotServerService {
+    /** Load snapshot from a database. */
+    getUnitOnRev: (context: ILogContext, params: IGetUnitOnRevRequest) => Promise<IGetUnitOnRevResponse>;
+    /** Load sheet block from a database. */
+    getSheetBlock: (context: ILogContext, params: IGetSheetBlockRequest) => Promise<IGetSheetBlockResponse>;
+    getDeserializedSheetBlock: (context: ILogContext, params: IGetSheetBlockRequest) => Promise<IGetDeserializedSheetBlockResponse>;
+    /** Fetch missing changeset */
+    fetchMissingChangesets: (context: ILogContext, params: IFetchMissingChangesetsRequest) => Promise<IFetchMissingChangesetsResponse>;
+    getResourcesRequest: (context: ILogContext, params: IGetResourcesRequest) => Promise<IGetResourcesResponse>;
+    /** Save snapshot to a database. */
+    saveSnapshot: (context: ILogContext, params: ISaveSnapshotRequest) => Promise<ISaveSnapshotResponse>;
+    /** Save sheet block to a database. */
+    saveSheetBlock: (context: ILogContext, params: ISaveSheetBlockRequest) => Promise<ISaveSheetBlockResponse>;
+    /** Save changeset to a database. */
+    saveChangeset: (context: ILogContext, params: ISaveChangesetRequest) => Promise<ISaveChangesetResponse>;
+    copyFileMeta: (context: ILogContext, params: ICopyFileMetaRequest) => Promise<ICopyFileMetaResponse>;
+    getLatestCsReqIdBySid: (context: ILogContext, params: IGetLatestCsReqIdBySidRequest) => Promise<IGetLatestCsReqIdBySidResponse>;
+}
+/**
+ * The service provides methods to load snapshots from the snapshot server.
+ */
+export declare class SnapshotService {
+    private readonly _revisionService;
+    private readonly _univerInstanceService;
+    private readonly _snapshotServerService;
+    private readonly _commandService;
+    private _injector;
+    private _compressMutationService;
+    private _resourceManagerService;
+    constructor(_revisionService: RevisionService, _univerInstanceService: IUniverInstanceService, _snapshotServerService: ISnapshotServerService, _commandService: ICommandService, _injector: Injector, _compressMutationService: CompressMutationService, _resourceManagerService: IResourceManagerService);
+    loadSheet(unitID: string, rev: number, context?: ILogContext): Promise<Workbook>;
+    loadDoc(unitID: string, rev: number, context?: ILogContext): Promise<DocumentDataModel>;
+    save(_context: ILogContext, workbook: Workbook): IWorkbookData;
+    saveDoc(_context: ILogContext, document: DocumentDataModel): IDocumentData;
+}

package/lib/types/services/transform/__tests__/doc.transform.service.spec.d.ts

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

package/lib/types/services/transform/__tests__/transform.service.spec.d.ts

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