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

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-host-wheel-gesture.service.d.ts

@@ -2,7 +2,7 @@ import type { IDisposable } from '@univerjs/core';
 export declare class EmbedHostWheelGestureService {
     private readonly _sessions;
     private readonly _hostGestureEvents;
-    register(root: HTMLElement): IDisposable;
+    register(root: HTMLElement, container: HTMLElement): IDisposable;
     isHostGesture(event: WheelEvent): boolean;
     private _observeWheel;
 }

package/lib/types/services/embed-host-zoom-wheel.d.ts

@@ -0,0 +1,7 @@
+import type { ICommandService, IUniverInstanceService } from '@univerjs/core';
+import type { IEmbedChildContainerContext } from '../types/embed-ui';
+export interface IEmbedHostZoomWheelDependencies {
+    commandService: ICommandService;
+    univerInstanceService: IUniverInstanceService;
+}
+export declare function routeEmbedHostZoomWheel(event: WheelEvent, context: IEmbedChildContainerContext, dependencies: IEmbedHostZoomWheelDependencies): boolean;

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

@@ -4,17 +4,21 @@ 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 _closedPortalInputGuards;
     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;
     hasRecentInteraction(ownerDocument?: Document): boolean;
     hasRecentInteractionFor(embedId: string | undefined, ownerDocument?: Document): boolean;
     closeOwnedFloatingSurfaces(embedId: string | undefined, ownerDocument: Document | undefined): void;
-    activatePortalScope(embedId: string, ownerDocument: Document | undefined): IDisposable;
+    activatePortalScope(embedId: string, ownerDocument: Document | undefined, options?: {
+        includeAppShellEditorPortal?: boolean;
+    }): IDisposable;
     private _collectOwnedFloatingSurfaceRoots;
     private _resolveFloatingSurfaceRoot;
     private _dispatchEscapeToFloatingSurface;
@@ -29,6 +33,8 @@ export declare class EmbedInteractionBoundaryService {
     private _isUniverPortalCandidate;
     private _isDetachedOffscreenPortalCandidate;
     private _markRuntimeFocusRole;
+    private _syncClosedPortalInputGuard;
+    private _clearClosedPortalInputGuard;
     private _markInteractionBoundaryOwnerTree;
     private _isUniverPortalTreeElement;
     private _getBodyPortalOwner;

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-print.service.d.ts

@@ -0,0 +1,55 @@
+import type { IPrintPreparationContext, IPrintPreparationContribution } from '@univerjs-pro/print';
+import { EmbedHostAdapterRegistryService, EmbedHostAnchorModelService, EmbedModelService } from '@univerjs-pro/embed';
+import { Disposable, ICommandService, IImageIoService, IUniverInstanceService, ThemeService } from '@univerjs/core';
+import { EmbedContentSizeRegistryService } from './embed-content-size-registry.service';
+import { EmbedFloatPreviewService } from './embed-float-preview.service';
+import { EmbedHostRestoreService } from './embed-host-restore.service';
+import { EmbedMountService } from './embed-mount.service';
+import { EmbedPassiveViewportRegistryService } from './embed-passive-viewport-registry.service';
+export interface IEmbedPrintResource {
+    canvas?: HTMLCanvasElement;
+    height: number;
+    source?: string;
+    verticalBreaks?: readonly number[];
+    width: number;
+}
+export declare class EmbedPrintService extends Disposable implements IPrintPreparationContribution {
+    private readonly _embedModelService;
+    private readonly _anchorModelService;
+    private readonly _hostAdapterRegistry;
+    private readonly _restoreService;
+    private readonly _previewService;
+    private readonly _mountService;
+    private readonly _contentSizeRegistry;
+    private readonly _passiveViewportRegistry;
+    private readonly _commandService;
+    private readonly _univerInstanceService;
+    private readonly _themeService;
+    private readonly _imageIoService;
+    private readonly _resources;
+    constructor(_embedModelService: EmbedModelService, _anchorModelService: EmbedHostAnchorModelService, _hostAdapterRegistry: EmbedHostAdapterRegistryService, _restoreService: EmbedHostRestoreService, _previewService: EmbedFloatPreviewService, _mountService: EmbedMountService, _contentSizeRegistry: EmbedContentSizeRegistryService, _passiveViewportRegistry: EmbedPassiveViewportRegistryService, _commandService: ICommandService, _univerInstanceService: IUniverInstanceService, _themeService: ThemeService, _imageIoService: IImageIoService);
+    prepare(context: IPrintPreparationContext): Promise<void>;
+    getImage(hostUnitId: string, embedId: string): string | undefined;
+    getResource(hostUnitId: string, embedId: string): IEmbedPrintResource | undefined;
+    private _activateSheetTabForPrint;
+    private _activateSlidePageForPrint;
+    private _prepareDescriptor;
+    private _captureMountedCanvas;
+    private _renderMountedScene;
+    private _renderCompleteScene;
+    private _resolveCompleteCaptureOptions;
+    private _measureContentSize;
+    private _resolveViewState;
+    private _resolveSize;
+    private _resolveTabViewportSize;
+    private _toDataUrl;
+    private _preloadImage;
+    private _clearHost;
+    private _getKey;
+    dispose(): void;
+}
+export declare function resolveCaptureFrameSlice(scroll: number, viewportSize: number, contentSize: number): {
+    size: number;
+    sourceOffset: number;
+    target: number;
+};

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, renderCurrentFrame?: boolean): Promise<void>;

package/lib/types/services/embed-render-child-view-contribution.d.ts

@@ -1,8 +1,9 @@
 import type { EmbedLayout } from '@univerjs-pro/embed';
-import type { DependencyIdentifier, IDisposable, UniverInstanceType } from '@univerjs/core';
+import type { DependencyIdentifier, IDisposable } from '@univerjs/core';
 import type { IRenderManagerService } from '@univerjs/engine-render';
+import type { Observable } from 'rxjs';
 import type { IEmbedChildContainerContext, IEmbedChildViewContribution } from '../types/embed-ui';
-import { Injector } from '@univerjs/core';
+import { Injector, UniverInstanceType } from '@univerjs/core';
 export interface IEmbedRenderLike {
     isMainScene?: boolean;
     engine: {
@@ -25,7 +26,9 @@ export interface IEmbedRenderLike {
         makeDirty?: (dirty?: boolean) => void;
     } | null | void;
     scene: {
-        makeDirty: () => void;
+        afterRender$?: Observable<unknown>;
+        makeDirty: (dirty?: boolean) => void;
+        requestRender?: () => Promise<unknown> | unknown;
         render?: () => void;
     };
     with?: <T>(dependency: DependencyIdentifier<T>) => T;
@@ -44,6 +47,7 @@ export declare function createEmbedRenderChildViewContribution(options: ICreateE
 export declare function mountEmbedRenderChildUnit(context: IEmbedChildContainerContext, renderManagerServiceIdentifier: DependencyIdentifier<IRenderManagerService>, target?: HTMLElement, options?: IMountEmbedRenderChildUnitOptions): IDisposable | undefined;
 export declare function observeEmbedRenderTargetResize(render: IEmbedRenderLike, target: HTMLElement, options?: {
     activate?: boolean;
+    idleMs?: number;
 }): IDisposable;
 export declare function ensureEmbedChildRender(renderManagerService: IRenderManagerService, childUnitId: string, renderParentInjector?: Injector): IEmbedRenderLike | undefined;
 export declare function createEmbedChildRender(renderManagerService: IRenderManagerService, childUnitId: string, renderParentInjector?: Injector): IEmbedRenderLike | undefined;

package/lib/types/services/embed-runtime-host-lease.service.d.ts

@@ -8,8 +8,8 @@ export interface IEmbedRuntimeHostLease extends IDisposable {
 }
 /**
  * Temporarily lends a single Embed runtime to another DOM host without creating
- * a duplicate child session. This is a host-lifecycle bridge, not a global
- * interaction policy; consumers remain responsible for their local input rules.
+ * a duplicate child session. Only Embed-owned runtime slots are relocated: the
+ * outer host can belong to React and must remain under its original parent.
  *
  * If passive runtime hosting becomes common outside presentation, promote the
  * capability into EmbedMountService instead of adding more DOM relocation paths.

package/lib/types/services/embed-scene-canvas-capture.service.d.ts

@@ -1,5 +1,6 @@
-import type { IDisposable, UniverInstanceType } from '@univerjs/core';
+import type { IDisposable } from '@univerjs/core';
 import type { IEmbedChildContainerContext } from '../types/embed-ui';
+import { UniverInstanceType } from '@univerjs/core';
 export type EmbedSceneCanvasCaptureResult = string | HTMLCanvasElement | ImageBitmap;
 export interface IEmbedSceneCanvasCaptureProvider {
     childType: UniverInstanceType;
@@ -22,3 +23,30 @@ export declare class EmbedSceneCanvasCaptureService {
     captureByChildUnitId(childUnitId: string): Promise<EmbedSceneCanvasCaptureResult | null | undefined>;
 }
 export declare function captureEmbedContextSceneCanvas(context: IEmbedChildContainerContext): string | undefined;
+interface IEmbedSceneScrollBar {
+    enableHorizontal: boolean;
+    enableVertical: boolean;
+}
+interface IEmbedScrollBarRender {
+    scene?: IEmbedScrollBarScene;
+}
+interface IEmbedScrollBarScene {
+    getViewports?: () => Array<{
+        getScrollBar?: () => IEmbedSceneScrollBar | null | undefined | void;
+    }>;
+    getAllObjects?: () => IEmbedScrollBarSceneObject[];
+    makeDirty?: (force?: boolean) => void;
+    render?: () => void;
+}
+interface IEmbedScrollBarSceneObject {
+    getSubScenes?: () => Map<string, IEmbedScrollBarScene>;
+    hide?: () => void;
+    oKey?: string;
+    show?: () => void;
+    visible?: boolean;
+}
+export declare function getEmbedContextSceneCanvas(context: IEmbedChildContainerContext, allowTainted?: boolean): HTMLCanvasElement | undefined;
+export declare function hideEmbedContextScrollbars(context: IEmbedChildContainerContext): () => void;
+export declare function hideEmbedRenderScrollbars(render: IEmbedScrollBarRender | null | undefined, roots?: readonly HTMLElement[]): () => void;
+export declare function waitForEmbedPrintScrollbarsHidden(childType: UniverInstanceType): Promise<void>;
+export {};

package/lib/types/services/embed-ui-runtime-scope-lease.service.d.ts

@@ -0,0 +1,16 @@
+import type { IDisposable } from '@univerjs/core';
+import type { IUIRuntimeScope } from '@univerjs/ui';
+import { Disposable } from '@univerjs/core';
+import { IUIRuntimeScopeService } from '@univerjs/ui';
+/**
+ * Keeps nested Embed render scopes behind one stable UI runtime registration.
+ * The global UI service therefore retains its single-owner behavior while
+ * fullscreen scopes can temporarily take over and restore their parent scope.
+ */
+export declare class EmbedUIRuntimeScopeLeaseService extends Disposable {
+    private readonly _runtimeScopeService;
+    private readonly _entries;
+    constructor(_runtimeScopeService: IUIRuntimeScopeService);
+    acquire(scope: IUIRuntimeScope): IDisposable;
+    dispose(): 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 {
@@ -172,14 +188,18 @@ export interface IEmbedFloatingMenuContribution {
 export interface IEmbedPassiveViewportWheelContext extends IEmbedChildContainerContext {
     event: WheelEvent;
     stage: EmbedFloatingStage;
-    source?: 'wheel' | 'host-scroll-sync';
+    source?: 'wheel' | 'host-scroll-sync' | 'print-capture';
     viewportScrollX?: number;
     viewportScrollY?: number;
 }
 export interface IEmbedPassiveViewportProvider {
     childType: UniverInstanceType;
     supportedLayouts?: EmbedLayout[];
+    getHorizontalScroll?: (context: IEmbedChildContainerContext) => number | undefined;
+    getVerticalScroll?: (context: IEmbedChildContainerContext) => number | undefined;
+    getStickyLeftWidth?: (context: IEmbedChildContainerContext) => number | undefined;
     getStickyHeaderHeight?: (context: IEmbedChildContainerContext) => number | undefined;
+    getStickyFooterHeight?: (context: IEmbedChildContainerContext) => number | undefined;
     handleWheel: (context: IEmbedPassiveViewportWheelContext) => boolean | void;
     subscribeVerticalScroll?: (context: IEmbedChildContainerContext, listener: (viewportScrollY: number) => void) => IDisposable | void;
 }
@@ -192,11 +212,15 @@ export interface IEmbedPassiveWheelHandlerContribution {
 export interface IEmbedContentSize {
     height?: number;
     width?: number;
+    verticalBreaks?: readonly number[];
 }
 export interface IEmbedContentSizeMeasureContext {
     childType: UniverInstanceType;
     childUnit?: unknown;
     childUnitId: string;
+    injector?: Injector;
+    limitRowsToViewportWidth?: boolean;
+    viewportHeight?: number;
     viewportWidth?: number;
 }
 export interface IEmbedContentSizeProvider {
@@ -233,7 +257,7 @@ export interface IEmbedMountSession {
     context?: IEmbedChildContainerContext;
 }
 export type EmbedFloatPreviewStatus = 'pending' | 'ready' | 'error' | 'stale';
-export type EmbedFloatPreviewReason = 'initial' | 'stage-exit' | 'resize' | 'content-change' | 'manual';
+export type EmbedFloatPreviewReason = 'initial' | 'stage-exit' | 'resize' | 'content-change' | 'manual' | 'print';
 export type EmbedFloatPreviewInvalidationReason = 'model-change' | 'view-state-change' | 'resize' | 'theme-change' | 'locale-change' | 'dispose';
 export type EmbedFloatPreviewRenderResult = string | HTMLCanvasElement | ImageBitmap;
 export interface IEmbedFloatPreviewEntry<TViewState = unknown> {