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

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

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

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

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