Skip to content

Build your own AI office with Univer Office SDK. Bring editing, calculation, collaboration, and file processing into your product for people and AI agents. Built on an extensible open-source core.

35.1 KB
Raw Blame
/**
 * 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 { DrawingTypeEnum, ICommandService, Injector, IUniverInstanceService, UniverInstanceType } from '@univerjs/core';
import { InsertDocDrawingCommand } from '@univerjs/docs-drawing';
import { SetDocZoomRatioOperation } from '@univerjs/docs-ui';
import { IDrawingManagerService } from '@univerjs/drawing';
import { DrawingRenderService } from '@univerjs/drawing-ui';
import { IRenderManagerService, Rect } from '@univerjs/engine-render';
import { CanvasFloatDomService } from '@univerjs/ui';
import { BehaviorSubject, Subject } from 'rxjs';
import { describe, expect, it, vi } from 'vitest';
import { DocRefreshDrawingsService } from '../../services/doc-refresh-drawings.service';
import {
    calcDocFloatDomPositionByRect,
    DocFloatDomController,
    mergeDocFloatDomRuntimeProps,
} from '../doc-float-dom.controller';

function createScene() {
    const viewport = { viewportScrollX: 10, viewportScrollY: 20, onScrollAfter$: new Subject() };
    return {
        viewport,
        getViewport: vi.fn(() => viewport),
        getAncestorScale: vi.fn(() => ({ scaleX: 2, scaleY: 3 })),
        getTransformerByCreate: vi.fn(() => ({})),
        removeObject: vi.fn(),
    };
}

function createController(options: {
    drawing?: Record<string, unknown>;
    rects?: Rect[];
    page?: any;
    renderType?: UniverInstanceType;
    refreshDrawingOnAdd?: { left: number; top: number; width: number; height: number; angle: number };
    resolveRefreshDrawing?: () => {
        left: number;
        top: number;
        width: number;
        height: number;
        angle: number;
    } | undefined;
    notifyMissingDrawingBeforeGeometry?: boolean;
} = {}) {
    const add$ = new Subject<any[]>();
    const remove$ = new Subject<any[]>();
    const refreshTransform$ = new Subject<any[]>();
    const currentSkeleton$ = new Subject<any>();
    const skeletonDirty$ = new Subject<boolean>();
    const renderCreated$ = new Subject<any>();
    const renderDisposed$ = new Subject<string>();
    const commandHandlers: Array<(command: { id: string; params?: unknown }) => void> = [];
    const scene = createScene();
    const canvas = { dispatchEvent: vi.fn() };
    const injector = new Injector([[DocRefreshDrawingsService], [DocFloatDomController]]);
    const docRefreshDrawingsService = injector.get(DocRefreshDrawingsService);
    const refreshDrawings = vi.spyOn(docRefreshDrawingsService, 'refreshDrawings');
    docRefreshDrawingsService.refreshDrawings$.subscribe((skeleton) => {
        const transform = options.resolveRefreshDrawing?.() ?? options.refreshDrawingOnAdd;
        if (skeleton != null && transform) {
            refreshTransform$.next([{
                unitId: 'doc-1',
                subUnitId: 'doc-1',
                drawingId: 'dom-1',
                transform,
            }]);
        }
    });
    const skeleton = {
        dirty$: skeletonDirty$,
        getSkeletonData: () => ({
            pages: [options.page ?? { pageWidth: 240, marginLeft: 20, marginRight: 30 }],
        }),
    };
    const renderUnit = {
        unitId: 'doc-1',
        type: options.renderType ?? UniverInstanceType.UNIVER_DOC,
        scene,
        engine: { getCanvasElement: () => canvas },
        isDisposed: vi.fn(() => false),
        with: vi.fn(() => ({
            currentSkeleton$,
            getSkeleton: () => skeleton,
        })),
    };
    const renderManagerService = {
        created$: renderCreated$,
        disposed$: renderDisposed$,
        getRenderUnitById: vi.fn(() => renderUnit),
    };
    const drawing = {
        unitId: 'doc-1',
        subUnitId: 'doc-1',
        drawingId: 'dom-1',
        componentKey: 'FloatDom',
        drawingType: DrawingTypeEnum.DRAWING_DOM,
        data: { value: 1 },
        ...options.drawing,
    };
    const drawingManagerService = {
        add$,
        remove$,
        refreshTransform$,
        getDrawingByParam: vi.fn(() => drawing),
    };
    const drawingRenderService = {
        renderFloatDom: vi.fn(() => options.rects ?? []),
    };
    const domLayers: Array<[string, any]> = [];
    const canvasFloatDomService = {
        domLayers,
        addFloatDom: vi.fn((layer) => {
            domLayers.push([layer.id, layer]);
        }),
        updateFloatDom: vi.fn((id, patch) => {
            const layer = domLayers.find(([layerId]) => layerId === id);
            if (layer) {
                Object.assign(layer[1], patch);
            }
        }),
        removeFloatDom: vi.fn(),
    };
    const doc = { getUnitId: () => 'doc-1' };
    const univerInstanceService = {
        getUnit: vi.fn(() => doc),
        getCurrentUnitOfType: vi.fn(() => doc),
        getCurrentTypeOfUnit$: vi.fn(() => new BehaviorSubject(null)),
    };
    const commandService = {
        onCommandExecuted: vi.fn((handler) => {
            commandHandlers.push(handler);
            return { dispose: vi.fn() };
        }),
        syncExecuteCommand: vi.fn(),
    };

    if (options.notifyMissingDrawingBeforeGeometry) {
        // DrawingUpdateController can request insertion before this controller receives the runtime geometry.
        const subscription = refreshTransform$.subscribe((params) => {
            subscription.unsubscribe();
            add$.next(params.map(({ unitId, subUnitId, drawingId }) => ({ unitId, subUnitId, drawingId })));
        });
    }
    injector.add([IRenderManagerService, { useValue: renderManagerService as never }]);
    injector.add([IDrawingManagerService, { useValue: drawingManagerService as never }]);
    injector.add([DrawingRenderService, { useValue: drawingRenderService as never }]);
    injector.add([CanvasFloatDomService, { useValue: canvasFloatDomService as never }]);
    injector.add([IUniverInstanceService, { useValue: univerInstanceService as never }]);
    injector.add([ICommandService, { useValue: commandService as never }]);
    const controller = injector.get(DocFloatDomController);

    return {
        controller,
        add$,
        currentSkeleton$,
        remove$,
        refreshTransform$,
        commandHandlers,
        scene,
        canvas,
        renderUnit,
        drawingRenderService,
        canvasFloatDomService,
        commandService,
        refreshDrawings,
        renderCreated$,
        renderDisposed$,
        skeletonDirty$,
    };
}

function publishEmbedRuntimeGeometry(
    refreshTransform$: ReturnType<typeof createController>['refreshTransform$'],
    transform = { left: 30, top: 50, width: 50, height: 40, angle: 0 }
) {
    refreshTransform$.next([{
        unitId: 'doc-1',
        subUnitId: 'doc-1',
        drawingId: 'dom-1',
        transform,
    }]);
}

describe('DocFloatDomController', () => {
    it('preserves existing props while adding custom block runtime viewport', () => {
        expect(mergeDocFloatDomRuntimeProps({ keep: true }, {
            customBlockRenderViewport: {
                bleedLeft: 96,
                bleedWidth: 1440,
                contentHeight: 720,
                contentWidth: 1280,
                height: 480,
                pageContentWidth: 1008,
                viewScale: 1.5,
                viewportHeight: 320,
            },
        } as never)).toEqual({
            customBlockRenderViewport: {
                bleedLeft: 96,
                bleedWidth: 1440,
                contentHeight: 720,
                contentWidth: 1280,
                height: 480,
                pageContentWidth: 1008,
                viewScale: 1.5,
                viewportHeight: 320,
            },
            keep: true,
        });
    });

    it('keeps existing props when no valid runtime viewport is available', () => {
        expect(mergeDocFloatDomRuntimeProps({ keep: true }, {
            customBlockRenderViewport: { contentWidth: 0 },
        } as never)).toEqual({ keep: true });
    });

    it('calculates float dom bounds using doc viewport scroll and ancestor scale', () => {
        const scene = createScene();

        expect(calcDocFloatDomPositionByRect({ left: 30, top: 50, right: 80, bottom: 90 }, scene as never, 0.4, 15)).toEqual({
            startX: 40,
            startY: 90,
            endX: 140,
            endY: 210,
            width: 100,
            height: 120,
            rotate: 15,
            absolute: { left: false, top: false },
            opacity: 0.4,
        });
    });

    it('updates float dom position after host doc zoom without rewriting runtime viewport', async () => {
        const rect = new Rect('dom-rect', {
            left: 30,
            top: 50,
            width: 50,
            height: 40,
        });
        const { add$, canvasFloatDomService, commandHandlers, controller, scene } = createController({
            rects: [rect],
            drawing: {
                customBlockRenderViewport: {
                    contentHeight: 240,
                    height: 240,
                    viewScale: 1,
                    viewportHeight: 120,
                },
            },
        });

        add$.next([{ unitId: 'doc-1', subUnitId: 'doc-1', drawingId: 'dom-1' }]);
        await Promise.resolve();
        const position$ = canvasFloatDomService.addFloatDom.mock.calls[0][0].position$ as BehaviorSubject<unknown>;
        scene.getAncestorScale.mockReturnValue({ scaleX: 1, scaleY: 1 });
        commandHandlers.forEach((handler) => handler({
            id: SetDocZoomRatioOperation.id,
            params: { unitId: 'doc-1', zoomRatio: 2 },
        }));
        scene.getAncestorScale.mockReturnValue({ scaleX: 2, scaleY: 2 });
        await Promise.resolve();

        expect(position$.getValue()).toMatchObject({
            startX: 40,
            startY: 60,
            width: 100,
            height: 480,
        });
        expect(canvasFloatDomService.updateFloatDom).not.toHaveBeenCalled();

        controller.dispose();
    });

    it('adds rendered float doms, updates their position, and removes them with their rect object', async () => {
        const rect = new Rect('dom-rect', {
            left: 30,
            top: 50,
            width: 50,
            height: 40,
        } as never);
        rect.setOpacity(0.8);
        const { controller, add$, remove$, scene, drawingRenderService, canvasFloatDomService } = createController({ rects: [rect] });

        add$.next([{ unitId: 'doc-1', subUnitId: 'doc-1', drawingId: 'dom-1' }]);
        await Promise.resolve();

        expect(drawingRenderService.renderFloatDom).toHaveBeenCalledWith(expect.objectContaining({ drawingId: 'dom-1' }), scene);
        expect(canvasFloatDomService.addFloatDom).toHaveBeenCalledWith(expect.objectContaining({
            id: 'dom-1',
            componentKey: 'FloatDom',
            unitId: 'doc-1',
            data: { value: 1 },
        }));

        const position$ = canvasFloatDomService.addFloatDom.mock.calls[0][0].position$;
        const positions: unknown[] = [];
        const sub = position$.subscribe((position: unknown) => positions.push(position));
        rect.transformByState({ left: 40, top: 60 });

        expect(positions.at(-1)).toMatchObject({
            startX: 60,
            startY: 120,
            width: 100,
            height: 120,
            opacity: 0.8,
        });

        remove$.next([{ drawingId: 'dom-1' }]);
        expect(canvasFloatDomService.removeFloatDom).toHaveBeenCalledWith('dom-1');
        expect(scene.removeObject).toHaveBeenCalledWith(rect);

        sub.unsubscribe();
        controller.dispose();
    });

    it('keeps embed custom block float doms visible when focus moves into child units', async () => {
        const rect = new Rect('dom-rect', {
            left: 30,
            top: 50,
            width: 50,
            height: 40,
        } as never);
        const { controller, add$, refreshTransform$, canvasFloatDomService } = createController({
            rects: [rect],
            drawing: {
                data: { version: 1, embedId: 'embed-1', hostAnchorId: 'anchor-1' },
            },
        });

        publishEmbedRuntimeGeometry(refreshTransform$);
        add$.next([{ unitId: 'doc-1', subUnitId: 'doc-1', drawingId: 'dom-1' }]);
        await Promise.resolve();

        expect(canvasFloatDomService.addFloatDom).toHaveBeenCalledWith(expect.objectContaining({
            eventPassThrough: false,
            preserveOnFocusChange: true,
        }));

        controller.dispose();
    });

    it('waits for layout runtime geometry before mounting an embed custom block', () => {
        const rect = new Rect('dom-rect', {
            left: 10,
            top: 20,
            width: 50,
            height: 40,
        });
        const { controller, add$, refreshTransform$, drawingRenderService, canvasFloatDomService } = createController({
            rects: [rect],
            drawing: {
                data: { version: 1, embedId: 'embed-1', hostAnchorId: 'anchor-1' },
            },
        });

        add$.next([{ unitId: 'doc-1', subUnitId: 'doc-1', drawingId: 'dom-1' }]);

        expect(drawingRenderService.renderFloatDom).not.toHaveBeenCalled();
        expect(canvasFloatDomService.addFloatDom).not.toHaveBeenCalled();

        publishEmbedRuntimeGeometry(refreshTransform$, { left: 300, top: 500, width: 50, height: 40, angle: 0 });

        expect(drawingRenderService.renderFloatDom).toHaveBeenCalledOnce();
        expect(canvasFloatDomService.addFloatDom).toHaveBeenCalledOnce();
        expect(canvasFloatDomService.addFloatDom.mock.calls[0][0].position$.getValue()).toMatchObject({
            startX: 580,
            startY: 1440,
            width: 100,
            height: 120,
        });

        controller.dispose();
    });

    it('refreshes current layout geometry when an embed drawing is added after publication', () => {
        const rect = new Rect('dom-rect', {
            left: 10,
            top: 20,
            width: 50,
            height: 40,
        });
        const { controller, add$, refreshDrawings, canvasFloatDomService } = createController({
            rects: [rect],
            drawing: {
                data: { version: 1, embedId: 'embed-1', hostAnchorId: 'anchor-1' },
            },
            refreshDrawingOnAdd: { left: 300, top: 500, width: 50, height: 40, angle: 0 },
        });

        add$.next([{ unitId: 'doc-1', subUnitId: 'doc-1', drawingId: 'dom-1' }]);

        expect(refreshDrawings).toHaveBeenCalledOnce();
        expect(canvasFloatDomService.addFloatDom).toHaveBeenCalledOnce();
        expect(canvasFloatDomService.addFloatDom.mock.calls[0][0].position$.getValue()).toMatchObject({
            startX: 580,
            startY: 1440,
            width: 100,
            height: 120,
        });

        controller.dispose();
    });

    it('mounts a pending embed without requesting recursive geometry and still accepts later layout changes', () => {
        const rect = new Rect('dom-rect', { left: 10, top: 20, width: 50, height: 40 });
        const { controller, add$, remove$, refreshTransform$, refreshDrawings, canvasFloatDomService } = createController({
            rects: [rect],
            drawing: { data: { version: 1, embedId: 'embed-1', hostAnchorId: 'anchor-1' } },
            refreshDrawingOnAdd: { left: 300, top: 500, width: 50, height: 40, angle: 0 },
            notifyMissingDrawingBeforeGeometry: true,
        });

        try {
            const drawing = { unitId: 'doc-1', subUnitId: 'doc-1', drawingId: 'dom-1' };
            add$.next([drawing]);

            expect(refreshDrawings).toHaveBeenCalledOnce();
            expect(canvasFloatDomService.addFloatDom).toHaveBeenCalledOnce();
            const position$ = canvasFloatDomService.addFloatDom.mock.calls[0][0].position$;
            expect(position$.getValue()).toMatchObject({ startX: 580, startY: 1440 });

            publishEmbedRuntimeGeometry(refreshTransform$, { left: 400, top: 600, width: 50, height: 40, angle: 0 });
            expect(position$.getValue()).toMatchObject({ startX: 780, startY: 1740 });

            remove$.next([drawing]);
            add$.next([drawing]);
            expect(canvasFloatDomService.addFloatDom).toHaveBeenCalledTimes(2);
            expect(canvasFloatDomService.addFloatDom.mock.calls[1][0].position$.getValue()).toMatchObject({
                startX: 580,
                startY: 1440,
            });
        } finally {
            controller.dispose();
        }
    });

    it('does not resolve layout services from a disposed render unit', () => {
        const { controller, add$, renderUnit, refreshDrawings } = createController({
            drawing: {
                data: { version: 1, embedId: 'embed-1', hostAnchorId: 'anchor-1' },
            },
        });
        renderUnit.isDisposed.mockReturnValue(true);

        add$.next([{ unitId: 'doc-1', subUnitId: 'doc-1', drawingId: 'dom-1' }]);

        expect(renderUnit.with).not.toHaveBeenCalled();
        expect(refreshDrawings).not.toHaveBeenCalled();

        controller.dispose();
    });

    it('does not resolve Doc layout services from a non-Doc render unit', () => {
        const { controller, add$, renderUnit, refreshDrawings } = createController({
            drawing: {
                data: { version: 1, embedId: 'embed-1', hostAnchorId: 'anchor-1' },
            },
            renderType: UniverInstanceType.UNIVER_SHEET,
        });

        add$.next([{ unitId: 'doc-1', subUnitId: 'doc-1', drawingId: 'dom-1' }]);

        expect(renderUnit.with).not.toHaveBeenCalled();
        expect(refreshDrawings).not.toHaveBeenCalled();

        controller.dispose();
    });

    it('resumes pending embed geometry when the host render is recreated', () => {
        const rect = new Rect('dom-rect', {
            left: 10,
            top: 20,
            width: 50,
            height: 40,
        });
        const {
            controller,
            add$,
            canvasFloatDomService,
            renderCreated$,
            renderDisposed$,
            renderUnit,
        } = createController({
            rects: [rect],
            drawing: {
                data: { version: 1, embedId: 'embed-1', hostAnchorId: 'anchor-1' },
            },
            refreshDrawingOnAdd: { left: 300, top: 500, width: 50, height: 40, angle: 0 },
        });
        renderUnit.isDisposed.mockReturnValue(true);
        add$.next([{ unitId: 'doc-1', subUnitId: 'doc-1', drawingId: 'dom-1' }]);
        expect(canvasFloatDomService.addFloatDom).not.toHaveBeenCalled();

        renderDisposed$.next('doc-1');
        renderUnit.isDisposed.mockReturnValue(false);
        renderCreated$.next(renderUnit);

        expect(canvasFloatDomService.addFloatDom).toHaveBeenCalledOnce();

        controller.dispose();
    });

    it('refreshes a pending embed drawing when the current skeleton becomes dirty', () => {
        let geometry: { left: number; top: number; width: number; height: number; angle: number } | undefined;
        const rect = new Rect('dom-rect', {
            left: 10,
            top: 20,
            width: 50,
            height: 40,
        });
        const { controller, add$, skeletonDirty$, refreshDrawings, canvasFloatDomService } = createController({
            rects: [rect],
            drawing: {
                data: { version: 1, embedId: 'embed-1', hostAnchorId: 'anchor-1' },
            },
            resolveRefreshDrawing: () => geometry,
        });

        add$.next([{ unitId: 'doc-1', subUnitId: 'doc-1', drawingId: 'dom-1' }]);
        expect(canvasFloatDomService.addFloatDom).not.toHaveBeenCalled();

        geometry = { left: 300, top: 500, width: 50, height: 40, angle: 0 };
        skeletonDirty$.next(true);

        expect(canvasFloatDomService.addFloatDom).toHaveBeenCalledOnce();
        const refreshCountAfterMount = refreshDrawings.mock.calls.length;
        skeletonDirty$.next(true);
        expect(refreshDrawings).toHaveBeenCalledTimes(refreshCountAfterMount);

        controller.dispose();
    });

    it('ignores hidden fallback geometry while an embed layout is incomplete', () => {
        const rect = new Rect('dom-rect', {
            left: 10,
            top: 20,
            width: 50,
            height: 40,
        });
        const { controller, add$, refreshTransform$, drawingRenderService, canvasFloatDomService } = createController({
            rects: [rect],
            drawing: {
                data: { version: 1, embedId: 'embed-1', hostAnchorId: 'anchor-1' },
            },
        });

        add$.next([{ unitId: 'doc-1', subUnitId: 'doc-1', drawingId: 'dom-1' }]);
        refreshTransform$.next([{
            unitId: 'doc-1',
            subUnitId: 'doc-1',
            drawingId: 'dom-1',
            hidden: true,
            transform: { left: 10, top: 20, width: 50, height: 40, angle: 0 },
        }]);

        expect(drawingRenderService.renderFloatDom).not.toHaveBeenCalled();
        expect(canvasFloatDomService.addFloatDom).not.toHaveBeenCalled();

        publishEmbedRuntimeGeometry(refreshTransform$, { left: 300, top: 500, width: 50, height: 40, angle: 0 });
        const position$ = canvasFloatDomService.addFloatDom.mock.calls[0][0].position$;
        const publishedPosition = position$.getValue();

        refreshTransform$.next([{
            unitId: 'doc-1',
            subUnitId: 'doc-1',
            drawingId: 'dom-1',
            hidden: true,
            transform: { left: 10, top: 20, width: 50, height: 40, angle: 0 },
        }]);

        expect(position$.getValue()).toEqual(publishedPosition);

        controller.dispose();
    });

    it('does not mount a removed embed custom block when runtime geometry arrives later', () => {
        const rect = new Rect('dom-rect', {
            left: 10,
            top: 20,
            width: 50,
            height: 40,
        });
        const { controller, add$, remove$, refreshTransform$, drawingRenderService, canvasFloatDomService } = createController({
            rects: [rect],
            drawing: {
                data: { version: 1, embedId: 'embed-1', hostAnchorId: 'anchor-1' },
            },
        });

        add$.next([{ unitId: 'doc-1', subUnitId: 'doc-1', drawingId: 'dom-1' }]);
        remove$.next([{ drawingId: 'dom-1' }]);
        publishEmbedRuntimeGeometry(refreshTransform$);

        expect(drawingRenderService.renderFloatDom).not.toHaveBeenCalled();
        expect(canvasFloatDomService.addFloatDom).not.toHaveBeenCalled();

        controller.dispose();
    });

    it('updates float dom position from its own host viewport scroll even when current doc focus changes', async () => {
        const rect = new Rect('dom-rect', {
            left: 30,
            top: 50,
            width: 50,
            height: 40,
        } as never);
        const { controller, add$, scene, canvasFloatDomService } = createController({ rects: [rect] });

        add$.next([{ unitId: 'doc-1', subUnitId: 'doc-1', drawingId: 'dom-1' }]);
        await Promise.resolve();

        const position$ = canvasFloatDomService.addFloatDom.mock.calls[0][0].position$;
        const positions: unknown[] = [];
        const sub = position$.subscribe((position: unknown) => positions.push(position));

        scene.viewport.viewportScrollY = 80;
        scene.viewport.onScrollAfter$.next({} as never);

        expect(positions.at(-1)).toMatchObject({
            startX: 40,
            startY: -90,
            width: 100,
            height: 120,
        });

        sub.unsubscribe();
        controller.dispose();
    });

    it('updates rendered float dom bounds only from the owning document unit', async () => {
        const rect = new Rect('dom-rect', {
            left: 30,
            top: 50,
            width: 50,
            height: 40,
        } as never);
        const { controller, add$, refreshTransform$, canvasFloatDomService } = createController({
            rects: [rect],
            drawing: {
                data: { version: 1, embedId: 'embed-1', hostAnchorId: 'anchor-1' },
            },
        });

        publishEmbedRuntimeGeometry(refreshTransform$);
        add$.next([{ unitId: 'doc-1', subUnitId: 'doc-1', drawingId: 'dom-1' }]);
        await Promise.resolve();

        const position$ = canvasFloatDomService.addFloatDom.mock.calls[0][0].position$;
        const positions: unknown[] = [];
        const sub = position$.subscribe((position: unknown) => positions.push(position));

        const positionCount = positions.length;
        refreshTransform$.next([{
            unitId: 'doc-2',
            drawingId: 'dom-1',
            transform: { left: 0, top: 0, width: 160, height: 240, angle: 0 },
        }]);
        expect(positions).toHaveLength(positionCount);

        refreshTransform$.next([{
            unitId: 'doc-1',
            drawingId: 'dom-1',
            transform: { left: 40, top: 60, width: 160, height: 240, angle: 0 },
            customBlockRenderViewport: { contentHeight: 240, height: 240, viewportHeight: 120 },
        }]);

        expect(positions.at(-1)).toMatchObject({
            startX: 60,
            startY: 120,
            width: 320,
            height: 720,
        });
        expect(canvasFloatDomService.updateFloatDom).toHaveBeenCalledWith('dom-1', expect.objectContaining({
            props: expect.objectContaining({
                customBlockRenderViewport: { contentHeight: 240, height: 240, viewportHeight: 120 },
            }),
        }));

        sub.unsubscribe();
        controller.dispose();
    });

    it('uses custom block viewport height when creating the initial float dom position', async () => {
        const rect = new Rect('dom-rect', {
            left: 30,
            top: 50,
            width: 50,
            height: 40,
        } as never);
        const { controller, add$, canvasFloatDomService } = createController({
            rects: [rect],
            drawing: {
                customBlockRenderViewport: { contentHeight: 240, height: 240, viewportHeight: 120 },
            },
        });

        add$.next([{ unitId: 'doc-1', subUnitId: 'doc-1', drawingId: 'dom-1' }]);
        await Promise.resolve();

        const position$ = canvasFloatDomService.addFloatDom.mock.calls[0][0].position$;
        const positions: unknown[] = [];
        const sub = position$.subscribe((position: unknown) => positions.push(position));

        expect(positions.at(-1)).toMatchObject({
            startX: 40,
            startY: 90,
            width: 100,
            height: 720,
        });

        sub.unsubscribe();
        controller.dispose();
    });

    it('uses the full content box for sheet-like embed float dom runtimes', async () => {
        const rect = new Rect('dom-rect', {
            left: 30,
            top: 50,
            width: 50,
            height: 40,
        } as never);
        const { controller, add$, refreshTransform$, canvasFloatDomService } = createController({
            rects: [rect],
            drawing: {
                data: {
                    version: 1,
                    embedId: 'embed-1',
                    hostAnchorId: 'anchor-1',
                    childType: UniverInstanceType.UNIVER_SHEET,
                },
            },
        });

        publishEmbedRuntimeGeometry(refreshTransform$);
        add$.next([{ unitId: 'doc-1', subUnitId: 'doc-1', drawingId: 'dom-1' }]);
        await Promise.resolve();

        expect(canvasFloatDomService.addFloatDom).toHaveBeenCalledWith(expect.objectContaining({
            contentBox: { contentInset: 0, wrapperInset: 0 },
            eventPassThrough: false,
        }));

        controller.dispose();
    });

    it('keeps the legacy content box for other embed float dom runtimes', async () => {
        const rect = new Rect('dom-rect', {
            left: 30,
            top: 50,
            width: 50,
            height: 40,
        } as never);
        const { controller, add$, refreshTransform$, canvasFloatDomService } = createController({
            rects: [rect],
            drawing: {
                data: {
                    version: 1,
                    embedId: 'embed-1',
                    hostAnchorId: 'anchor-1',
                    childType: UniverInstanceType.UNIVER_SLIDE,
                },
            },
        });

        publishEmbedRuntimeGeometry(refreshTransform$);
        add$.next([{ unitId: 'doc-1', subUnitId: 'doc-1', drawingId: 'dom-1' }]);
        await Promise.resolve();

        expect(canvasFloatDomService.addFloatDom).toHaveBeenCalledWith(expect.objectContaining({
            contentBox: undefined,
            eventPassThrough: false,
        }));

        controller.dispose();
    });

    it('falls back to custom block viewport height when refreshes omit transform data', async () => {
        const rect = new Rect('dom-rect', {
            left: 30,
            top: 50,
            width: 50,
            height: 40,
        } as never);
        const { controller, add$, refreshTransform$, canvasFloatDomService } = createController({
            rects: [rect],
            drawing: {
                data: { version: 1, embedId: 'embed-1', hostAnchorId: 'anchor-1' },
            },
        });

        publishEmbedRuntimeGeometry(refreshTransform$);
        add$.next([{ unitId: 'doc-1', subUnitId: 'doc-1', drawingId: 'dom-1' }]);
        await Promise.resolve();

        const position$ = canvasFloatDomService.addFloatDom.mock.calls[0][0].position$;
        const positions: unknown[] = [];
        const sub = position$.subscribe((position: unknown) => positions.push(position));

        refreshTransform$.next([{
            unitId: 'doc-1',
            drawingId: 'dom-1',
            customBlockRenderViewport: { contentHeight: 240, height: 240, viewportHeight: 120 },
        }]);

        expect(positions.at(-1)).toMatchObject({
            startX: 40,
            startY: 90,
            width: 100,
            height: 720,
        });

        sub.unsubscribe();
        controller.dispose();
    });

    it('keeps the measured custom block size while following refreshed doc-flow position', async () => {
        const rect = new Rect('dom-rect', {
            left: 30,
            top: 50,
            width: 50,
            height: 40,
        } as never);
        const { controller, add$, refreshTransform$, canvasFloatDomService } = createController({
            rects: [rect],
            drawing: {
                data: { version: 1, embedId: 'embed-1', hostAnchorId: 'anchor-1' },
            },
        });

        publishEmbedRuntimeGeometry(refreshTransform$);
        add$.next([{ unitId: 'doc-1', subUnitId: 'doc-1', drawingId: 'dom-1' }]);
        await Promise.resolve();

        const position$ = canvasFloatDomService.addFloatDom.mock.calls[0][0].position$;
        const positions: unknown[] = [];
        const sub = position$.subscribe((position: unknown) => positions.push(position));

        refreshTransform$.next([{
            unitId: 'doc-1',
            drawingId: 'dom-1',
            transform: { left: 40, top: 60, width: 160, height: 240, angle: 0 },
            customBlockRenderViewport: { contentHeight: 240, height: 240, viewportHeight: 120 },
        }]);
        rect.transformByState({ left: 45, top: 65, width: 160, height: 40, angle: 0 } as never);
        refreshTransform$.next([{
            unitId: 'doc-1',
            drawingId: 'dom-1',
            transform: { left: 45, top: 65, width: 160, height: 40, angle: 0 },
        }]);

        expect(positions.at(-1)).toMatchObject({
            startX: 70,
            startY: 135,
            width: 320,
            height: 720,
        });

        sub.unsubscribe();
        controller.dispose();
    });

    it('keeps embed custom block size while moving slide-like blocks with doc flow refreshes', async () => {
        const rect = new Rect('dom-rect', {
            left: 30,
            top: 240,
            width: 720,
            height: 405,
        } as never);
        const { controller, add$, refreshTransform$, canvasFloatDomService } = createController({
            rects: [rect],
            drawing: {
                data: { version: 1, embedId: 'embed-1', hostAnchorId: 'anchor-1' },
            },
        });

        publishEmbedRuntimeGeometry(refreshTransform$, { left: 30, top: 240, width: 720, height: 405, angle: 0 });
        add$.next([{ unitId: 'doc-1', subUnitId: 'doc-1', drawingId: 'dom-1' }]);
        await Promise.resolve();

        const position$ = canvasFloatDomService.addFloatDom.mock.calls[0][0].position$;
        const positions: unknown[] = [];
        const sub = position$.subscribe((position: unknown) => positions.push(position));

        rect.transformByState({ left: 30, top: 60, width: 720, height: 405, angle: 0 } as never);
        refreshTransform$.next([{
            unitId: 'doc-1',
            drawingId: 'dom-1',
            transform: { left: 30, top: 60, width: 720, height: 405, angle: 0 },
        }]);

        expect(positions.at(-1)).toMatchObject({
            startY: 120,
            height: 1215,
        });

        sub.unsubscribe();
        controller.dispose();
    });

    it('falls back to custom block content height when viewport layout height is omitted', async () => {
        const rect = new Rect('dom-rect', {
            left: 30,
            top: 50,
            width: 50,
            height: 40,
        } as never);
        const { controller, add$, canvasFloatDomService } = createController({
            rects: [rect],
            drawing: {
                customBlockRenderViewport: { contentHeight: 240, viewportHeight: 120 },
            },
        });

        add$.next([{ unitId: 'doc-1', subUnitId: 'doc-1', drawingId: 'dom-1' }]);
        await Promise.resolve();

        const position$ = canvasFloatDomService.addFloatDom.mock.calls[0][0].position$;
        const positions: unknown[] = [];
        const sub = position$.subscribe((position: unknown) => positions.push(position));

        expect(positions.at(-1)).toMatchObject({
            height: 720,
        });

        sub.unsubscribe();
        controller.dispose();
    });

    it('inserts a float dom using page content width when no explicit width is provided', () => {
        const { controller, commandService } = createController();

        const drawingId = controller.insertFloatDom(
            { componentKey: 'FloatDom', data: { text: 'hello' } } as never,
            { height: 36, drawingId: 'fixed-dom-id' }
        );

        expect(drawingId).toBe('fixed-dom-id');
        expect(commandService.syncExecuteCommand).toHaveBeenCalledWith(
            InsertDocDrawingCommand.id,
            expect.objectContaining({
                unitId: 'doc-1',
                drawings: [
                    expect.objectContaining({
                        drawingId: 'fixed-dom-id',
                        drawingType: DrawingTypeEnum.DRAWING_DOM,
                        layoutType: expect.any(Number),
                        docTransform: expect.objectContaining({
                            size: { width: 190, height: 36 },
                        }),
                    }),
                ],
            })
        );

        controller.dispose();
    });
});