@univerjs-pro/collaboration 0.1.10

package/lib/types/plugin.d.ts

@@ -0,0 +1,12 @@
+import { Injector } from '@wendellhu/redi';
+import { Plugin } from '@univerjs/core';
+
+export interface ICollaborationPluginConfig {
+}
+export declare class CollaborationPlugin extends Plugin {
+    private _config;
+    protected _injector: Injector;
+    static pluginName: string;
+    constructor(_config: ICollaborationPluginConfig, _injector: Injector);
+    onStarting(injector: Injector): void;
+}

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

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

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

@@ -0,0 +1,20 @@
+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,16 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};

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

@@ -0,0 +1,14 @@
+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/rev/__tests__/rev.service.spec.d.ts

@@ -0,0 +1,20 @@
+import { Dependency, Injector } from '@wendellhu/redi';
+import { IWorkbookData, PluginCtor, Workbook, 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 | undefined): T;
+        <T_1>(id: import('@wendellhu/redi').DependencyIdentifier<T_1>, quantity: import("@wendellhu/redi").Quantity.MANY, lookUp?: import('@wendellhu/redi').LookUp | undefined): T_1[];
+        <T_2>(id: import('@wendellhu/redi').DependencyIdentifier<T_2>, quantity: import("@wendellhu/redi").Quantity.OPTIONAL, lookUp?: import('@wendellhu/redi').LookUp | undefined): T_2 | null;
+        <T_3>(id: import('@wendellhu/redi').DependencyIdentifier<T_3>, quantity: import("@wendellhu/redi").Quantity.REQUIRED, lookUp?: import('@wendellhu/redi').LookUp | undefined): T_3;
+        <T_4>(id: import('@wendellhu/redi').DependencyIdentifier<T_4>, quantity?: import('@wendellhu/redi').Quantity | undefined, lookUp?: import('@wendellhu/redi').LookUp | undefined): T_4 | T_4[] | null;
+        <T_5>(id: import('@wendellhu/redi').DependencyIdentifier<T_5>, quantityOrLookup?: import('@wendellhu/redi').Quantity | import('@wendellhu/redi').LookUp | undefined, lookUp?: import('@wendellhu/redi').LookUp | undefined): T_5 | T_5[] | null;
+    };
+    sheet: Workbook;
+};

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

@@ -0,0 +1,23 @@
+import { ILogService, 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>;
+/**
+ * This service provide util functions to get revision number of a document or increment the revision number.
+ */
+export declare class RevisionService {
+    private readonly _univerInstanceService;
+    private readonly _logService;
+    constructor(_univerInstanceService: IUniverInstanceService, _logService: ILogService);
+    /**
+     * Get the current revision of a document.
+     * @param unitID
+     */
+    getCurrentRevForDocument(unitID: string): number;
+    /**
+     * Increment the revision number of a document.
+     * @param unitID
+     * @returns The revision number after increment.
+     */
+    incrementRevForDocument(unitID: string): number;
+}

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

@@ -0,0 +1,12 @@
+import { IFetchMissingChangesetsResponse, IGetResourcesResponse, IGetSheetBlockRequest, IGetSheetBlockResponse, IGetUnitOnRevRequest, IGetUnitOnRevResponse, ISaveChangesetResponse, ISaveSheetBlockResponse, ISaveSnapshotResponse } from '@univerjs/protocol';
+import { ILogContext, ISnapshotServerService } from '@univerjs/core';
+
+export declare class MockSnapshotServerService implements ISnapshotServerService {
+    getUnitOnRev(_context: ILogContext, params: IGetUnitOnRevRequest): Promise<IGetUnitOnRevResponse>;
+    getSheetBlock(_context: ILogContext, params: IGetSheetBlockRequest): Promise<IGetSheetBlockResponse>;
+    fetchMissingChangesets(): Promise<IFetchMissingChangesetsResponse>;
+    getResourcesRequest(): Promise<IGetResourcesResponse>;
+    saveSnapshot(): Promise<ISaveSnapshotResponse>;
+    saveSheetBlock(): Promise<ISaveSheetBlockResponse>;
+    saveChangeset(): Promise<ISaveChangesetResponse>;
+}

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

@@ -0,0 +1,22 @@
+import { RevisionService } from '../rev/rev.service';
+import { CompressMutationService } from '../compress-mutation/compress-mutation-service';
+import { Injector } from '@wendellhu/redi';
+import { DocumentDataModel, IDocumentData, ILogContext, IWorkbookData, Workbook, ICommandService, IResourceManagerService, ISnapshotServerService, IUniverInstanceService } from '@univerjs/core';
+
+/**
+ * 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 {};

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

@@ -0,0 +1,115 @@
+import { IFailureTransformChangesetsResult, IFailureTransformMutationResult, IFailureTransformMutationsResult, ISuccessTransformChangesetsResult, ISuccessTransformMutationResult, ISuccessTransformMutationsResult, ITransformChangesetsResult, ITransformMutationResult, ITransformMutationsResult, ITransformMutationsWithChangesetResult } from './types';
+import { IChangeset } from '../../models/changeset';
+import { IMutationInfo, Disposable } from '@univerjs/core';
+
+/**
+ * A single transform algorithm. Algorithms are registered to the transform service in the form of `{m1}-{m2}`.
+ * When the transform service is transforming two mutations, it would find the algorithm by the form of `{m1}-{m2}`.
+ * `m1` is the mutation on the left side, and `m2` is the mutation on the right side.
+ */
+export interface IMutationTransformAlgorithm<M extends object = any, N extends object = any> {
+    m1: string;
+    m2?: string | 'any';
+    handler(m1: IMutationInfo<M>, m2: IMutationInfo<N>): ITransformMutationResult;
+    handler(m1: IMutationInfo<M>, m2: IMutationInfo<N>, onlyLater?: true): Omit<ISuccessTransformMutationResult, 'm1Prime'> | IFailureTransformMutationResult;
+}
+/**
+ * This service's responsibility is to transform mutations (changesets).
+ *
+ * Features could register transform algorithms to this service, so this the service could transform more mutations.
+ *
+ * This should be used both on client and server.
+ *
+ * This service is also business-agnostic, so it could be used in docs, sheets and slides.
+ */
+export interface ITransformService {
+    /**
+     * Register an algorithm to transform two kinds of mutations.
+     *
+     * Note that this method is not the same as other registering methods in Univer, it wouldn't return a disposable,
+     * because it would cause critical problems if you unregister a transform algorithm.
+     */
+    registerTransformAlgorithm: (algorithms: IMutationTransformAlgorithm) => void;
+    /**
+     * Transform two single mutations. Note that m1Prime and m2Prime may not be single mutations. 1x1 may result in nxn.
+     *
+     * @internal
+     *
+     * Visualization:
+     *
+     *                    /\
+     *               m1  /  \  m2
+     *                  /    \
+     *                  \    /
+     *        m2Prime    \  /    m1Prime
+     *                    \/
+     *
+     * @param m1
+     * @param m2
+     * @param onlyLeft If set to true, the result would only contain m1Prime.
+     */
+    transformMutation(m1: IMutationInfo, m2: IMutationInfo): IFailureTransformMutationResult | Omit<ISuccessTransformMutationResult, 'm1Prime'>;
+    transformMutation(m1: IMutationInfo, m2: IMutationInfo, onlyLater: false): ITransformMutationResult;
+    /**
+     * Transform two array of mutations. Not that the time complexity (also memory complexity) of this method is O(m*n),
+     * in which m & n are numbers of mutations in each array.
+     *
+     * @internal
+     *
+     * Visualization:
+     *
+     *                    /\
+     *               m1  /  \  m2
+     *                  /    \
+     *                 /\    /\
+     *                /  \  /  \
+     *               /    \/    \
+     *               \    /\    /
+     *                \  /  \  /
+     *                 \/    \/
+     *                  \    /
+     *                   \  /
+     *         m2Prime    \/    m1Prime
+     *
+     * @param m1
+     * @param m2
+     */
+    transformMutations(m1: IMutationInfo[], m2: IMutationInfo[]): IFailureTransformMutationsResult | Omit<ISuccessTransformMutationsResult, 'm1Prime'>;
+    transformMutations(m1: IMutationInfo[], m2: IMutationInfo[], onlyLater: boolean): ITransformMutationsResult;
+    /**
+     * Transform two arrays of changesets
+     *
+     * @internal
+     */
+    transformChangesets(c1: IChangeset[], c2: IChangeset[]): IFailureTransformChangesetsResult | Omit<ISuccessTransformChangesetsResult, 'c1Prime'>;
+    transformChangesets(c1: IChangeset[], c2: IChangeset[], onlyLater: false): ITransformChangesetsResult;
+    /**
+     * Transform mutations with changesets. We only wants transformed mutations here.
+     *
+     * @internal
+     */
+    transformMutationsWithChangeset: (c1: IChangeset, m2: IMutationInfo[]) => ITransformMutationsWithChangesetResult;
+}
+export declare const ITransformService: import('@wendellhu/redi').IdentifierDecorator<ITransformService>;
+export declare class TransformService extends Disposable implements ITransformService {
+    private readonly _transformMap;
+    dispose(): void;
+    registerTransformAlgorithm(algorithm: IMutationTransformAlgorithm): void;
+    transformMutation(m1: IMutationInfo, m2: IMutationInfo): ITransformMutationResult;
+    transformMutation(m1: IMutationInfo, m2: IMutationInfo, onlyLater: true): IFailureTransformMutationResult | Omit<ISuccessTransformMutationResult, 'm1Prime'>;
+    transformMutations(m1: IMutationInfo[], m2: IMutationInfo[]): ITransformMutationsResult;
+    transformMutations(m1: IMutationInfo[], m2: IMutationInfo[], onlyLater: true): IFailureTransformMutationsResult | Omit<ISuccessTransformMutationsResult, 'm1Prime'>;
+    /**
+     * Assume `m1` has already applied to the document, we need m2Prime to be applied to the document.
+     *
+     * @param m1
+     * @param m2
+     * @returns transformed mutations of m2
+     */
+    private _rightInclineTransformMutations;
+    private _leftInclineTransformMutations;
+    transformChangesets(c1: IChangeset[], c2: IChangeset[]): ITransformChangesetsResult;
+    transformChangesets(c1: IChangeset[], c2: IChangeset[], onlyLater: true): IFailureTransformChangesetsResult | Omit<ISuccessTransformChangesetsResult, 'c1Prime'>;
+    transformMutationsWithChangeset(c1: IChangeset, m2: IMutationInfo[]): ITransformMutationsWithChangesetResult;
+}
+export declare function makeArray<T>(input: T | T[]): T[];

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

@@ -0,0 +1,48 @@
+import { IChangeset } from '../../models/changeset';
+import { IMutationInfo } from '@univerjs/core';
+
+export interface ISuccessTransformMutationResult {
+    m1Prime: IMutationInfo | IMutationInfo[];
+    m2Prime: IMutationInfo | IMutationInfo[];
+}
+export interface IFailureTransformMutationResult {
+    error: Error;
+}
+export type ITransformMutationResult = ISuccessTransformMutationResult | IFailureTransformMutationResult;
+export declare function isTransformMutationFailure(result: ITransformMutationResult | Omit<ISuccessTransformMutationResult, 'm1Prime'>): result is IFailureTransformMutationResult;
+export declare function isTransformMutationSuccess(result: ITransformMutationResult | Omit<ISuccessTransformMutationResult, 'm1Prime'>): result is ISuccessTransformMutationResult;
+export interface IFailureInclineTransformMutationsResult {
+    error: Error;
+}
+export type IInclineTransformMutationsResult = IMutationInfo[] | IFailureInclineTransformMutationsResult;
+export declare function isInclineTransformMutationsFailure(result: IInclineTransformMutationsResult): result is IFailureInclineTransformMutationsResult;
+export interface ISuccessTransformMutationsResult {
+    m1Prime: IMutationInfo[];
+    m2Prime: IMutationInfo[];
+}
+export interface IFailureTransformMutationsResult {
+    error: Error;
+}
+export type ITransformMutationsResult = ISuccessTransformMutationsResult | IFailureTransformMutationsResult;
+export declare function isTransformMutationsFailure(result: Partial<ITransformMutationsResult>): result is IFailureTransformMutationsResult;
+export declare function isTransformMutationsSuccess(result: Partial<ITransformMutationsResult>): result is ISuccessTransformMutationsResult;
+export interface ISuccessTransformChangesetsResult {
+    c1Prime: IChangeset[];
+    c2Prime: IChangeset[];
+}
+export interface IFailureTransformChangesetsResult {
+    error: Error;
+}
+export type ITransformChangesetsResult = ISuccessTransformChangesetsResult | IFailureTransformChangesetsResult;
+export declare function isTransformChangesetsFailure(result: Partial<ITransformChangesetsResult>): result is IFailureTransformChangesetsResult;
+export declare function isTransformChangesetsSuccess(result: Partial<ITransformChangesetsResult>): result is ISuccessTransformChangesetsResult;
+export interface ISuccessTransformMutationsWithChangesetResult {
+    c1Prime: IChangeset;
+    m2Prime: IMutationInfo[];
+}
+export interface IFailureTransformMutationsWithChangesetResult {
+    error: Error;
+}
+export type ITransformMutationsWithChangesetResult = ISuccessTransformMutationsWithChangesetResult | IFailureTransformMutationsWithChangesetResult;
+export declare function isTransformMutationsWithChangesetFailure(result: ITransformMutationsWithChangesetResult): result is IFailureTransformMutationsWithChangesetResult;
+export declare function isTransformMutationsWithChangesetSuccess(result: ITransformMutationsWithChangesetResult): result is ISuccessTransformMutationsWithChangesetResult;

package/lib/types/utils.d.ts

@@ -0,0 +1,4 @@
+import { UniverType } from '@univerjs/protocol';
+import { UniverInstanceType } from '@univerjs/core';
+
+export declare function mapDocumentTypeToUniverType(documentType: UniverInstanceType): UniverType;