@univerjs-pro/collaboration 0.4.2 → 0.5.0-alpha.0

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

@@ -1,46 +0,0 @@
-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

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

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

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

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

@@ -1,114 +0,0 @@
-import { Disposable, IMutationInfo } from '@univerjs/core';
-import { IChangeset } from '../../models/changeset';
-import { IFailureTransformChangesetsResult, IFailureTransformMutationResult, IFailureTransformMutationsResult, ISuccessTransformChangesetsResult, ISuccessTransformMutationResult, ISuccessTransformMutationsResult, ITransformChangesetsResult, ITransformMutationResult, ITransformMutationsResult, ITransformMutationsWithChangesetResult } from './types';
-/**
- * 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

@@ -1,47 +0,0 @@
-import { IMutationInfo } from '@univerjs/core';
-import { IChangeset } from '../../models/changeset';
-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

@@ -1,8 +0,0 @@
-import { UniverInstanceType } from '@univerjs/core';
-import { UniverType } from '@univerjs/protocol';
-export declare function mapDocumentTypeToUniverType(documentType: UniverInstanceType): UniverType;
-export interface ILogContext {
-    metadata?: Record<string, string>;
-}
-export declare function b64EncodeUnicode(str: string): string;
-export declare function b64DecodeUnicode(str: string): string;