@univerjs-pro/sheets-history-ui 1.0.0-rc.0

package/lib/types/viewer/mobile-plugin.d.ts

@@ -0,0 +1,16 @@
+import type { IUniverSheetsHistoryUIConfig } from '../config/config';
+import { IConfigService, Injector, Plugin } from '@univerjs/core';
+import { IRenderManagerService } from '@univerjs/engine-render';
+export declare class SheetsHistoryViewerMobileUIPlugin extends Plugin {
+    private readonly _config;
+    protected _injector: Injector;
+    private readonly _renderManagerService;
+    private readonly _configService;
+    static pluginName: string;
+    static packageName: string;
+    static version: string;
+    constructor(_config: IUniverSheetsHistoryUIConfig | undefined, _injector: Injector, _renderManagerService: IRenderManagerService, _configService: IConfigService);
+    onStarting(): void;
+    onRendered(): void;
+    onSteady(): void;
+}

package/lib/types/viewer/plugin.d.ts

@@ -0,0 +1,16 @@
+import type { IUniverSheetsHistoryUIConfig } from '../config/config';
+import { IConfigService, Injector, Plugin } from '@univerjs/core';
+import { IRenderManagerService } from '@univerjs/engine-render';
+export declare class SheetsHistoryViewerPlugin extends Plugin {
+    private readonly _config;
+    protected _injector: Injector;
+    private readonly _renderManagerService;
+    private readonly _configService;
+    static pluginName: string;
+    static packageName: string;
+    static version: string;
+    constructor(_config: IUniverSheetsHistoryUIConfig | undefined, _injector: Injector, _renderManagerService: IRenderManagerService, _configService: IConfigService);
+    onStarting(): void;
+    onRendered(): void;
+    onSteady(): void;
+}

package/lib/types/viewer/services/disable-dialog.service.d.ts

@@ -0,0 +1,13 @@
+import type { IDisposable } from '@univerjs/core';
+import type { IDialogPartMethodOptions, IDialogService } from '@univerjs/ui';
+import type { Observable } from 'rxjs';
+import { Disposable } from '@univerjs/core';
+import { Subject } from 'rxjs';
+export declare class DisableDialogService extends Disposable implements IDialogService {
+    protected readonly _dialogOptions$: Subject<IDialogPartMethodOptions[]>;
+    constructor();
+    open(): IDisposable;
+    close(): void;
+    closeAll(_expectIds?: string[]): void;
+    getDialogs$(): Observable<IDialogPartMethodOptions[]>;
+}

package/lib/types/viewer/services/history-fetch.service.d.ts

@@ -0,0 +1,106 @@
+import type { ILogContext } from '@univerjs-pro/collaboration';
+import type { Nullable, Workbook } from '@univerjs/core';
+import type { IGetHistoryCsRequest, IGetHistoryCsResponse } from '@univerjs/protocol';
+import { CompressMutationService, ISnapshotServerService } from '@univerjs-pro/collaboration';
+import { Disposable, ICommandService, IConfigService, IPermissionService, IUniverInstanceService } from '@univerjs/core';
+import { IDrawingManagerService } from '@univerjs/drawing';
+import { HTTPService } from '@univerjs/network';
+import { SheetPermissionInitController } from '@univerjs/sheets';
+export interface IHistoryVersion {
+    unitId: string;
+    id: string;
+    startRev: number;
+    endRev: number;
+    time?: number;
+    user: string;
+    users: string[];
+    recoverTime?: number;
+    commands: string[];
+    isAnonymous: boolean;
+    additionalFields?: string;
+    startRevCreateTime?: number;
+    endRevCreateTime?: number;
+}
+export interface IServiceVersionsData {
+    hasMore: boolean;
+    lastLabel: string;
+    entities: {
+        datas: Record<string, IVersionItem>;
+        users: Record<string, IUser>;
+    };
+    historyIds: string[];
+}
+export interface IVersionItem {
+    unitId: string;
+    userId: string;
+    userIds: string[];
+    command: string[];
+    createTime: number;
+    startRevision: number;
+    endRevision: number;
+    recoverTime?: string;
+    additionalFields?: string;
+    startRevCreateTime: number;
+    endRevCreateTime: number;
+}
+export interface IUser {
+    userID: string;
+    name: string;
+    avatar: string;
+    anonymous: boolean;
+    canBindAnonymous: boolean;
+}
+/**
+ * @description The origin of the history
+ */
+export declare enum HistoryOrigin {
+    Unspecified = 0,
+    User = 1,
+    Character = 2
+}
+export interface IHistoryCreator {
+    userId: string;
+    name: string;
+    avatar: string;
+    origins: HistoryOrigin[];
+}
+export declare class HistoryFetchService extends Disposable {
+    private readonly _snapshotServerService;
+    private readonly _univerInstanceService;
+    private readonly _commandService;
+    private readonly _permissionService;
+    private readonly _drawingManagerService;
+    private readonly _configService;
+    private readonly _httpService;
+    private _compressMutationService;
+    private _sheetPermissionInitController;
+    /**
+     * ✅ LRU cache for workbookData by (unitID, rev).
+     * Key: `${unitID}:${rev}`
+     * Value: IWorkbookData
+     *
+     * No _inflight, no _loadToken — outer layer is assumed to serialize loadSheet calls.
+     */
+    private _workbookDataCache;
+    constructor(_snapshotServerService: ISnapshotServerService, _univerInstanceService: IUniverInstanceService, _commandService: ICommandService, _permissionService: IPermissionService, _drawingManagerService: IDrawingManagerService, _configService: IConfigService, _httpService: HTTPService, _compressMutationService: CompressMutationService, _sheetPermissionInitController: SheetPermissionInitController);
+    dispose(): void;
+    fetchCreatorList(unitID: string): Promise<IHistoryCreator[]>;
+    getVersions(unitID: string, params?: {
+        userIds?: string[];
+        lastLabel?: string;
+        origin?: HistoryOrigin;
+    }): Promise<Nullable<{
+        hasMore: boolean;
+        lastLabel: string;
+        versions: IHistoryVersion[];
+        members: Record<string, IUser>;
+    }>>;
+    getHistoryChangesets(_context: ILogContext, params: IGetHistoryCsRequest): Promise<IGetHistoryCsResponse>;
+    private _getAPIPrefix;
+    private _cacheKey;
+    loadSheet(unitID: string, rev: number, context?: ILogContext): Promise<boolean>;
+    private _applyWorkbookData;
+    private _createUnit;
+}
+export declare function disableHistoryWorkbookEditing(permissionService: IPermissionService, drawingManagerService: IDrawingManagerService, workbook: Workbook): void;
+export declare function convertEntitiesToVersions(data: IServiceVersionsData): IHistoryVersion[];

package/lib/types/viewer/services/history-manager.service.d.ts

@@ -0,0 +1,84 @@
+import type { HistoryOrigin, IHistoryCreator, IHistoryVersion, IUser } from './history-fetch.service';
+import { Disposable, IConfirmService, ILogService, LocaleService } from '@univerjs/core';
+import { IMessageService } from '@univerjs/ui';
+import { HistoryFetchService } from './history-fetch.service';
+export declare enum HistoryModeStatus {
+    Entered = "entered",
+    Exited = "exited",
+    Error = "error"
+}
+export declare enum LoadingState {
+    Init = "init",
+    Loading = "loading",
+    Loaded = "loaded",
+    Error = "error"
+}
+export declare const VIRTUAL_VERSION_NOW = "VIRTUAL_VERSION_NOW";
+export declare class HistoryManagerService extends Disposable {
+    private readonly _messageService;
+    private readonly _confirmService;
+    private readonly _logService;
+    private readonly _localeService;
+    private readonly _historyFetchService;
+    private _versions$;
+    readonly versions$: import("rxjs").Observable<IHistoryVersion[]>;
+    private _currentVersion$;
+    readonly currentVersion$: import("rxjs").Observable<string>;
+    private _status$;
+    readonly status$: import("rxjs").Observable<HistoryModeStatus>;
+    private _revertRevision$;
+    readonly revertRevision$: import("rxjs").Observable<number>;
+    private _unitId$;
+    readonly unitId$: import("rxjs").Observable<string | null>;
+    private _fetching$;
+    readonly fetching$: import("rxjs").Observable<boolean>;
+    private _creators$;
+    readonly creators$: import("rxjs").Observable<IHistoryCreator[]>;
+    private _openPanel$;
+    readonly openPanel$: import("rxjs").Observable<boolean>;
+    private _detailVersionsMap;
+    private _setFetching;
+    get fetching(): boolean;
+    private _loadingState$;
+    readonly loadingState$: import("rxjs").Observable<LoadingState>;
+    private _lastLabel;
+    private _hasMore;
+    private _members;
+    private _canRevert;
+    private _loadParams;
+    private _unitCurrentVersionMap;
+    constructor(_messageService: IMessageService, _confirmService: IConfirmService, _logService: ILogService, _localeService: LocaleService, _historyFetchService: HistoryFetchService);
+    triggerLoadVersions(unitId: string, canRevert: boolean): Promise<void>;
+    triggerCustomVersions(unitId: string, canRevert: boolean, param: {
+        hasMore: boolean;
+        lastLabel: string;
+        versions: IHistoryVersion[];
+        members: Record<string, IUser>;
+    }): void;
+    loadInitialVersions(unitId: string, params?: {
+        userIds?: string[];
+        origin?: HistoryOrigin;
+    }): Promise<void>;
+    loadMoreVersions(): Promise<boolean>;
+    loadHistoryCreatorList(): Promise<void>;
+    triggerLoadSheet(versionId: string): Promise<void>;
+    triggerRevert(id?: string): Promise<void>;
+    private _updateVersions;
+    getCurrentVersion(): IHistoryVersion | undefined;
+    private _setVersions;
+    getVersion(id: string): IHistoryVersion | undefined;
+    registerDetailVersion(version: IHistoryVersion): void;
+    getCurrentUnitCurrentVersion(): number | undefined;
+    getSelectedVersionIsCurrentVersion(): boolean;
+    getSelectedVersionCanRevert(): boolean;
+    getMember(id: string): IUser | undefined;
+    exitHistoryMode(): void;
+    set status(value: HistoryModeStatus);
+    get status(): HistoryModeStatus;
+    selectVersion(value: string): void;
+    get currentVersion(): string;
+    set unitId(value: string | null);
+    get unitId(): string | null;
+    get canRevert(): boolean;
+    get loadingState(): LoadingState;
+}

package/lib/types/viewer/services/sheets-history-diff-color.service.d.ts

@@ -0,0 +1,16 @@
+import type { HistoryChangeKind } from '@univerjs-pro/edit-history';
+import type { Observable } from 'rxjs';
+import { Disposable, ThemeService } from '@univerjs/core';
+export interface ISheetsHistoryDiffStyle {
+    readonly fill: string;
+    readonly stroke: string;
+}
+export type SheetsHistoryDiffPalette = Readonly<Record<HistoryChangeKind, ISheetsHistoryDiffStyle>>;
+export declare class SheetsHistoryDiffColorService extends Disposable {
+    private readonly _themeService;
+    private readonly _palette$;
+    readonly palette$: Observable<SheetsHistoryDiffPalette>;
+    constructor(_themeService: ThemeService);
+    private _createPalette;
+    private _createStyle;
+}

package/lib/types/viewer/services/version-diff.service.d.ts

@@ -0,0 +1,89 @@
+import type { IMutationInfo, IRange } from '@univerjs/core';
+import { ISnapshotServerService, ITransformService } from '@univerjs-pro/collaboration';
+import { SheetsChartService } from '@univerjs-pro/sheets-chart';
+import { SheetsPivotTableConfigModel } from '@univerjs-pro/sheets-pivot';
+import { SparklineDataSourceModel } from '@univerjs-pro/sheets-sparkline';
+import { Disposable, LocaleService } from '@univerjs/core';
+import { RangeProtectionRuleModel } from '@univerjs/sheets';
+import { ConditionalFormattingRuleModel } from '@univerjs/sheets-conditional-formatting';
+import { SheetDataValidationModel } from '@univerjs/sheets-data-validation';
+import { SheetsFilterService } from '@univerjs/sheets-filter';
+import { SheetTableService } from '@univerjs/sheets-table';
+import { HistoryFetchService } from './history-fetch.service';
+import { HistoryManagerService } from './history-manager.service';
+export interface ISheetRange {
+    unitId: string;
+    subUnitId: string;
+    range: IRange;
+    highlightRow?: boolean;
+    highlightColumn?: boolean;
+    showText?: string;
+}
+export interface ISheetDrawing {
+    unitId: string;
+    subUnitId: string;
+    drawingId: string;
+    showText?: string;
+}
+export interface IVersionDiff {
+    ranges: Map<string, ISheetRange[]>;
+    insertCellRanges?: Map<string, ISheetRange[]>;
+    deleteCellRanges?: Map<string, ISheetRange[]>;
+    updateCellRanges?: Map<string, ISheetRange[]>;
+    insertBorderRanges?: Map<string, ISheetRange[]>;
+    deleteBorderRanges?: Map<string, ISheetRange[]>;
+    updateBorderRanges?: Map<string, ISheetRange[]>;
+    arrowRowRanges?: Map<string, ISheetRange[]>;
+    arrowColumnRanges?: Map<string, ISheetRange[]>;
+    updateDrawings?: Map<string, ISheetDrawing[]>;
+    insertDrawings?: Map<string, ISheetDrawing[]>;
+    deleteDrawings?: Map<string, ISheetDrawing[]>;
+    subUnitIds: string[];
+    active: string | null;
+}
+export interface IMutationInfoWithMemberId extends IMutationInfo {
+    memberId: string;
+}
+export declare class VersionDiffService extends Disposable {
+    private readonly _historyManagerService;
+    private readonly _transformService;
+    private readonly _snapshotServerService;
+    private readonly _rangeProtectionRuleModel;
+    private _conditionalFormattingRuleModel;
+    private _dataValidationModel;
+    private _sheetsFilterService;
+    private readonly _sparklineDataSourceModel;
+    private readonly _sheetsPivotTableConfigModel;
+    private _sheetTableService;
+    protected readonly _localeService: LocaleService;
+    private readonly _sheetsChartService;
+    private readonly _historyFetchService;
+    private _diffRangesMap;
+    private _currentVersionDiff$;
+    readonly currentVersionDiff$: import("rxjs").Observable<IVersionDiff>;
+    constructor(_historyManagerService: HistoryManagerService, _transformService: ITransformService, _snapshotServerService: ISnapshotServerService, _rangeProtectionRuleModel: RangeProtectionRuleModel, _conditionalFormattingRuleModel: ConditionalFormattingRuleModel, _dataValidationModel: SheetDataValidationModel, _sheetsFilterService: SheetsFilterService, _sparklineDataSourceModel: SparklineDataSourceModel, _sheetsPivotTableConfigModel: SheetsPivotTableConfigModel, _sheetTableService: SheetTableService, _localeService: LocaleService, _sheetsChartService: SheetsChartService, _historyFetchService: HistoryFetchService);
+    private _init;
+    ensureVersion(versionId: string): Promise<void>;
+    getMutationActionMap(): Map<string, string>;
+    categorizeMutationRanges(mutation: IMutationInfo, mutationActionMap: Map<string, string>): {
+        allRanges: ISheetRange[];
+        insertCellRanges: ISheetRange[];
+        deleteCellRanges: ISheetRange[];
+        updateCellRanges: ISheetRange[];
+        insertBorderRanges: ISheetRange[];
+        deleteBorderRanges: ISheetRange[];
+        updateBorderRanges: ISheetRange[];
+        arrowRowRanges: ISheetRange[];
+        arrowColumnRanges: ISheetRange[];
+        insertDrawings: ISheetDrawing[];
+        deleteDrawings: ISheetDrawing[];
+        updateDrawings: ISheetDrawing[];
+        subUnitIds: string[];
+    };
+    private _transformMutationByOrder;
+    private _yieldToMain;
+    private _getActiveSubUnitId;
+    private _extractRanges;
+    private _categorizeMutationRanges;
+    private _combineRanges;
+}

package/lib/types/viewer/views/HistoryLoadingMask.d.ts

@@ -0,0 +1 @@
+export declare function HistoryLoadingMask(): import("react").JSX.Element | null;

package/lib/types/viewer/views/HistoryViewHeader.d.ts

@@ -0,0 +1 @@
+export declare function HistoryViewHeader(): import("react").JSX.Element;

package/lib/types/viewer/views/MobileHistoryViewHeader.d.ts

@@ -0,0 +1 @@
+export declare function MobileHistoryViewHeader(): import("react").JSX.Element;

package/lib/types/viewer/views/MobileVersionListPanel.d.ts

@@ -0,0 +1 @@
+export declare function MobileVersionListPanel(): import("react").JSX.Element;

package/lib/types/viewer/views/VersionListPanel.d.ts

@@ -0,0 +1,21 @@
+import type { IHistoryVersion } from '../services/history-fetch.service';
+export interface IVersionWitDate {
+    versions: IHistoryVersion[];
+    dateString: string;
+    startDateString: string;
+    endDateString: string;
+}
+export declare function VersionListPanel(): import("react").JSX.Element;
+export declare function Empty(): import("react").JSX.Element;
+export declare function VersionDate(props: {
+    date: string;
+    startDate?: string;
+    endDate?: string;
+}): import("react").JSX.Element;
+export declare function VersionItem(props: {
+    item: IHistoryVersion;
+    onToggleExpand?: (version: IHistoryVersion) => Promise<void>;
+    isExpanded?: boolean;
+    isLoadingDetail?: boolean;
+    isDetail?: boolean;
+}): import("react").JSX.Element;

package/lib/types/viewer/views/all-mutations.d.ts

@@ -0,0 +1,101 @@
+/**
+ * All mutations collected from the Univer Pro project
+ * Organized by plugin/package with comments indicating the source
+ *
+ * Note: The action field uses locale keys with the format `${localePrefix}actionName`
+ * You may need to add corresponding translations in your locale files
+ */
+/**
+ * All mutations organized by plugin
+ * Format: { id: MutationClass.id, action: `${localePrefix}actionKey` }
+ */
+export declare function getAllMutations(localePrefix?: string): {
+    collaboration: {
+        id: string;
+        action: string;
+    }[];
+    sheets: {
+        id: string;
+        action: string;
+    }[];
+    sheetsConditionalFormatting: {
+        id: string;
+        action: string;
+    }[];
+    sheetsFilter: {
+        id: string;
+        action: string;
+    }[];
+    dataValidation: {
+        id: string;
+        action: string;
+    }[];
+    sheetsChart: {
+        id: string;
+        action: string;
+    }[];
+    sheetsSparkline: {
+        id: string;
+        action: string;
+    }[];
+    sheetsPivot: {
+        id: string;
+        action: string;
+    }[];
+    sheetsShape: {
+        id: string;
+        action: string;
+    }[];
+    sheetsTable: {
+        id: string;
+        action: string;
+    }[];
+    sheetsDrawing: {
+        id: string;
+        action: string;
+    }[];
+};
+/**
+ * Get a flat array of all mutations
+ */
+export declare function getAllMutationsFlat(localePrefix?: string): ({
+    id: string;
+    action: string;
+} | {
+    id: string;
+    action: string;
+} | {
+    id: string;
+    action: string;
+} | {
+    id: string;
+    action: string;
+} | {
+    id: string;
+    action: string;
+} | {
+    id: string;
+    action: string;
+} | {
+    id: string;
+    action: string;
+} | {
+    id: string;
+    action: string;
+} | {
+    id: string;
+    action: string;
+} | {
+    id: string;
+    action: string;
+} | {
+    id: string;
+    action: string;
+})[];
+/**
+ * Get mutations for specific plugins
+ */
+export declare function getMutationsByPlugins(plugins: string[], localePrefix?: string): {
+    id: string;
+    action: string;
+}[];

package/lib/types/viewer/views/shapes/sheet-history-arrow.shape.d.ts

@@ -0,0 +1,29 @@
+import type { IMouseEvent, IPointerEvent, IShapeProps } from '@univerjs/engine-render';
+import { Shape } from '@univerjs/engine-render';
+export declare const SHEET_HISTORY_ARROW_ZINDEX = 1;
+export declare const SHEET_HISTORY_ARROW_BORDER_WIDTH = 4;
+export declare const ARROW_HEAD_SIZE = 12;
+export interface ISheetHistoryArrowShapeProps extends IShapeProps {
+    color: string;
+    direction: 'horizontal' | 'vertical';
+    highlight?: boolean;
+    highlightSecond?: number;
+}
+export declare class SheetHistoryArrowShape<T extends ISheetHistoryArrowShapeProps = ISheetHistoryArrowShapeProps> extends Shape<T> {
+    private _color;
+    private _direction;
+    private _highlight;
+    private _highlightSecond;
+    private _blinkTimer?;
+    private _blinkIntervalTimer?;
+    private _isBlinkVisible;
+    constructor(key: string, props: T);
+    setShapeProps(props: Partial<ISheetHistoryArrowShapeProps>): void;
+    triggerDblclick(_evt: IPointerEvent | IMouseEvent): boolean;
+    dispose(): void;
+    protected _draw(ctx: CanvasRenderingContext2D): void;
+    private _startBlinking;
+    private _stopBlinking;
+    private _drawHorizontalArrow;
+    private _drawVerticalArrow;
+}

package/lib/types/viewer/views/utils.d.ts

@@ -0,0 +1,11 @@
+import type { LocaleService, Nullable } from '@univerjs/core';
+import type { IHistoryVersion } from '../services/history-fetch.service';
+import type { IVersionWitDate } from './VersionListPanel';
+export declare const parseDateWithLocale: (date: Nullable<number>, localeService: LocaleService) => {
+    date: string;
+    time: string;
+};
+export declare const parseAction: (version: IHistoryVersion, localeService: LocaleService) => string;
+export declare function extractMainMutation(version: IHistoryVersion): string[];
+export declare function parseDateDayWithLocale(dateString: string, localeService: LocaleService): string;
+export declare function transformVersionsToDateGroup(versions?: IHistoryVersion[]): IVersionWitDate[];