@univerjs-pro/embed-ui 1.0.0-alpha.8 → 1.0.0-beta.1

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

@@ -0,0 +1,92 @@
+import type { IMenuItem } from '@univerjs/ui';
+import type { ReactNode } from 'react';
+import type { LocaleKey } from '../../locale/types';
+import { BorderStyleTypes, BorderType } from '@univerjs/core';
+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 NumberFormatDropdown(props: {
+    menuItem: IMenuItem | undefined;
+    onClick: () => void;
+}): import("react").JSX.Element | null;
+export declare function FontFamilyFloatingDropdown(props: {
+    embedId: string;
+    menuItem: IMenuItem | undefined;
+    title: LocaleKey;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onSelect: (value: string) => void;
+}): import("react").JSX.Element | null;
+export declare function FontSizeFloatingDropdown(props: {
+    embedId: string;
+    menuItem: IMenuItem | undefined;
+    title: LocaleKey;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onSelect: (value: string) => void;
+}): import("react").JSX.Element | null;
+export declare function HorizontalAlignDropdown(props: {
+    embedId: string;
+    menuItem: IMenuItem | undefined;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    execute: (item: IMenuItem | undefined, params?: object) => void;
+}): import("react").JSX.Element | null;
+export declare function VerticalAlignDropdown(props: {
+    embedId: string;
+    menuItem: IMenuItem | undefined;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    execute: (item: IMenuItem | undefined, params?: object) => void;
+}): import("react").JSX.Element | null;
+export declare function ColorDropdown(props: {
+    embedId: string;
+    menuItem: IMenuItem | undefined;
+    title: LocaleKey;
+    icon: ReactNode;
+    defaultColor: string;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onChange: (value: string) => void;
+    onReset: () => void;
+}): import("react").JSX.Element | null;
+export declare function BorderCompositeDropdown(props: {
+    embedId: string;
+    menuItem: IMenuItem | undefined;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onSelect: (type: BorderType, style?: BorderStyleTypes, color?: string) => void;
+}): import("react").JSX.Element | null;
+export declare function MergeDropdown(props: {
+    embedId: string;
+    menuItems: IResolvedSheetsFloatingToolbarMenuItems['merge'];
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    execute: (item: IMenuItem | undefined, params?: object) => void;
+}): import("react").JSX.Element | null;
+export declare function WrapDropdown(props: {
+    embedId: string;
+    menuItem: IMenuItem | undefined;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    execute: (commandId: string, params?: object) => void;
+}): import("react").JSX.Element | null;

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

@@ -0,0 +1,85 @@
+import type { IMenuItem, IValueOption } from '@univerjs/ui';
+import type { ButtonHTMLAttributes, HTMLAttributes, ReactNode } from 'react';
+import type { LocaleKey } from '../../locale/types';
+export declare const FloatingToolbarTrigger: import("react").ForwardRefExoticComponent<ButtonHTMLAttributes<HTMLButtonElement> & {
+    children: ReactNode;
+    title: string;
+} & import("react").RefAttributes<HTMLButtonElement>>;
+export declare const FloatingToolbarSplitTrigger: import("react").ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
+    title: string;
+    primary: ReactNode;
+    disabled?: boolean;
+    open?: boolean;
+    onPrimaryClick: () => void;
+} & import("react").RefAttributes<HTMLDivElement>>;
+export declare function MenuButton(props: {
+    children: ReactNode;
+    title: string;
+    className?: string;
+    disabled?: boolean;
+    active?: boolean;
+    onClick: () => void;
+}): import("react").JSX.Element;
+export declare function MenuButtonFromMenu(props: {
+    item: IMenuItem | undefined;
+    children: ReactNode;
+    title: LocaleKey;
+    onClick: () => void;
+}): import("react").JSX.Element | null;
+export declare function useMenuItemRuntimeState(item: IMenuItem | undefined): {
+    hidden: boolean;
+    disabled: boolean;
+    activated: boolean;
+    value: unknown;
+};
+export declare function getMenuTitle(item: IMenuItem): string;
+export declare function getOptionLabel(option: IValueOption): string;
+export declare function getWrapIcon(value: IValueOption['value']): ReactNode;
+export declare function keepFloatingPanelInteraction(event: React.MouseEvent<HTMLElement> | React.PointerEvent<HTMLElement>): void;
+export declare function isFloatingDropdownOwnSurfaceTarget(target: EventTarget | null, embedId: string): boolean;
+export declare function keepFloatingDropdownOpenForOwnSurface(event: {
+    target: EventTarget | null;
+    preventDefault: () => void;
+}, embedId: string): void;
+export declare function Panel(props: {
+    embedId: string;
+    children: ReactNode;
+    onPointerDown: (event: React.PointerEvent<HTMLElement>) => void;
+}): import("react").JSX.Element;
+export declare function PanelRow(props: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function InlineFloatingDropdown(props: {
+    embedId: string;
+    title: LocaleKey;
+    trigger: ReactNode;
+    overlay: ReactNode;
+    disabled?: boolean;
+    triggerClassName?: string;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+}): import("react").JSX.Element;
+export declare function MenuPanel(props: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function RibbonListPanel(props: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function RibbonListItem(props: {
+    children: ReactNode;
+    icon: ReactNode;
+    onClick: () => void;
+}): import("react").JSX.Element;
+export declare function MenuPanelItem(props: {
+    children: ReactNode;
+    icon?: ReactNode;
+    active?: boolean;
+    onClick: () => void;
+}): import("react").JSX.Element;
+export declare function PanelButton(props: {
+    title: string;
+    active?: boolean;
+    disabled?: boolean;
+    children: ReactNode;
+    onClick: () => void;
+}): import("react").JSX.Element;

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

@@ -1,2 +1,4 @@
 import type { IEmbedContentSizeProvider } from '../../types/embed-ui';
+export declare const DEFAULT_SHEET_COLUMN_HEADER_HEIGHT = 24;
 export declare function createSheetsContentSizeProvider(): IEmbedContentSizeProvider;
+export declare function resolveSheetsStickyHeaderHeight(childUnit: unknown): number;

package/lib/types/products/sheets/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 createSheetsPassiveViewportProvider(rootInjector: Injector): IEmbedPassiveViewportProvider;
+import type { IEmbedChildContainerContext, IEmbedPassiveViewportProvider } from '../../types/embed-ui';
+export declare function createSheetsPassiveViewportProvider(rootInjector: IEmbedChildContainerContext['injector']): IEmbedPassiveViewportProvider;

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

@@ -1,5 +1,5 @@
+import type { Injector } from '@univerjs/core';
 import { EmbedModelService } from '@univerjs-pro/embed';
-import { type Injector } from '@univerjs/core';
 import { ISheetEmbedRuntimeService } from '@univerjs/sheets-ui';
 import { CanvasFloatDomPreviewService } from '@univerjs/ui';
 import { Subscription } from 'rxjs';

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

@@ -1,7 +1,7 @@
 import type { EmbedDisplayTarget } from '@univerjs-pro/embed';
 import type { SlideModel } from '@univerjs-pro/slides';
+import type { ICommandService } from '@univerjs/core';
 import type { IEmbedChildContainerContext, IEmbedChildViewContribution } from '../../types/embed-ui';
-import { type ICommandService } from '@univerjs/core';
 export declare function createSlidesEmbedChildViewContribution(commandService: ICommandService): IEmbedChildViewContribution;
 export declare function applySlideDisplayTarget(slide: SlideModel, target: EmbedDisplayTarget | undefined): void;
 export declare function shouldUseSlideEmbedFloatingPreview(context: Pick<IEmbedChildContainerContext, 'layout' | 'renderScope'>): boolean;

package/lib/types/products/slides/embed-floating-menu-stage.d.ts

@@ -1,8 +1,8 @@
-import type { IEmbedFloatingActivation } from '../../types/embed-ui';
+import type { EmbedFloatingStage, IEmbedFloatingActivation } from '../../types/embed-ui';
 export declare function resolveSlidesFloatingMenuStage(params: {
     embedId: string;
     active: IEmbedFloatingActivation | null;
     fullscreen?: boolean;
     usesDomFloatingStage?: boolean;
     renderScopeActive?: boolean;
-}): 'inactive' | 'stage2';
+}): EmbedFloatingStage;

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

@@ -1,7 +1,9 @@
 import type { Injector } from '@univerjs/core';
 import { EmbedModelService } from '@univerjs-pro/embed';
 import { ISlideEmbedRuntimeService } from '@univerjs-pro/slides-ui';
+import { IUniverInstanceService } from '@univerjs/core';
 import { EmbedActivationService } from '../../services/embed-activation.service';
+import { EmbedBlockRegistryService } from '../../services/embed-block-registry.service';
 import { EmbedFloatPreviewService } from '../../services/embed-float-preview.service';
 import { EmbedHostRestoreService } from '../../services/embed-host-restore.service';
 import { EmbedMountService } from '../../services/embed-mount.service';
@@ -14,11 +16,13 @@ interface ISlidesEmbedRuntimeServiceDependencies {
     embedModelService: EmbedModelService;
     mountService: EmbedMountService;
     activationService: EmbedActivationService;
+    blockRegistry: EmbedBlockRegistryService;
     restoreService: EmbedHostRestoreService;
     previewService: EmbedFloatPreviewService;
     runtimeHostLeaseService: EmbedRuntimeHostLeaseService;
     passiveViewportRegistry: EmbedPassiveViewportRegistryService;
     passiveWheelHandlerRegistry: EmbedPassiveWheelHandlerRegistryService;
+    univerInstanceService?: IUniverInstanceService;
     sceneCanvasCaptureService: EmbedSceneCanvasCaptureService | undefined;
 }
 export declare function createSlidesEmbedRuntimeService(params: ISlidesEmbedRuntimeServiceDependencies): ISlideEmbedRuntimeService;

package/lib/types/products/slides/services/embed-slide-presentation-preview.d.ts

@@ -1,4 +1,7 @@
+import type { EmbedModelService, IEmbedDescriptor } from '@univerjs-pro/embed';
 import type { ISlideEmbedPresentationMountParams } from '@univerjs-pro/slides-ui';
+import type { EmbedActivationService } from '../../../services/embed-activation.service';
+import type { EmbedBlockRegistryService } from '../../../services/embed-block-registry.service';
 import type { EmbedFloatPreviewService } from '../../../services/embed-float-preview.service';
 import type { EmbedHostRestoreService } from '../../../services/embed-host-restore.service';
 import type { EmbedPassiveViewportRegistryService } from '../../../services/embed-passive-viewport-registry.service';
@@ -6,8 +9,10 @@ import type { EmbedPassiveWheelHandlerRegistryService } from '../../../services/
 import type { EmbedRuntimeHostLeaseService } from '../../../services/embed-runtime-host-lease.service';
 import type { EmbedSceneCanvasCaptureService } from '../../../services/embed-scene-canvas-capture.service';
 import type { EmbedFloatPreviewRenderResult } from '../../../types/embed-ui';
-type EmbedModelService = import('@univerjs-pro/embed').EmbedModelService;
+import { UniverInstanceType } from '@univerjs/core';
 export interface ISlidePresentationEmbedDependencies {
+    activationService: EmbedActivationService;
+    blockRegistry: EmbedBlockRegistryService;
     embedModelService: EmbedModelService;
     restoreService: EmbedHostRestoreService;
     previewService: EmbedFloatPreviewService;
@@ -23,5 +28,12 @@ export interface ISlidePresentationEmbedDependencies {
  * Static preview rendering remains only as a runtime-unavailable fallback.
  */
 export declare function mountSlidesPresentationEmbed(dependencies: ISlidePresentationEmbedDependencies, mountParams: ISlideEmbedPresentationMountParams): import("@wendellhu/redi").IDisposable;
+export declare function createSlidesPresentationPreviewDescriptor(params: {
+    hostUnitId: string;
+    embedId: string;
+    hostAnchorId: string;
+    childUnitId?: string;
+    childType?: UniverInstanceType;
+    entry: 'slides-floating-object' | 'slides-page-list-block';
+}): IEmbedDescriptor | undefined;
 export declare function normalizePresentationPreviewResult(result: EmbedFloatPreviewRenderResult): string | undefined;
-export {};

package/lib/types/services/embed-activation.service.d.ts

@@ -26,6 +26,7 @@ export declare class EmbedActivationService extends Disposable {
     activateFloating(descriptor: IEmbedDescriptor, stage?: 'stage1' | 'stage2', _options?: IEmbedFloatingActivationOptions): void;
     focusFloatingRuntime(descriptor: IEmbedDescriptor, options?: IEmbedFloatingActivationOptions): void;
     activateFullscreen(descriptor: IEmbedDescriptor): void;
+    focusHostForPassiveRuntime(descriptor: IEmbedDescriptor): void;
     clearFullscreen(descriptor: IEmbedDescriptor): void;
     clearFloating(embedId?: string, hostUnitId?: string): void;
     clearTab(embedId?: string): void;

package/lib/types/services/embed-child-runtime-scope.d.ts

@@ -1,7 +1,7 @@
-import type { IDisposable } from '@univerjs/core';
+import type { Dependency, IDisposable } from '@univerjs/core';
 import type { IEmbedChildContainerContext, IEmbedChildRuntimeScope } from '../types/embed-ui';
 export type EmbedChildRuntimeScopeCreateContext = Omit<IEmbedChildContainerContext, 'runtimeScope'>;
-export declare function createEmbedChildRuntimeScope(context: EmbedChildRuntimeScopeCreateContext, setActive: (active: boolean) => void): {
+export declare function createEmbedChildRuntimeScope(context: EmbedChildRuntimeScopeCreateContext, setActive: (active: boolean) => void, scopedDependencies?: readonly Dependency[]): {
     runtimeScope: IEmbedChildRuntimeScope;
     disposable: IDisposable;
 };

package/lib/types/services/embed-child-unit-scoped-injector.d.ts

@@ -1,6 +1,9 @@
+import type { Dependency } from '@univerjs/core';
 import type { IEmbedChildContainerContext } from '../types/embed-ui';
 import { Injector } from '@univerjs/core';
 export type IEmbedScopedConfigOverrides = ReadonlyMap<string | symbol, (config: unknown) => unknown>;
-export declare function createEmbedChildUnitScopedInjector(context: IEmbedChildContainerContext): Injector | undefined;
+type EmbedChildContainerSetupContext = Omit<IEmbedChildContainerContext, 'runtimeScope'>;
+export declare function createEmbedChildUnitScopedInjector(context: EmbedChildContainerSetupContext, scopedDependencies?: readonly Dependency[]): Injector | undefined;
 export declare function createEmbedScopedConfigInjector(parentInjector: Injector, configOverrides: IEmbedScopedConfigOverrides): Injector | undefined;
 export declare function createEmbedScopedInjector(parentInjector: Injector, overrides: ReadonlyMap<unknown, unknown>, sharedRootInjector?: Injector): Injector;
+export {};

package/lib/types/services/embed-content-size-registry.service.d.ts

@@ -1,9 +1,17 @@
 import type { IDisposable, UniverInstanceType } from '@univerjs/core';
 import type { IEmbedContentSize, IEmbedContentSizeMeasureContext, IEmbedContentSizeProvider } from '../types/embed-ui';
-export declare class EmbedContentSizeRegistryService {
+import { Disposable } from '@univerjs/core';
+export declare class EmbedContentSizeRegistryService extends Disposable {
     private readonly _providers;
+    private readonly _contentSizeChanged$;
+    readonly contentSizeChanged$: import("rxjs").Observable<{
+        embedId: string;
+        hostUnitId: string;
+    }>;
     register(provider: IEmbedContentSizeProvider): IDisposable;
     get(childType: UniverInstanceType): IEmbedContentSizeProvider | undefined;
     list(): IEmbedContentSizeProvider[];
     measureContentSize(context: IEmbedContentSizeMeasureContext): IEmbedContentSize | undefined;
+    notifyContentSizeChanged(hostUnitId: string, embedId: string): void;
+    dispose(): void;
 }

package/lib/types/services/embed-display-target-sync.d.ts

@@ -1,6 +1,4 @@
+import type { EmbedDisplayTarget } from '@univerjs-pro/embed';
+import type { ICommandService, IDisposable } from '@univerjs/core';
 import type { IEmbedChildContainerContext } from '../types/embed-ui';
-import { type EmbedDisplayTarget } from '@univerjs-pro/embed';
-import { type ICommandService, type IDisposable } from '@univerjs/core';
-type ApplyEmbedDisplayTarget = (target: EmbedDisplayTarget | undefined) => void;
-export declare function registerEmbedDisplayTargetSync(context: Pick<IEmbedChildContainerContext, 'descriptor' | 'embedId' | 'hostUnitId'>, commandService: ICommandService, applyTarget: ApplyEmbedDisplayTarget): IDisposable;
-export {};
+export declare function registerEmbedDisplayTargetSync(context: Pick<IEmbedChildContainerContext, 'descriptor' | 'embedId' | 'hostUnitId'>, commandService: ICommandService, applyTarget: (target: EmbedDisplayTarget | undefined) => void): IDisposable;

package/lib/types/services/embed-dom-wheel.d.ts

@@ -0,0 +1,40 @@
+import type { IDisposable } from '@univerjs/core';
+import type { IEmbedChildContainerContext } from '../types/embed-ui';
+import type { EmbedHostWheelGestureService } from './embed-host-wheel-gesture.service';
+import type { EmbedPassiveViewportRegistryService } from './embed-passive-viewport-registry.service';
+import type { EmbedPassiveWheelHandlerRegistryService } from './embed-passive-wheel-handler-registry.service';
+export declare function registerEmbedDomWheelRouting(options: {
+    container: HTMLElement;
+    gate: HTMLElement;
+    getChildContext: () => IEmbedChildContainerContext | undefined;
+    getStage: () => 'inactive' | 'stage1' | 'stage2';
+    hostScrollOffset: {
+        current: number;
+    };
+    hostWheelGestureService: EmbedHostWheelGestureService;
+    invalidate: (reason: 'child-scroll' | 'host-scroll' | 'wheel') => void;
+    liveRoot: HTMLElement;
+    onHostWheel?: (event: WheelEvent, context: IEmbedChildContainerContext) => boolean | void;
+    passiveViewportRegistry: EmbedPassiveViewportRegistryService;
+    passiveWheelHandlerRegistry: EmbedPassiveWheelHandlerRegistryService;
+    resizeDocsSheetLikeRendererByWheel?: (event: WheelEvent) => boolean;
+    routeHostGestures: boolean;
+    syncHostVerticalScroll?: boolean;
+    viewScale?: number;
+}): IDisposable;
+export declare function createEmbedWheelEventForViewScale(event: WheelEvent, viewScale: number | undefined): WheelEvent;
+export declare function createForwardedEmbedWheelEvent(source: WheelEvent, init: WheelEventInit): WheelEvent;
+export declare function isEmbedForwardedWheelEvent(event: Event | undefined): boolean;
+export declare function markHostVerticalWheelAttempted(event: WheelEvent): void;
+export declare function isHostVerticalWheelAttempted(event: WheelEvent): boolean;
+export declare function forwardWheelToEmbedRuntime(event: WheelEvent, liveRoot: HTMLElement): boolean;
+export declare function scrollEmbedRuntimeDom(event: WheelEvent, liveRoot: HTMLElement): boolean;
+export declare function scrollEmbedRuntimeDomElement(event: WheelEvent, element: HTMLElement): boolean;
+export declare function scrollHostScrollPortByWheel(container: HTMLElement, event: WheelEvent): boolean;
+export declare function findNearestEmbedScrollPort(element: HTMLElement): HTMLElement | null;
+export declare function clipsEmbedOverflow(element: HTMLElement): boolean;
+export declare function shouldPassVerticalWheelToHost(context: IEmbedChildContainerContext, event: WheelEvent, syncHostVerticalScroll?: boolean): boolean;
+export declare function shouldUseRuntimeDomHorizontalScroll(container: HTMLElement, event: WheelEvent): boolean;
+export declare function getHorizontalWheelDelta(event: WheelEvent): number;
+export declare function scrollDocsSheetLikeHorizontalWheel(deltaX: number, resizeRenderer: () => boolean, scrollChild: () => boolean): boolean;
+export declare function shouldRouteUnhandledWheelToHost(event: WheelEvent): boolean;

package/lib/types/services/embed-fullscreen-runtime.d.ts

@@ -0,0 +1,26 @@
+import type { EmbedLayout, IEmbedDescriptor } from '@univerjs-pro/embed';
+import type { IDisposable, Injector } from '@univerjs/core';
+import type { IEmbedChildContainerContext, IEmbedRenderScope } from '../types/embed-ui';
+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;

package/lib/types/services/embed-host-menu-override.service.d.ts

@@ -3,6 +3,7 @@ import type { IEmbedHostMenuOverride } from '../types/embed-ui';
 export interface IEmbedHostMenuOverrideActivateOptions {
     layoutPolicy?: IEmbedLayoutPolicy;
     allowPlaceholder?: boolean;
+    allowHiddenRibbon?: boolean;
     portalContainer?: HTMLElement | null;
 }
 export declare class EmbedHostMenuOverrideService {

package/lib/types/services/embed-interaction-boundary.service.d.ts

@@ -4,10 +4,11 @@ export declare function getEmbedInteractionBoundaryOwnerId(element: HTMLElement
 export declare function isEventTargetInSameEmbedInteractionBoundary(scopeElement: HTMLElement | null | undefined, target: EventTarget | null | undefined): boolean;
 export declare class EmbedInteractionBoundaryService {
     private readonly _roots;
+    private readonly _childUnitIds;
     private readonly _portalObservers;
     private readonly _activePortalOwners;
     private _pendingPortalOwner;
-    registerRoot(embedId: string, root: HTMLElement): IDisposable;
+    registerRoot(embedId: string, root: HTMLElement, childUnitId?: string): IDisposable;
     private _registerRootPopupDescendantFocusRoles;
     registerOwnedElement(embedId: string, element: HTMLElement): IDisposable;
     contains(embedId: string | undefined, target: EventTarget | null | undefined, event?: Event): boolean;

package/lib/types/services/embed-mount.service.d.ts

@@ -2,6 +2,7 @@ import type { IEmbedDescriptor } from '@univerjs-pro/embed';
 import type { IEmbedHostMountResult, IEmbedMountSession } from '../types/embed-ui';
 import { Injector, IUniverInstanceService } from '@univerjs/core';
 import { EmbedChildViewRegistryService } from './embed-child-view-registry.service';
+import { EmbedFloatingActiveService } from './embed-floating-active.service';
 import { EmbedHostContainerRegistryService } from './embed-host-container-registry.service';
 import { EmbedOverlayRootService } from './embed-overlay-root.service';
 import { EmbedRuntimePolicyService } from './embed-runtime-policy.service';
@@ -19,11 +20,13 @@ export declare class EmbedMountService {
     private readonly _overlayRootService;
     private readonly _sceneCanvasCaptureService;
     private readonly _univerInstanceService;
+    private readonly _floatingActiveService;
     private readonly _runtimePolicyService;
     private readonly _injector;
     private readonly _sessions;
     private readonly _tabFocusLeases;
-    constructor(_hostContainerRegistry: EmbedHostContainerRegistryService, _childViewRegistry: EmbedChildViewRegistryService, _overlayRootService: EmbedOverlayRootService, _sceneCanvasCaptureService: EmbedSceneCanvasCaptureService, _univerInstanceService: IUniverInstanceService, _runtimePolicyService: EmbedRuntimePolicyService, _injector: Injector);
+    private readonly _tabHostRenderLeases;
+    constructor(_hostContainerRegistry: EmbedHostContainerRegistryService, _childViewRegistry: EmbedChildViewRegistryService, _overlayRootService: EmbedOverlayRootService, _sceneCanvasCaptureService: EmbedSceneCanvasCaptureService, _univerInstanceService: IUniverInstanceService, _floatingActiveService: EmbedFloatingActiveService, _runtimePolicyService: EmbedRuntimePolicyService, _injector: Injector);
     mount(descriptor: IEmbedDescriptor): IEmbedMountSession;
     mountIntoHostElement(descriptor: IEmbedDescriptor, hostElement: HTMLElement, runtimeRoots?: IEmbedHostMountResult['runtimeRoots']): IEmbedMountSession;
     private _mountResolvedHost;
@@ -33,10 +36,13 @@ export declare class EmbedMountService {
     getSession(embedId: string): IEmbedMountSession | undefined;
     listSessions(): IEmbedMountSession[];
     activateSession(embedId: string): void;
+    releaseSessionFocus(embedId: string): boolean;
     deactivateTabSessions(embedId?: string): IEmbedMountSession[];
     deactivateFloatingSession(embedId: string): IEmbedMountSession | undefined;
     setActive(embedId: string, active: boolean): void;
     private _runChildBeforeDeactivate;
+    private _suspendTabPeerHostRender;
+    private _releaseTabPeerHostRenderLease;
     private _resolveLayout;
     private _createRenderScope;
     private _registerRuntimeBoundary;
@@ -44,6 +50,7 @@ export declare class EmbedMountService {
     private _mountFloatingMenu;
     private _registerChildFocusBridge;
     private _focusTabPeerSession;
+    private _refreshTabPeerRender;
     private _activateTabPeerFocusLease;
     private _releaseTabPeerFocusLeasesForHost;
     private _releaseTabPeerFocusLease;

package/lib/types/services/embed-presentation-policy.d.ts

@@ -0,0 +1 @@
+export declare function findEmbedPresentationElementAtPoint(root: HTMLElement, selector: string, clientX: number, clientY: number): HTMLElement | undefined;

package/lib/types/services/embed-render-canvas-preview-provider.d.ts

@@ -1,8 +1,9 @@
 import type { DependencyIdentifier, Injector, UniverInstanceType } from '@univerjs/core';
-import type { IRenderManagerService } from '@univerjs/engine-render';
-import type { IEmbedFloatPreviewProvider } from '../types/embed-ui';
+import type { IEmbedChildContainerContext, IEmbedFloatPreviewProvider } from '../types/embed-ui';
+import { IRenderManagerService } from '@univerjs/engine-render';
 export interface ICreateEmbedRenderCanvasPreviewProviderOptions {
     childType: UniverInstanceType;
     renderManagerService: DependencyIdentifier<IRenderManagerService>;
 }
 export declare function createEmbedRenderCanvasPreviewProvider(injector: Injector, options: ICreateEmbedRenderCanvasPreviewProviderOptions): IEmbedFloatPreviewProvider;
+export declare function waitForEmbedContextCanvasPreviewReady(context: IEmbedChildContainerContext): Promise<void>;

package/lib/types/types/embed-ui.d.ts

@@ -1,6 +1,6 @@
 import type { EmbedHostEntry, EmbedLayout, EmbedMenuBehavior, IEmbedDescriptor, IEmbedLayoutPolicies } from '@univerjs-pro/embed';
-import type { DependencyIdentifier, ICommandService, IDisposable, Injector, IUniverInstanceService, UniverInstanceType } from '@univerjs/core';
-import type { IMenuManagerService, IRibbonService } from '@univerjs/ui';
+import type { Dependency, DependencyIdentifier, ICommandService, IDisposable, Injector, IUniverInstanceService, UniverInstanceType } from '@univerjs/core';
+import type { IMenuManagerService, IRibbonService, RibbonType } from '@univerjs/ui';
 import type { Observable } from 'rxjs';
 export interface IEmbedContainerContext {
     descriptor: IEmbedDescriptor;
@@ -92,6 +92,7 @@ export interface IEmbedHostContainerContribution {
 export interface IEmbedChildViewContribution {
     childType: UniverInstanceType;
     supportedLayouts: EmbedLayout[];
+    scopedDependencies?: readonly Dependency[];
     canvasRootClassName?: string;
     beforeDeactivate?: (context: IEmbedChildContainerContext) => void;
     mount?: (context: IEmbedChildContainerContext) => IDisposable | void;
@@ -113,12 +114,13 @@ export interface IEmbedProductMenuMountContext {
     surface?: EmbedProductMenuSurface;
     childUnitId?: string;
     embedId?: string;
-    injector: unknown;
+    injector: Injector;
     menuSchema: unknown;
     menuTitlePrefix?: string;
     activeRibbonTab?: string;
     headerMenu?: boolean;
     toolbarOnly?: boolean;
+    ribbonType?: RibbonType;
     ribbonHeaderClassName?: string;
     scopedActionServiceTokens?: readonly DependencyIdentifier<unknown>[];
 }
@@ -139,12 +141,26 @@ export interface IEmbedProductRibbonOverrideContext {
     hostUnitId: string;
     entry: EmbedHostEntry;
 }
+export interface IEmbedPresentationPolicyContext {
+    childContext: IEmbedChildContainerContext;
+    entry: EmbedHostEntry;
+    runtimeHost: HTMLElement;
+}
+export interface IEmbedPresentationNavigationContext extends IEmbedPresentationPolicyContext {
+    clientX: number;
+    clientY: number;
+}
+export interface IEmbedPresentationPolicyContribution {
+    getChromeCss?: (context: IEmbedPresentationPolicyContext) => string | undefined;
+    activateNavigationAtPoint?: (context: IEmbedPresentationNavigationContext) => boolean;
+}
 export interface IEmbedBlockContribution {
     childType: UniverInstanceType;
     productName: string;
     hostChromeMode?: EmbedHostChromeMode;
     hostHeaderMode?: 'none' | 'placeholder';
     layoutPolicy?: IEmbedLayoutPolicies;
+    presentationPolicy?: IEmbedPresentationPolicyContribution;
     createRibbonOverride?: (context: IEmbedProductRibbonOverrideContext) => IEmbedProductRibbonOverride | undefined;
 }
 export declare enum EmbedHostChromeMode {
@@ -179,7 +195,9 @@ export interface IEmbedPassiveViewportWheelContext extends IEmbedChildContainerC
 export interface IEmbedPassiveViewportProvider {
     childType: UniverInstanceType;
     supportedLayouts?: EmbedLayout[];
+    getStickyHeaderHeight?: (context: IEmbedChildContainerContext) => number | undefined;
     handleWheel: (context: IEmbedPassiveViewportWheelContext) => boolean | void;
+    subscribeVerticalScroll?: (context: IEmbedChildContainerContext, listener: (viewportScrollY: number) => void) => IDisposable | void;
 }
 export interface IEmbedPassiveWheelHandlerContribution {
     childType: UniverInstanceType;
@@ -195,6 +213,8 @@ export interface IEmbedContentSizeMeasureContext {
     childType: UniverInstanceType;
     childUnit?: unknown;
     childUnitId: string;
+    injector?: Injector;
+    viewportHeight?: number;
     viewportWidth?: number;
 }
 export interface IEmbedContentSizeProvider {