@cool-office/docs-ui 0.0.0-stage → 1.2.0

package/lib/types/services/doc-ime-state-change-interceptor.service.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * 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.
+ */
+import type { Nullable } from '@cool-office/core';
+import type { IDocStateChangeInfo, IDocStateChangeInterceptorService } from '@cool-office/docs';
+import { IRenderManagerService } from '@cool-office/engine-render';
+export declare class DocIMEStateChangeInterceptorService implements IDocStateChangeInterceptorService {
+    private readonly _renderManagerService;
+    constructor(_renderManagerService: IRenderManagerService);
+    transformChangeStateInfo(changeStateInfo: IDocStateChangeInfo): Nullable<IDocStateChangeInfo>;
+}

package/lib/types/services/doc-layout-coordinator.service.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * 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.
+ */
+import type { DocLayoutExecutorService, IDocLayoutPageResult, IDocLayoutStartOptions, IDocLayoutStepResult } from '@cool-office/docs';
+import type { DocumentLayoutReason, DocumentSkeleton, IDocumentLayoutProgress, IDocumentLayoutProtectedRange } from '@cool-office/engine-render';
+import { Disposable } from '@cool-office/core';
+export interface IDocLayoutCoordinatorCallbacks {
+    onProgress: (progress: IDocumentLayoutProgress, publication?: IDocLayoutStepResult['publication']) => void;
+    onComplete?: (progress: IDocumentLayoutProgress) => void;
+    onForegroundReady?: (progress: IDocumentLayoutProgress) => void;
+}
+export type DocumentLayoutSchedulingSkeleton = Pick<DocumentSkeleton, 'startIncrementalLayout' | 'stepIncrementalLayout' | 'cancelIncrementalLayout'> & Partial<Pick<DocumentSkeleton, 'publishIncrementalLayoutBacklog'>>;
+type DocumentLayoutSchedulingOptions = NonNullable<Parameters<DocumentSkeleton['startIncrementalLayout']>[0]> & {
+    deferForeground?: boolean;
+    reason: DocumentLayoutReason;
+    foregroundWindowSize?: number;
+    foregroundBudgetMs?: number;
+    foregroundEndOffset?: number;
+};
+type DocLayoutSchedulingExecutor = Pick<DocLayoutExecutorService, 'startLayout' | 'stepLayout' | 'publishBacklog' | 'getLayoutPage' | 'cancelLayout' | 'disposeLayoutMount'>;
+type ExternalLayoutPresentation = Pick<DocumentSkeleton, 'beginExternalLayout' | 'cancelExternalLayout'>;
+export type DocLayoutVisualFrameScheduler = (callback: () => void) => () => void;
+/**
+ * Cooperative presentation scheduler for interactive document layout.
+ *
+ * The coordinator owns only timing and cancellation. The selected executor owns
+ * layout state; both executors publish the same generation/step contract.
+ */
+export declare class DocLayoutCoordinatorService extends Disposable {
+    private readonly _scheduleVisualFrame;
+    private readonly _mountId;
+    private _mountEpoch;
+    private _viewportEpoch;
+    private _workerMount;
+    private _scheduledLayout;
+    private _animationFrameId;
+    private _idleCallbackId;
+    private _fallbackTimerId;
+    private _pendingWorkerPresentation;
+    private _workerPresentationPaused;
+    constructor(_scheduleVisualFrame?: DocLayoutVisualFrameScheduler);
+    schedule(skeleton: DocumentLayoutSchedulingSkeleton, options: DocumentLayoutSchedulingOptions, callbacks: IDocLayoutCoordinatorCallbacks): number;
+    scheduleWorker(unitId: string, skeleton: ExternalLayoutPresentation, executorService: DocLayoutSchedulingExecutor, options: IDocLayoutStartOptions, protectedRange: IDocumentLayoutProtectedRange | undefined, callbacks: IDocLayoutCoordinatorCallbacks, onError: (error: unknown) => void, preserveCompletedLayout?: boolean): void;
+    getWorkerPage(pageIndex: number): Promise<IDocLayoutPageResult | null>;
+    deferBackgroundWork(): void;
+    setWorkerPresentationPaused(paused: boolean): void;
+    hasScheduledLayout(): boolean;
+    cancel(): void;
+    dispose(): void;
+    private _scheduleForeground;
+    private _scheduleBackground;
+    private _runSlice;
+    private _runMainThreadSlice;
+    private _publishMainThreadBacklog;
+    private _finishForegroundWindow;
+    private _completeForegroundWindow;
+    private _runWorkerSlice;
+    private _startWorkerLayout;
+    private _publishWorkerBacklog;
+    private _assertWorkerResultRevisions;
+    private _publishWorkerResult;
+    private _getWorkerIdentity;
+    private _getWorkerGeneration;
+    private _assertWorkerResultIdentity;
+    private _cancelCallbacks;
+}
+export {};

package/lib/types/services/doc-layout-interaction.service.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * 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.
+ */
+import type { IDisposable } from '@cool-office/core';
+import { Disposable } from '@cool-office/core';
+/**
+ * Coordinates render-scoped interactions that require the current document
+ * skeleton to stay stable until the interaction ends.
+ */
+export declare class DocLayoutInteractionService extends Disposable {
+    private readonly _active$;
+    private _interactionCount;
+    readonly active$: import("rxjs").Observable<boolean>;
+    get isActive(): boolean;
+    beginInteraction(): IDisposable;
+    dispose(): void;
+}

package/lib/types/services/doc-layout-progress.service.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * 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.
+ */
+import type { Observable } from 'rxjs';
+import { IUniverInstanceService, RxDisposable } from '@cool-office/core';
+export interface IDocLayoutProgressState {
+    progress: number;
+    unitId: string;
+}
+export declare class DocLayoutProgressService extends RxDisposable {
+    private readonly _univerInstanceService;
+    private readonly _progressByUnit$;
+    readonly currentProgress$: Observable<IDocLayoutProgressState | null>;
+    constructor(_univerInstanceService: IUniverInstanceService);
+    setProgress(unitId: string, progress: number): void;
+    clearProgress(unitId: string): void;
+    dispose(): void;
+}

package/lib/types/services/doc-menu-style.service.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * 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.
+ */
+import type { ICommand, ITextStyle, Nullable } from '@cool-office/core';
+import { Disposable, IUniverInstanceService, ThemeService } from '@cool-office/core';
+import { DocSelectionManagerService } from '@cool-office/docs';
+import { IRenderManagerService } from '@cool-office/engine-render';
+export declare class DocMenuStyleService extends Disposable {
+    private readonly _textSelectionManagerService;
+    private readonly _univerInstanceService;
+    private readonly _renderManagerService;
+    private readonly _themeService;
+    private _cacheStyle;
+    constructor(_textSelectionManagerService: DocSelectionManagerService, _univerInstanceService: IUniverInstanceService, _renderManagerService: IRenderManagerService, _themeService: ThemeService);
+    private _init;
+    private _listenDocRangeChange;
+    getStyleCache(): Nullable<ITextStyle>;
+    getDefaultStyle(): ITextStyle;
+    setStyleCache(style: ITextStyle): void;
+    private _clearStyleCache;
+}
+export interface ISetDocInputStyleCommandParams {
+    style: ITextStyle;
+}
+export declare const SetDocInputStyleCommand: ICommand<ISetDocInputStyleCommandParams>;

package/lib/types/services/doc-mobile-element-menu.service.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * 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.
+ */
+import type { IBoundRectNoAngle, IMouseEvent, IPointerEvent } from '@cool-office/engine-render';
+import type { IMobileDocElementMenuProps } from '../views/mobile-element-menu/MobileDocElementMenu';
+import { Disposable, IUniverInstanceService } from '@cool-office/core';
+import { DocCanvasPopManagerService } from './doc-popup-manager.service';
+export interface IDocMobileElementTarget extends IMobileDocElementMenuProps {
+    unitId: string;
+    rect: IBoundRectNoAngle;
+    onTap?: (offset: {
+        offsetX: number;
+        offsetY: number;
+    }) => void;
+    onDrag?: (event: IPointerEvent | IMouseEvent) => void;
+}
+/** Element hit testing stays in its plugin; the document owns tap-versus-scroll recognition. */
+export declare class DocMobileElementMenuService extends Disposable {
+    private readonly _popupService;
+    private _pending;
+    private _editingBounds;
+    private _popup;
+    private _unitId;
+    constructor(_popupService: DocCanvasPopManagerService, instanceService: IUniverInstanceService);
+    capture(target: IDocMobileElementTarget): boolean;
+    takeTarget(unitId: string): IDocMobileElementTarget | null;
+    setEditingBounds(unitId: string, rect: IBoundRectNoAngle): void;
+    getEditingBounds(unitId: string): IBoundRectNoAngle | null;
+    show(target: IDocMobileElementTarget): void;
+    close(): void;
+    dispose(): void;
+}

package/lib/types/services/doc-page-layout.service.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * 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.
+ */
+import type { DocumentDataModel } from '@cool-office/core';
+import type { IRenderContext, IRenderModule } from '@cool-office/engine-render';
+import { Disposable } from '@cool-office/core';
+import { DocViewScaleService } from './doc-view-scale';
+export declare class DocPageLayoutService extends Disposable implements IRenderModule {
+    private _context;
+    private readonly _docViewScaleService;
+    private _bottomReserve;
+    constructor(_context: IRenderContext<DocumentDataModel>, _docViewScaleService: DocViewScaleService);
+    setBottomReserve(height: number): void;
+    resolveSceneHeight(contentHeight: number): number;
+    calculatePagePosition(): this | undefined;
+}

package/lib/types/services/doc-paragraph-menu.service.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * 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.
+ */
+import type { DocumentDataModel, ICustomBlock, ICustomTable, IDocumentBlockRange } from '@cool-office/core';
+import type { IBoundRectNoAngle, IRenderContext, IRenderModule } from '@cool-office/engine-render';
+import { Disposable, DocumentBlockType, IContextService, IPermissionService } from '@cool-office/core';
+import { DocSelectionManagerService, DocSkeletonManagerService } from '@cool-office/docs';
+import type { IMutiPageParagraphBound, ITableBound } from './doc-event-manager.service';
+import { DocEventManagerService } from './doc-event-manager.service';
+import { DocLayoutInteractionService } from './doc-layout-interaction.service';
+import { DocCanvasPopManagerService } from './doc-popup-manager.service';
+import { DocFloatMenuService } from './float-menu.service';
+import { DocSelectionRenderService } from './selection/doc-selection-render.service';
+export interface IDocBlockMenuTarget {
+    kind: Exclude<DocumentBlockType, DocumentBlockType.COLUMN_GROUP>;
+    key: string;
+    paragraph?: IMutiPageParagraphBound;
+    blockRange?: IDocumentBlockRange;
+    table?: ICustomTable;
+    customBlock?: ICustomBlock;
+    icon?: string;
+    cellRange?: {
+        startOffset: number;
+        endOffset: number;
+    };
+    menuRange: {
+        startOffset: number;
+        endOffset: number;
+        collapsed: boolean;
+    };
+    moveRange: {
+        startOffset: number;
+        endOffset: number;
+    };
+    emptyMode: boolean;
+    draggable: boolean;
+}
+export interface IDocBlockDropTarget {
+    targetOffset: number;
+    rect: {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+    };
+}
+export interface IDocSlashMenuRequest {
+    anchorRect: IBoundRectNoAngle;
+    nonce: number;
+    target: IDocBlockMenuTarget;
+}
+export declare class DocParagraphMenuService extends Disposable implements IRenderModule {
+    private _context;
+    private _docSelectionManagerService;
+    private _docEventManagerService;
+    private _docPopupManagerService;
+    private _docSkeletonManagerService;
+    private _floatMenuService;
+    private _docSelectionRenderService;
+    private readonly _permissionService;
+    private _docLayoutInteractionService;
+    private readonly _contextService;
+    private _paragraphMenu;
+    private _paragraphMenuHideTimer;
+    private readonly _activeTarget$;
+    readonly activeTarget$: import("rxjs").Observable<IDocBlockMenuTarget | null>;
+    private _focusedTableMenu;
+    private readonly _focusedTableTarget$;
+    readonly focusedTableTarget$: import("rxjs").Observable<IDocBlockMenuTarget | null>;
+    private readonly _focusedTableMenuDismiss$;
+    readonly focusedTableMenuDismiss$: import("rxjs").Observable<void>;
+    private readonly _slashMenuRequest$;
+    readonly slashMenuRequest$: import("rxjs").Observable<IDocSlashMenuRequest | null>;
+    private _isBlockMenuDragging;
+    private _isSlashMenuActive;
+    private _slashMenuRequestNonce;
+    private _menuInteraction;
+    private _dragInteraction;
+    get activeParagraph(): IMutiPageParagraphBound | undefined;
+    get activeTarget(): IDocBlockMenuTarget | null;
+    get focusedTableTarget(): IDocBlockMenuTarget | null;
+    setBlockMenuDragging(isDragging: boolean): void;
+    get isBlockMenuDragging(): boolean;
+    constructor(_context: IRenderContext<DocumentDataModel>, _docSelectionManagerService: DocSelectionManagerService, _docEventManagerService: DocEventManagerService, _docPopupManagerService: DocCanvasPopManagerService, _docSkeletonManagerService: DocSkeletonManagerService, _floatMenuService: DocFloatMenuService, _docSelectionRenderService: DocSelectionRenderService, _permissionService: IPermissionService, _docLayoutInteractionService: DocLayoutInteractionService, _contextService: IContextService);
+    private _getExpandedSelectionState;
+    private _hasExpandedSelectionRanges;
+    private _hasExpandedTextSelection;
+    private _hasExpandedSelection;
+    setParagraphMenuActive(active: boolean, focusedTable?: boolean): void;
+    private _init;
+    private _handleSlashMenuKeydown;
+    private _handleSlashMenuInputBefore;
+    private _openSlashMenu;
+    private _shouldOpenSlashMenu;
+    private _shouldOpenSlashMenuFromInput;
+    private _getCollapsedTextRange;
+    private _getSlashMenuParagraph;
+    private _getSlashMenuAnchorRect;
+    showParagraphMenu(paragraph: IMutiPageParagraphBound): void;
+    showTableMenu(tableBound: ITableBound, focused?: boolean): void;
+    private _showHoverMenu;
+    private _showFocusedTableMenu;
+    private _shouldKeepCurrentCellMenuForTable;
+    getDropTargetFromClientPoint(clientX: number, clientY: number, sourceRange: {
+        startOffset: number;
+        endOffset: number;
+    }): IDocBlockDropTarget | null;
+    private _cancelParagraphMenuHide;
+    private _scheduleParagraphMenuHide;
+    hideParagraphMenu(force?: boolean): void;
+    hideFocusedTableMenu(): void;
+    private _canEditDocument;
+    dispose(): void;
+    private _buildParagraphMenuTarget;
+    private _getBodyBlockTargets;
+    private _getCellBlockTargets;
+}

package/lib/types/services/doc-popup-manager.service.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * 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.
+ */
+import type { INeedCheckDisposable, ITextRangeParam } from '@cool-office/core';
+import type { BaseObject, IBoundRectNoAngle, IRender, Scene } from '@cool-office/engine-render';
+import type { IPopup } from '@cool-office/ui';
+import type { Observable } from 'rxjs';
+import { Disposable, ICommandService, IUniverInstanceService } from '@cool-office/core';
+import { IRenderManagerService } from '@cool-office/engine-render';
+import { ICanvasPopupService } from '@cool-office/ui';
+export declare function transformBound2OffsetBound(originBound: IBoundRectNoAngle, scene: Scene): IBoundRectNoAngle;
+export declare function transformPosition2Offset(x: number, y: number, scene: Scene): {
+    x: number;
+    y: number;
+};
+export declare function transformOffset2Bound(offsetX: number, offsetY: number, scene: Scene): {
+    x: number;
+    y: number;
+};
+export interface IDocCanvasPopup extends Omit<IPopup, 'anchorRect$' | 'children' | 'unitId' | 'subUnitId' | 'canvasElement'> {
+    /** Notify when a business-owned rect changes independently of scene transforms. */
+    positionChanges$?: Observable<unknown>;
+    /** Defaults to true. Passive hover affordances can track layout without holding it. */
+    requiresStableLayout?: boolean;
+    mask?: boolean;
+    extraProps?: Record<string, unknown>;
+    multipleDirection?: IPopup['direction'];
+    /** Anchor at the focus end while retaining the entire selection for outside-click exclusion. */
+    rangeAnchor?: 'selection-end';
+}
+export declare const calcDocRangePositions: (range: ITextRangeParam, currentRender: IRender) => IBoundRectNoAngle[] | undefined;
+export declare class DocCanvasPopManagerService extends Disposable {
+    private readonly _globalPopupManagerService;
+    private readonly _renderManagerService;
+    private readonly _univerInstanceService;
+    private readonly _commandService;
+    private readonly _popupCountByUnit;
+    private readonly _popupUnits$;
+    readonly popupUnits$: Observable<ReadonlySet<string>>;
+    constructor(_globalPopupManagerService: ICanvasPopupService, _renderManagerService: IRenderManagerService, _univerInstanceService: IUniverInstanceService, _commandService: ICommandService);
+    dispose(): void;
+    private _beginPopupActivity;
+    private _publishPopupUnits;
+    getRangeBounds(range: ITextRangeParam, unitId: string): IBoundRectNoAngle[] | undefined;
+    private _shouldUpdateForCommand;
+    private _createRectPositionObserver;
+    private _createObjectPositionObserver;
+    private _createRangePositionObserver;
+    attachPopupToRect(rect: IBoundRectNoAngle | (() => IBoundRectNoAngle), popup: IDocCanvasPopup, unitId: string): INeedCheckDisposable;
+    /**
+     * attach a popup to canvas object
+     * @param targetObject target canvas object
+     * @param popup popup item
+     * @returns disposable
+     */
+    attachPopupToObject(targetObject: BaseObject, popup: IDocCanvasPopup, unitId: string): INeedCheckDisposable;
+    /**
+     * attach a popup to doc range
+     * @param range doc range
+     * @param popup popup item
+     * @param unitId unit id
+     * @returns disposable
+     */
+    attachPopupToRange(range: ITextRangeParam, popup: IDocCanvasPopup, unitId: string): INeedCheckDisposable;
+    private _resolveEmbeddedPopupInjector;
+    private _resolvePopupManagerService;
+}

package/lib/types/services/doc-print-interceptor.service.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * 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.
+ */
+import type { DisposableCollection } from '@cool-office/core';
+import type { Documents, DocumentSkeleton, Engine, IBoundRectNoAngle, Scene } from '@cool-office/engine-render';
+import { Disposable, InterceptorManager } from '@cool-office/core';
+export interface IDocPrintContext {
+    unitId: string;
+    pageIndex?: number;
+    scene: Scene;
+    engine: Engine;
+    root: HTMLElement;
+    skeleton: DocumentSkeleton;
+}
+export interface IDocPrintDomtContext extends IDocPrintContext {
+    offset: {
+        x: number;
+        y: number;
+    };
+    bound: IBoundRectNoAngle;
+}
+export interface IDocPrintComponentContext extends IDocPrintContext {
+    documents: Documents;
+}
+export interface IDocPrintPreparationContext {
+    unitId: string;
+    dpr: number;
+}
+export declare class DocPrintInterceptorService extends Disposable {
+    private _printComponentMap;
+    private readonly _printPreparationHandlers;
+    readonly interceptor: InterceptorManager<{
+        PRINTING_COMPONENT_COLLECT: import("@cool-office/core").IInterceptor<undefined, IDocPrintComponentContext>;
+        PRINTING_DOM_COLLECT: import("@cool-office/core").IInterceptor<DisposableCollection, IDocPrintDomtContext>;
+    }>;
+    constructor();
+    registerPrintComponent(componentKey: string, printingComponentKey: string): void;
+    getPrintComponent(componentKey: string): string | undefined;
+    getPageDrawingIds(skeleton: DocumentSkeleton, pageIndex?: number): ReadonlySet<string> | null;
+    registerPrintPreparation(handler: (context: IDocPrintPreparationContext) => Promise<void>): () => boolean;
+    preparePrint(context: IDocPrintPreparationContext): Promise<void>;
+    dispose(): void;
+}

package/lib/types/services/doc-render-background.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * 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.
+ */
+import type { ICanvasColorService } from '@cool-office/engine-render';
+import { DocumentFlavor } from '@cool-office/core';
+export interface IResolveDocRenderBackgroundOptions {
+    documentFlavor?: DocumentFlavor;
+    canvasColorService?: ICanvasColorService;
+    editorBackgroundColor?: string;
+    isEditor?: boolean;
+}
+export interface IResolvedDocRenderBackground {
+    canvasElementBackgroundColor: string;
+    docBackgroundFillColor?: string;
+}
+export declare function resolveDocRenderBackground(options: IResolveDocRenderBackgroundOptions): IResolvedDocRenderBackground;
+export declare function getDefaultDocCanvasBackgroundColor(documentFlavor?: DocumentFlavor, isEditor?: boolean): "transparent" | "var(--univer-gray-100)" | "var(--univer-gray-0)";

package/lib/types/services/doc-view-scale.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * 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.
+ */
+import type { DocumentDataModel } from '@cool-office/core';
+import type { IRenderContext, IRenderModule } from '@cool-office/engine-render';
+import type { IDocFitToWidthOptions, IUniverDocsUIConfig } from '../config/config';
+import { Disposable, DocumentFlavor, IConfigService } from '@cool-office/core';
+export interface ICalcDocFitToWidthScaleParams {
+    availableWidth: number;
+    baseWidth: number;
+    options?: IDocFitToWidthOptions;
+}
+export interface IResolveDocFitBaseWidthParams {
+    documentFlavor?: DocumentFlavor;
+    documentStylePageWidth?: number;
+    skeletonPageWidth?: number;
+}
+export declare function normalizeDocFitToWidthOptions(options?: IDocFitToWidthOptions): {
+    mode: import("..").DocFitMode;
+    target: import("..").DocFitTarget;
+    paddingX: import("../config/config").DocFitPaddingX;
+    minScale: number;
+    maxScale?: number;
+    align: import("..").DocFitAlign;
+};
+export declare function resolveDocFitPaddingX(availableWidth: number, paddingX: IDocFitToWidthOptions['paddingX']): number;
+export declare function calcDocFitToWidthScale(params: ICalcDocFitToWidthScaleParams): number;
+export declare function resolveDocFitBaseWidth(params: IResolveDocFitBaseWidthParams): number;
+export declare function resolveDocViewScale(userZoomRatio: number, fitToWidthScale: number): number;
+export declare class DocViewScaleService extends Disposable implements IRenderModule {
+    protected readonly _context: IRenderContext<DocumentDataModel>;
+    private readonly _configService;
+    constructor(_context: IRenderContext<DocumentDataModel>, _configService: IConfigService);
+    getPluginConfig(): Partial<IUniverDocsUIConfig>;
+    getOptions(): IDocFitToWidthOptions;
+    getBaseWidth(): number;
+    getAvailableWidth(): number;
+    getUserZoomRatio(): number;
+    getFitToWidthScale(): number;
+    getViewScale(userZoomRatio?: number): number;
+    private _resolveContainer;
+}

package/lib/types/services/doc-zoom.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * 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.
+ */
+import type { DocumentDataModel, ICommandService, IUniverInstanceService } from '@cool-office/core';
+import { Observable } from 'rxjs';
+export declare const DEFAULT_MODERN_DOC_ZOOM_RATIO = 1;
+export declare const DOC_ZOOM_SHORTCUTS: number[];
+type DocZoomSource = Pick<DocumentDataModel, 'getSettings' | 'getSnapshot'>;
+export declare function getDocEffectiveZoomRatio(documentModel: DocZoomSource): number;
+export declare function getDocZoomRatio$(commandService: ICommandService, instanceService: IUniverInstanceService): Observable<number>;
+export {};