@univerjs-pro/embed-ui 1.0.0-alpha.7 → 1.0.0-beta.0

package/lib/types/common/embed-float-interaction-policy.d.ts

@@ -1,11 +1,9 @@
 import type { EmbedFloatingStage, EmbedInteractionFlow } from '../types/embed-ui';
 export interface IEmbedFloatInteractionPolicy {
     allowHostBodyDrag: boolean;
-    allowHostDragHandle: boolean;
     disableLiveHostPointerEvents: boolean;
     passThroughInteractionGate: boolean;
     runtimeOwnsInteraction: boolean;
-    showHostDragHandle: boolean;
 }
 export declare function resolveEmbedFloatInteractionPolicy(params: {
     stage: EmbedFloatingStage;

package/lib/types/common/embed-overlay-layers.d.ts

@@ -0,0 +1,4 @@
+/** Embed chrome sits above the embedded block while remaining below product overlays. */
+export declare const EMBED_CHROME_Z_INDEX = 800;
+/** Fullscreen covers other embed chrome while remaining below product overlays. */
+export declare const EMBED_FULLSCREEN_Z_INDEX = 810;

package/lib/types/components/EmbedFloatDomRenderer.d.ts

@@ -1,27 +1,6 @@
-import type { IDisposable } from '@univerjs/core';
 import type { Observable } from 'rxjs';
 import type { EmbedFloatingStage, EmbedInteractionFlow, IEmbedChildContainerContext } from '../types/embed-ui';
-import { UniverInstanceType } from '@univerjs/core';
-import { ILayoutService } from '@univerjs/ui';
-import { EmbedRuntimeFocusCoordinator } from '../services/embed-runtime-focus-coordinator.service';
-export declare const EMBED_FLOAT_DRAG_HANDLE_POINTER_DOWN_EVENT = "univer:embed-float-drag-handle:pointerdown";
-export interface IEmbedFloatDragHandlePointerDownDetail {
-    embedId: string;
-    hostUnitId: string;
-    hostAnchorId: string;
-    pointerId?: number;
-    clientX: number;
-    clientY: number;
-    button?: number;
-}
-export interface IEmbedFloatDomData {
-    version: 1;
-    embedId: string;
-    hostUnitId?: string;
-    hostAnchorId: string;
-    childUnitId?: string;
-    childType?: UniverInstanceType;
-}
+import type { IEmbedFloatDomData } from './embed-float-dom-data';
 export type IEmbedDocsCustomBlockLayout = {
     floatingMenuInsetTop: number;
     sheetLike: false;
@@ -29,8 +8,11 @@ export type IEmbedDocsCustomBlockLayout = {
     bleedLeft: number;
     bleedWidth: number;
     contentHeight: number;
+    contentWidth: number;
     floatingMenuInsetTop: number;
+    pageContentWidth: number;
     sheetLike: true;
+    viewScale: number;
     viewportHeight: number;
 };
 export declare function EmbedFloatDomRenderer(props: {
@@ -55,18 +37,3 @@ export declare function EmbedFloatDomRenderer(props: {
     resolveHostWheelGestureRoot?: (container: HTMLElement) => HTMLElement | null | undefined;
     isExternalHostInteraction?: (event: PointerEvent) => boolean;
 }): import("react").JSX.Element;
-export declare function syncRuntimeInteractionVisibility(container: HTMLElement, chrome: HTMLElement | undefined, visible: boolean, _stage: 'inactive' | 'stage1' | 'stage2'): void;
-export declare function syncChromeControlsVisibility(container: HTMLElement, chrome: HTMLElement | undefined, visible: boolean, dragHandleVisible: boolean, stage: 'inactive' | 'stage1' | 'stage2'): void;
-export declare function syncDocsSheetLikeChromePageArea(chrome: HTMLElement, chromeRect: DOMRect, pageRect: DOMRect): void;
-export declare function resolveChromeAnchorRect(container: HTMLElement): DOMRect;
-export declare function registerEmbedStage2LayoutContainers(layoutService: Pick<ILayoutService, 'checkElementInCurrentContainers' | 'registerContainerElement'>, focusCoordinator: Pick<EmbedRuntimeFocusCoordinator, 'listElements' | 'runtimeFocusChanged$'>, embedId: string | undefined, container: HTMLElement | null, stage: EmbedFloatingStage): IDisposable | undefined;
-export declare function shouldAcquireOwnedInteractionPointerLease(options: {
-    stage: EmbedFloatingStage;
-    target: EventTarget | null;
-    liveRoot: HTMLElement;
-    isOwnedChildInteraction: boolean;
-}): boolean;
-export declare function shouldPreserveFocusAfterOwnedPointerInteraction(options: {
-    now: number;
-    ownedPointerInteractionUntil: number;
-}): boolean;

package/lib/types/components/EmbedHostToolbarMenu.d.ts

@@ -1,6 +1,3 @@
-import type { EmbedLayout, IEmbedDescriptor } from '@univerjs-pro/embed';
-import type { IDisposable } from '@univerjs/core';
-import type { IEmbedChildContainerContext, IEmbedRenderScope } from '../types/embed-ui';
 import { Injector } from '@univerjs/core';
 export declare function EmbedHostToolbarMenu(): import("react").JSX.Element | null;
 interface IEmbedFullscreenRuntimeParts {
@@ -11,27 +8,4 @@ interface IEmbedFullscreenRuntimeParts {
 }
 export declare function EmbedFullscreenPopupParts(props: IEmbedFullscreenRuntimeParts): import("react").JSX.Element;
 export declare function EmbedFullscreenRightSidebarParts(props: IEmbedFullscreenRuntimeParts): import("react").JSX.Element;
-export declare function createFullscreenRenderScope(descriptor: IEmbedDescriptor, layout: EmbedLayout, roots: {
-    viewport: HTMLElement;
-    menuSlot: HTMLElement;
-    popupSlot?: HTMLElement;
-    footerSlot: HTMLElement;
-}): IEmbedRenderScope;
-export declare function registerFullscreenRuntimeOwnership(params: {
-    injector: Injector;
-    descriptor: IEmbedDescriptor;
-    renderScope: IEmbedRenderScope;
-    menuRoot: HTMLElement | null;
-    menuSlot: HTMLElement;
-    popupSlot: HTMLElement;
-    sidebarSlot: HTMLElement;
-    rightSidebarSlot: HTMLElement;
-    footerSlot: HTMLElement;
-}): IDisposable;
-export declare function mountFullscreenWorkbenchMenus(params: {
-    injector: Injector;
-    descriptor: IEmbedDescriptor;
-    childContext: IEmbedChildContainerContext;
-    menuContainer: HTMLElement;
-}): IDisposable | undefined;
 export {};

package/lib/types/components/embed-float-dom-data.d.ts

@@ -0,0 +1,10 @@
+import type { UniverInstanceType } from '@univerjs/core';
+export interface IEmbedFloatDomData {
+    childType?: UniverInstanceType;
+    childUnitId?: string;
+    embedId: string;
+    hostAnchorId: string;
+    hostUnitId?: string;
+    version: 1;
+}
+export declare function normalizeEmbedFloatDomData(data: unknown): IEmbedFloatDomData | undefined;

package/lib/types/components/embed-float-dom-geometry.d.ts

@@ -0,0 +1,95 @@
+import type { IDisposable } from '@univerjs/core';
+import type { Observable } from 'rxjs';
+import type { EmbedFloatingGeometryService } from '../services/embed-floating-geometry.service';
+import type { EmbedFloatingStage, IEmbedChildContainerContext, IEmbedPassiveViewportProvider } from '../types/embed-ui';
+interface IEmbedFloatDomRect {
+    height: number;
+    left: number;
+    top: number;
+    width: number;
+}
+export declare const MIN_DOCS_SHEET_LIKE_RUNTIME_INTERACTION_HEIGHT = 24;
+export declare const MIN_EMBED_FLOATING_CHROME_CONTROLS_HEIGHT = 40;
+export type EmbedVerticalScrollOwner = 'host' | 'child' | undefined;
+interface IDocsEmbedVerticalScrollState {
+    childOffset: number;
+    clipBottom: number;
+    visualOffset: number;
+}
+export interface IEmbedHostVerticalScrollSyncOptions {
+    container: HTMLElement;
+    content: HTMLElement;
+    contentHeight?: number;
+    enabled?: boolean;
+    getChildContext: () => IEmbedChildContainerContext | undefined;
+    getProvider: (context: IEmbedChildContainerContext) => IEmbedPassiveViewportProvider | undefined;
+    getStage: () => EmbedFloatingStage;
+    hostLayout$?: Observable<unknown>;
+    invalidate: () => void;
+    offset: {
+        current: number;
+    };
+    onHostWheel?: (event: WheelEvent, context: IEmbedChildContainerContext) => boolean | void;
+    owner: {
+        current: EmbedVerticalScrollOwner;
+    };
+    syncingChildFromHost: {
+        current: boolean;
+    };
+    syncingHostFromChild: {
+        current: boolean;
+    };
+    viewScale?: number;
+    viewportHeight?: number;
+}
+export declare function registerEmbedHostVerticalScrollSync(options: IEmbedHostVerticalScrollSyncOptions): IDisposable;
+export declare function canWriteDocsEmbedVerticalScroll(owner: EmbedVerticalScrollOwner, writer: Exclude<EmbedVerticalScrollOwner, undefined>): boolean;
+export declare function resolveDocsEmbedHostScrollDelta(targetOffset: number, currentOffset: number, distanceToSticky: number): number;
+export declare function resolveDocsEmbedVerticalScrollState(params: {
+    contentHeight: number;
+    hostOffset: number;
+    stickyHeaderHeight: number;
+    viewportHeight: number;
+}): IDocsEmbedVerticalScrollState;
+export declare function resolveDocsSheetLikeHorizontalMetrics(layout: {
+    bleedLeft: number;
+    bleedWidth: number;
+    contentWidth: number;
+}): {
+    initialWidth: number;
+    maxExpansion: number;
+};
+export declare function clampNumber(value: number, min: number, max: number): number;
+export declare function resetEmbedChromeLayoutStyles(chrome: HTMLElement): void;
+export declare function cacheEmbedFloatDomRect(container: HTMLElement, rect?: IEmbedFloatDomRect): void;
+export declare function registerEmbedChromeLayout(options: {
+    chrome: HTMLElement;
+    container: HTMLElement;
+    deferInactive?: boolean;
+    docsSheetLikeLayout?: {
+        contentWidth: number;
+        pageContentWidth: number;
+    };
+    embedId?: string;
+    geometryService: EmbedFloatingGeometryService;
+    hostLayout$?: Observable<unknown>;
+    stage: EmbedFloatingStage;
+}): IDisposable;
+export declare function isPointInsideFloatBlock(container: HTMLElement, event: MouseEvent): boolean;
+export declare function syncRuntimeInteractionVisibility(container: HTMLElement, chrome: HTMLElement | undefined, visible: boolean, _stage: EmbedFloatingStage): void;
+export declare function syncChromeControlsVisibility(container: HTMLElement, chrome: HTMLElement | undefined, visible: boolean, stage: EmbedFloatingStage): void;
+export declare function syncDocsSheetLikeChromePageArea(chrome: HTMLElement, chromeRect: DOMRect, pageRect: DOMRect): void;
+export declare function resolveDocsSheetLikePageAreaRect(containerRect: DOMRect, layout?: {
+    contentWidth: number;
+    pageContentWidth: number;
+}): DOMRect;
+export declare function clearDocsSheetLikeChromePageArea(chrome: HTMLElement): void;
+export declare function resolveChromeAnchorRect(container: HTMLElement): DOMRect;
+export declare function isDocsSheetLikeChrome(container: HTMLElement): boolean;
+export declare function isDocsCustomBlockChrome(container: HTMLElement): boolean;
+export declare function invalidateGeometryAfterRuntimeScroll(geometryService: EmbedFloatingGeometryService, embedId: string | undefined, reason: 'child-scroll' | 'host-scroll' | 'wheel', framesRef: {
+    current: number[];
+}): void;
+export declare function shouldSyncChromeRectForGlobalEvent(container: HTMLElement, event: Event | undefined, cachedRect: Partial<IEmbedFloatDomRect>): boolean;
+export declare function isVerticalWheelOrScrollEvent(event: Event | undefined): boolean;
+export {};

package/lib/types/components/embed-float-dom-interaction.d.ts

@@ -0,0 +1,114 @@
+import type { EmbedModelService } from '@univerjs-pro/embed';
+import type { IDisposable } from '@univerjs/core';
+import type { ILayoutService } from '@univerjs/ui';
+import type { EmbedActivationService } from '../services/embed-activation.service';
+import type { EmbedFloatingActiveService } from '../services/embed-floating-active.service';
+import type { EmbedInteractionBoundaryService } from '../services/embed-interaction-boundary.service';
+import type { EmbedRuntimeFocusCoordinator, EmbedRuntimeFocusRole } from '../services/embed-runtime-focus-coordinator.service';
+import type { EmbedFloatingStage, EmbedInteractionFlow } from '../types/embed-ui';
+import type { EmbedVerticalScrollOwner } from './embed-float-dom-geometry';
+import { UniverInstanceType } from '@univerjs/core';
+export declare const EMBED_FLOAT_CHROME_CONTROL_SELECTOR = "[data-embed-floating-menu=\"true\"], [data-embed-floating-menu-popup=\"true\"], [data-embed-ribbon-override=\"true\"]";
+export declare const EMBED_FLOAT_DRAG_HANDLE_POINTER_DOWN_EVENT = "univer:embed-float-drag-handle:pointerdown";
+export interface IEmbedFloatDragHandlePointerDownDetail {
+    button?: number;
+    clientX: number;
+    clientY: number;
+    embedId: string;
+    hostAnchorId: string;
+    hostUnitId: string;
+    pointerId?: number;
+}
+export declare function getRuntimeRootElements(...roots: Array<HTMLElement | null | undefined>): HTMLElement[];
+export declare function findRuntimeCanvas(roots: HTMLElement[], target?: EventTarget | null): HTMLCanvasElement | null;
+export declare function shouldAutoFocusRuntimeCanvas(childType: UniverInstanceType | undefined, allowBase?: boolean): boolean;
+export declare function isChildEditorOrPopupRuntimeElement(target: EventTarget | null): boolean;
+export declare function getRuntimeFocusRole(target: EventTarget | null): EmbedRuntimeFocusRole | undefined;
+export declare function registerEmbedStage2LayoutContainers(layoutService: Pick<ILayoutService, 'checkElementInCurrentContainers' | 'registerContainerElement'>, focusCoordinator: Pick<EmbedRuntimeFocusCoordinator, 'listElements' | 'runtimeFocusChanged$'>, embedId: string | undefined, container: HTMLElement | null, stage: EmbedFloatingStage): IDisposable | undefined;
+export declare function shouldAcquireOwnedInteractionPointerLease(options: {
+    stage: EmbedFloatingStage;
+    target: EventTarget | null;
+    liveRoot: HTMLElement;
+    isOwnedChildInteraction: boolean;
+}): boolean;
+export declare function shouldPreserveFocusAfterOwnedPointerInteraction(options: {
+    now: number;
+    ownedPointerInteractionUntil: number;
+}): boolean;
+export declare function registerEmbedOutsideInteraction(options: {
+    activationService: EmbedActivationService;
+    chrome: HTMLElement | null;
+    container: HTMLElement;
+    embedId: string;
+    externalHostInteractionUntil: {
+        current: number;
+    };
+    floatingActiveService: EmbedFloatingActiveService;
+    focusCoordinator: EmbedRuntimeFocusCoordinator;
+    graceMs: number;
+    hostUnitId?: string;
+    interactionBoundaryService: EmbedInteractionBoundaryService;
+    isExternalHostInteraction?: (event: PointerEvent) => boolean;
+    ownedPointerInteractionUntil: {
+        current: number;
+    };
+    runtimeFocusOwners: string[];
+}): IDisposable;
+export declare function registerEmbedActivationInteraction(options: {
+    acquireStage2SessionLease: () => void;
+    activationService: EmbedActivationService;
+    data: {
+        embedId: string;
+        hostAnchorId: string;
+        hostUnitId: string;
+    };
+    embedModelService: EmbedModelService;
+    enableStage1BodyDrag?: boolean;
+    floatingActiveService: EmbedFloatingActiveService;
+    gate: HTMLElement;
+    interactionFlow: EmbedInteractionFlow;
+    popupRoot: HTMLElement | null;
+    releaseStage2SessionLeaseIfActivationDoesNotStick: () => void;
+}): IDisposable;
+export declare function registerEmbedCanvasFocus(options: {
+    acquireStage2SessionLease: () => void;
+    activationService: EmbedActivationService;
+    data: {
+        childType?: UniverInstanceType;
+        embedId?: string;
+        hostUnitId?: string;
+    };
+    embedModelService: EmbedModelService;
+    floatingActiveService: EmbedFloatingActiveService;
+    focusCoordinator: EmbedRuntimeFocusCoordinator;
+    getRuntimeRoots: () => HTMLElement[];
+    interactionFlow: EmbedInteractionFlow;
+    liveRoot: HTMLElement;
+    popupRoot: HTMLElement | null;
+    releaseStage2SessionLeaseIfActivationDoesNotStick: () => void;
+    runtimeFocusOwners: string[];
+}): IDisposable;
+export declare function registerEmbedPointerLease(options: {
+    data: {
+        childType?: UniverInstanceType;
+        childUnitId?: string;
+        embedId: string;
+        hostUnitId?: string;
+    };
+    floatingActiveService: EmbedFloatingActiveService;
+    focusCoordinator: EmbedRuntimeFocusCoordinator;
+    graceMs: number;
+    interactionBoundaryService: EmbedInteractionBoundaryService;
+    liveRoot: HTMLElement;
+    ownedPointerInteractionUntil: {
+        current: number;
+    };
+    pointerLease: {
+        current: IDisposable | undefined;
+    };
+    verticalScrollOwner: {
+        current: EmbedVerticalScrollOwner;
+    };
+}): IDisposable;
+export declare function isHostFocusSurface(target: HTMLElement): boolean;
+export declare function blurRuntimeFocusIfOwnedByBlock(embedId: string | undefined, roots: HTMLElement[]): void;

package/lib/types/plugin.d.ts

@@ -1,19 +1,21 @@
 import type { IUniverEmbedUIPluginConfig } from './config/config';
-import { IConfigService, Injector, Plugin, UniverInstanceType } from '@univerjs/core';
+import { IConfigService, Injector, IUniverInstanceService, Plugin, UniverInstanceType } from '@univerjs/core';
 export declare class UniverEmbedUIPlugin extends Plugin {
     private readonly _config;
     protected readonly _injector: Injector;
     private readonly _configService;
+    private readonly _univerInstanceService;
     static pluginName: string;
     static packageName: string;
     static version: string;
     static type: UniverInstanceType;
-    constructor(_config: Partial<IUniverEmbedUIPluginConfig> | undefined, _injector: Injector, _configService: IConfigService);
+    constructor(_config: Partial<IUniverEmbedUIPluginConfig> | undefined, _injector: Injector, _configService: IConfigService, _univerInstanceService: IUniverInstanceService);
     onStarting(): void;
     onReady(): void;
     private _registerServices;
     private _registerProductMenus;
     private _registerProductUIContributions;
+    private _registerLateProductUIContributions;
     private _flushPendingContributions;
     private _registerFloatingMenus;
     private _touchServices;

package/lib/types/products/bases/BaseFullscreenTableSidebar.d.ts

@@ -0,0 +1,31 @@
+import type { BaseDataModel, BaseViewType, ITableSnapshot, IViewSnapshot } from '@univerjs/core';
+export declare function BaseFullscreenTablePanelPortal(props: {
+    embedId: string;
+    childUnitId: string;
+    base: BaseDataModel;
+    activeTable: ITableSnapshot;
+}): import("react").ReactPortal | null;
+export declare function BaseEmbedFullscreenViewTabs(props: {
+    embedId: string;
+    activeView: IViewSnapshot;
+    views: IViewSnapshot[];
+    addViewOpen: boolean;
+    onAddViewOpenChange: (open: boolean) => void;
+    onActivateView: (viewId: string) => void;
+    onAddView: (type: BaseViewType) => void;
+    onSetViewAsFirst: (viewId: string) => void;
+    onMoveView: (viewId: string, target: {
+        beforeViewId?: string;
+        afterViewId?: string;
+    }) => void;
+    onRenameView: (viewId: string, name: string) => void;
+    onDuplicateView: (viewId: string) => void;
+    onConfigureView: (anchor: HTMLElement, viewId: string) => void;
+    onDeleteView: (viewId: string) => void;
+}): import("react").JSX.Element;
+export declare function getVisibleBaseTables(snapshot: ReturnType<BaseDataModel['getSnapshot']> | undefined): ITableSnapshot[];
+export declare function createBaseFullscreenTableSidebarItems(snapshot: ReturnType<BaseDataModel['getSnapshot']> | undefined, activeTableId: string | null | undefined): {
+    id: string;
+    name: string;
+    active: boolean;
+}[];

package/lib/types/products/bases/EmbedChildView.d.ts

@@ -1,13 +1,16 @@
 import type { IUniverBaseUIConfig } from '@univerjs-pro/bases-ui';
+import type { EmbedDisplayTarget, IEmbedBaseDisplayTarget } from '@univerjs-pro/embed';
 import type { BaseDataModel, Injector } from '@univerjs/core';
 import type { IEmbedChildContainerContext, IEmbedChildViewContribution } from '../../types/embed-ui';
 import { BaseEditorService, BaseUIPopupService, BaseUIStateService, IBaseUIPopupService, IBaseViewWheelScrollService } from '@univerjs-pro/bases-ui';
+import { ICommandService } from '@univerjs/core';
 export type BaseEmbedChromeMode = 'workbench' | 'content-only' | 'fullscreen';
-export declare function createBasesEmbedChildViewContribution(): IEmbedChildViewContribution;
+export declare function createBasesEmbedChildViewContribution(commandService: ICommandService): IEmbedChildViewContribution;
 export declare function isBaseCanvasRootReady(canvasRoot: HTMLElement | null): canvasRoot is HTMLElement;
 export declare function shouldActivateBasesEmbedRender(_context: Pick<IEmbedChildContainerContext, 'renderScope'>): boolean;
 export declare function createBasesEmbedChildUnitScopedInjector(context: IEmbedChildContainerContext, baseStateService: BaseUIStateService, basePopupService: IBaseUIPopupService, baseEditorService: BaseEditorService): Injector | undefined;
-export declare function initializeBasesEmbedState(stateService: BaseUIStateService, childUnit: BaseDataModel, chromeMode?: BaseEmbedChromeMode): void;
+export declare function initializeBasesEmbedState(stateService: BaseUIStateService, childUnit: BaseDataModel, chromeMode?: BaseEmbedChromeMode, displayTarget?: EmbedDisplayTarget): void;
+export declare function resolveBasesDisplayTarget(childUnit: BaseDataModel, displayTarget?: EmbedDisplayTarget): IEmbedBaseDisplayTarget;
 export declare function resolveBasesEmbedChromeMode(context: Pick<IEmbedChildContainerContext, 'renderScope'>): BaseEmbedChromeMode;
 export declare function createBasesEmbedScopedInjector(rootInjector: Injector, childScopedInjector: Injector, baseStateService: BaseUIStateService, basePopupService?: BaseUIPopupService, baseEditorService?: BaseEditorService, chromeMode?: BaseEmbedChromeMode, baseWheelScrollService?: IBaseViewWheelScrollService, readOnly?: boolean, globalPortalContainer?: HTMLElement | null): Injector;
 export declare function resolveEmbeddedBaseUIConfig(baseConfig: IUniverBaseUIConfig, chromeMode?: BaseEmbedChromeMode): IUniverBaseUIConfig;

package/lib/types/products/bases/EmbedFloatingMenu.d.ts

@@ -1,5 +1,5 @@
 import type { IBaseToolbarState } from '@univerjs-pro/bases-ui';
-import type { BaseDataModel, IViewSnapshot } from '@univerjs/core';
+import type { IViewSnapshot } from '@univerjs/core';
 import type { IEmbedFloatingMenuContribution } from '../../types/embed-ui';
 export declare const BASE_EMBED_VIEW_PANEL_WIDTH = 208;
 export declare function createBasesFloatingMenuContributions(): IEmbedFloatingMenuContribution[];
@@ -19,11 +19,6 @@ export declare function createBaseFloatingToolbarState(view: IViewSnapshot, undo
     undos?: number;
     redos?: number;
 }): IBaseToolbarState;
-export declare function createBaseFullscreenTableSidebarItems(snapshot: ReturnType<BaseDataModel['getSnapshot']> | undefined, activeTableId: string | null | undefined): {
-    id: string;
-    name: string;
-    active: boolean;
-}[];
 export declare function viewPanelStyle(anchor: DOMRect): {
     top: number;
     left: number;

package/lib/types/products/bases/embed-content-size.d.ts

@@ -1,9 +1,15 @@
 import type { IEmbedContentSizeProvider } from '../../types/embed-ui';
-interface IBaseContentSizeActiveState {
-    activeTableId?: string;
-    activeViewId?: string;
+import { IBaseProjectionService } from '@univerjs-pro/bases';
+import { IBaseUIStateService, IBaseViewWheelScrollService } from '@univerjs-pro/bases-ui';
+import { UniverInstanceType } from '@univerjs/core';
+export declare class BasesEmbedContentSizeProvider implements IEmbedContentSizeProvider {
+    private readonly _baseUIStateService;
+    private readonly _projectionService;
+    private readonly _wheelScrollService;
+    readonly childType = UniverInstanceType.UNIVER_BASE;
+    constructor(_baseUIStateService: IBaseUIStateService, _projectionService: IBaseProjectionService, _wheelScrollService: IBaseViewWheelScrollService);
+    measureContentSize(context: Parameters<IEmbedContentSizeProvider['measureContentSize']>[0]): {
+        height: number | undefined;
+        width: number | undefined;
+    } | undefined;
 }
-export declare function createBasesContentSizeProvider(baseUIStateService?: {
-    getState?: () => IBaseContentSizeActiveState | undefined;
-}): IEmbedContentSizeProvider;
-export {};

package/lib/types/products/bases/embed-passive-viewport.d.ts

@@ -1,3 +1,2 @@
-import type { Injector } from '@univerjs/core';
-import type { IEmbedPassiveViewportProvider } from '../../types/embed-ui';
-export declare function createBasesPassiveViewportProvider(rootInjector: Injector): IEmbedPassiveViewportProvider;
+import type { IEmbedChildContainerContext, IEmbedPassiveViewportProvider } from '../../types/embed-ui';
+export declare function createBasesPassiveViewportProvider(rootInjector: IEmbedChildContainerContext['injector']): IEmbedPassiveViewportProvider;

package/lib/types/products/bases/register.d.ts

@@ -5,6 +5,7 @@ import { EmbedActivationService } from '../../services/embed-activation.service'
 import { EmbedHostRestoreService } from '../../services/embed-host-restore.service';
 import { EmbedMountService } from '../../services/embed-mount.service';
 export declare function registerBasesEmbedUIContributions(injector: Injector): void;
+export declare function registerBasesEmbedContentSizeProvider(injector: Injector): void;
 export declare function createBasesEmbedRuntimeService(params: {
     embedModelService: EmbedModelService;
     restoreService: EmbedHostRestoreService;

package/lib/types/products/docs/EmbedDocsCustomBlockRenderer.d.ts

@@ -1,4 +1,4 @@
-import type { IEmbedFloatDomData } from '../../components/EmbedFloatDomRenderer';
+import type { IEmbedFloatDomData } from '../../components/embed-float-dom-data';
 import { IRenderManagerService } from '@univerjs/engine-render';
 export interface IEmbedDocsCustomBlockRuntimeProps {
     customBlockRenderViewport?: {
@@ -7,22 +7,15 @@ export interface IEmbedDocsCustomBlockRuntimeProps {
         contentHeight?: number;
         contentWidth?: number;
         height?: number;
+        pageContentWidth?: number;
+        viewScale?: number;
         viewportHeight?: number;
     };
 }
-export interface IDocsTableLikeCustomBlockWheelHandlerOptions {
-    getLive: () => HTMLElement | null;
-    getMaxScrollLeft?: () => number | undefined;
-}
-export interface IDocsTableLikeCustomBlockStage2WheelHandlerOptions extends IDocsTableLikeCustomBlockWheelHandlerOptions {
-    getStage: () => 'inactive' | 'stage1' | 'stage2' | undefined;
-}
 export declare function EmbedDocsCustomBlockRenderer(props: {
     data?: IEmbedFloatDomData;
 } & IEmbedDocsCustomBlockRuntimeProps): import("react").JSX.Element;
 export declare function blurHostDocSelectionWhenEmbedRuntimeEntersStage(renderManagerService: IRenderManagerService, hostUnitId: string | undefined, stage: 'inactive' | 'stage1' | 'stage2'): void;
-export declare function createDocsTableLikeCustomBlockWheelHandler(options: IDocsTableLikeCustomBlockWheelHandlerOptions): (event: WheelEvent) => void;
-export declare function createDocsTableLikeCustomBlockStage2WheelHandler(options: IDocsTableLikeCustomBlockStage2WheelHandlerOptions): (event: WheelEvent) => void;
 export declare function resolveDocsTableLikeCustomBlockRuntimeContentHeight(authoritativeContentHeight: number | undefined): number;
 export declare function resolveDocsCustomBlockRuntimeViewportHeight(params: {
     contentHeight: number;

package/lib/types/products/docs/docs-custom-block-layout.d.ts

@@ -1,5 +1,6 @@
 export declare const DOCS_CUSTOM_BLOCK_FLOATING_MENU_INSET_TOP = 52;
+export declare function resolveDocsSheetCustomBlockContentHeight(contentHeight: number): number;
 export declare function resolveDocsCustomBlockLayoutHeight(params: {
     contentHeight: number;
-    tableLike: boolean;
+    floatingMenuInsetTop: number;
 }): number;

package/lib/types/products/docs/embed-docs-custom-block-bleed.render-controller.d.ts

@@ -2,6 +2,7 @@ import type { DocumentDataModel } from '@univerjs/core';
 import type { IRenderContext, IRenderModule } from '@univerjs/engine-render';
 import { EmbedModelService } from '@univerjs-pro/embed';
 import { Disposable, ICommandService, IUniverInstanceService } from '@univerjs/core';
+import { DocViewScaleService } from '@univerjs/docs-ui';
 import { IRenderManagerService } from '@univerjs/engine-render';
 import { EmbedContentSizeRegistryService } from '../../services/embed-content-size-registry.service';
 export declare class EmbedDocsCustomBlockBleedRenderController extends Disposable implements IRenderModule {
@@ -11,9 +12,10 @@ export declare class EmbedDocsCustomBlockBleedRenderController extends Disposabl
     private readonly _contentSizeRegistry;
     private readonly _embedModelService;
     private readonly _renderManagerService;
+    private readonly _docViewScaleService;
     private readonly _resolvedChildUnits;
     private readonly _pendingChildUnits;
-    constructor(_context: IRenderContext<DocumentDataModel>, _univerInstanceService: IUniverInstanceService, _commandService: ICommandService, _contentSizeRegistry: EmbedContentSizeRegistryService, _embedModelService: EmbedModelService, _renderManagerService: IRenderManagerService);
+    constructor(_context: IRenderContext<DocumentDataModel>, _univerInstanceService: IUniverInstanceService, _commandService: ICommandService, _contentSizeRegistry: EmbedContentSizeRegistryService, _embedModelService: EmbedModelService, _renderManagerService: IRenderManagerService, _docViewScaleService: DocViewScaleService);
     private _getHostUnit;
     private _getHostSnapshot;
     private _rerenderHostDoc;
@@ -23,3 +25,6 @@ export declare class EmbedDocsCustomBlockBleedRenderController extends Disposabl
     private _getDocsLeft;
     private _getVisibleCanvasDocumentRect;
 }
+export declare function observeDocsCustomBlockCanvasResize(canvas: Element | null | undefined, onResize: () => void): {
+    dispose: () => void;
+} | undefined;

package/lib/types/products/product-ui-contributions.d.ts

@@ -1,2 +1,3 @@
 import type { Injector } from '@univerjs/core';
 export declare function registerDefaultEmbedProductUIContributions(injector: Injector): void;
+export declare function registerDefaultEmbedProductUILateContributions(injector: Injector): void;

package/lib/types/products/sheets/EmbedBlock.d.ts

@@ -1,6 +1,9 @@
+import type { EmbedDisplayTarget } from '@univerjs-pro/embed';
+import type { ICommandService, Workbook } from '@univerjs/core';
 import type { IEmbedBlockContribution, IEmbedChildContainerContext, IEmbedChildViewContribution } from '../../types/embed-ui';
 export declare function createSheetsEmbedBlockContribution(): IEmbedBlockContribution;
-export declare function createSheetsEmbedChildViewContribution(): IEmbedChildViewContribution;
+export declare function createSheetsEmbedChildViewContribution(commandService: ICommandService): IEmbedChildViewContribution;
+export declare function applySheetDisplayTarget(workbook: Workbook, target: EmbedDisplayTarget | undefined): void;
 export declare function shouldShowEmbeddedSheetChrome(context: Pick<IEmbedChildContainerContext, 'renderScope'>): boolean;
 export declare function applyEmbeddedSheetChromeInset(canvasRoot: HTMLElement, chrome: {
     formulaBar: boolean;

package/lib/types/products/sheets/EmbedFloatingMenu.d.ts

@@ -1,7 +1,6 @@
-import type { IMenuItem, IMenuSchema, IValueOption } from '@univerjs/ui';
+import type { IMenuItem, IMenuSchema } from '@univerjs/ui';
 import type { IEmbedFloatingMenuContribution } from '../../types/embed-ui';
-import { BORDER_LINE_CHILDREN } from '@univerjs/sheets-ui';
-import { FONT_SIZE_LIST } from '@univerjs/ui';
+import type { IResolvedSheetsFloatingToolbarMenuItems } from './SheetEmbedFloatingMenuControls';
 export type SheetFloatingToolbarItem = {
     id: string;
     type: 'button' | 'dropdown';
@@ -10,41 +9,11 @@ export type SheetFloatingToolbarItem = {
     type: 'divider';
 };
 export declare function createSheetsFloatingToolbarItems(): SheetFloatingToolbarItem[];
-export declare function createSheetsFloatingBorderLineItems(): typeof BORDER_LINE_CHILDREN;
-export declare function createSheetsFloatingFontSizeItems(): typeof FONT_SIZE_LIST;
-export interface IResolvedSheetsFloatingToolbarMenuItems {
-    formatPainter?: IMenuItem;
-    numberFormat?: IMenuItem;
-    fontFamily?: IMenuItem;
-    fontSize?: IMenuItem;
-    bold?: IMenuItem;
-    textColor?: IMenuItem;
-    backgroundColor?: IMenuItem;
-    borderComposite?: IMenuItem;
-    merge?: {
-        root?: IMenuItem;
-        all?: IMenuItem;
-        vertical?: IMenuItem;
-        horizontal?: IMenuItem;
-        unmerge?: IMenuItem;
-    };
-    horizontalAlign?: IMenuItem;
-    verticalAlign?: IMenuItem;
-    wrap?: IMenuItem;
-    filter?: IMenuItem;
-    deleteBlock?: true;
-}
 export declare function resolveSheetsFloatingToolbarMenuItems(menuSchemas: IMenuSchema[]): IResolvedSheetsFloatingToolbarMenuItems;
 export declare function createVisibleSheetsFloatingToolbarItems(resolved: IResolvedSheetsFloatingToolbarMenuItems): SheetFloatingToolbarItem[];
-export declare function getStaticMenuSelections(item: IMenuItem | undefined): IValueOption[];
 export declare function resolveMenuCommandRequest(item: IMenuItem | undefined, params?: object): {
     commandId: string;
     params?: object;
 } | undefined;
 export declare function createSheetsFloatingMenuContributions(): IEmbedFloatingMenuContribution[];
 export declare function shouldUseSheetsFloatingMenuDomStage(_entry: string): boolean;
-export declare function isFloatingDropdownOwnSurfaceTarget(target: EventTarget | null, embedId: string): boolean;
-export declare function keepFloatingDropdownOpenForOwnSurface(event: {
-    target: EventTarget | null;
-    preventDefault: () => void;
-}, embedId: string): void;