@univerjs-pro/embed-ui 1.0.0-alpha.3

package/lib/types/locale/ru-RU.d.ts

@@ -0,0 +1,3 @@
+import type enUS from './en-US';
+declare const locale: typeof enUS;
+export default locale;

package/lib/types/locale/sk-SK.d.ts

@@ -0,0 +1,3 @@
+import type enUS from './en-US';
+declare const locale: typeof enUS;
+export default locale;

package/lib/types/locale/types.d.ts

@@ -0,0 +1,3 @@
+import type { LocaleLeafKeys } from '@univerjs/core';
+import type enUS from './en-US';
+export type LocaleKey = LocaleLeafKeys<typeof enUS>;

package/lib/types/locale/vi-VN.d.ts

@@ -0,0 +1,3 @@
+import type enUS from './en-US';
+declare const locale: typeof enUS;
+export default locale;

package/lib/types/locale/zh-CN.d.ts

@@ -0,0 +1,3 @@
+import type enUS from './en-US';
+declare const locale: typeof enUS;
+export default locale;

package/lib/types/locale/zh-HK.d.ts

@@ -0,0 +1,3 @@
+import type enUS from './en-US';
+declare const locale: typeof enUS;
+export default locale;

package/lib/types/locale/zh-TW.d.ts

@@ -0,0 +1,3 @@
+import type enUS from './en-US';
+declare const locale: typeof enUS;
+export default locale;

package/lib/types/plugin.d.ts

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

package/lib/types/product-menus/docs-product-menus.d.ts

@@ -0,0 +1,2 @@
+import type { IDisposable, Injector } from '@univerjs/core';
+export declare function registerDefaultEmbedProductMenus(injector: Injector): IDisposable[];

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

@@ -0,0 +1,13 @@
+import type { IUniverBaseUIConfig } from '@univerjs-pro/bases-ui';
+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';
+export type BaseEmbedChromeMode = 'workbench' | 'content-only' | 'fullscreen';
+export declare function createBasesEmbedChildViewContribution(): 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 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

@@ -0,0 +1,36 @@
+import type { IBaseToolbarState } from '@univerjs-pro/bases-ui';
+import type { BaseDataModel, 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[];
+export declare function resolveBasesFloatingMenuStage(params: {
+    embedId: string;
+    activeEmbedId: string | null | undefined;
+    stage: string | null | undefined;
+    fullscreen?: boolean;
+    usesDomFloatingStage: boolean;
+    renderScopeActive: boolean;
+}): 'inactive' | 'stage2';
+export declare function resolveBasesFloatingMenuClassName(params: {
+    entry: string;
+    fullscreen: boolean;
+    stage: 'inactive' | 'stage2';
+}): string;
+export declare function shouldUseBaseFullscreenToolbar(fullscreen: boolean): boolean;
+export declare function shouldUseBaseFullscreenViewTabs(fullscreen: boolean): boolean;
+export declare function shouldShowBaseEmbedRemoveButton(fullscreen: boolean): boolean;
+export declare function createBaseEmbedFloatingMenuBoundaryAttributes(embedId: string): Record<string, string>;
+export declare function createBaseFloatingToolbarState(view: IViewSnapshot, undoRedoStatus?: {
+    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;
+    maxHeight: number;
+};

package/lib/types/products/bases/embed-block.d.ts

@@ -0,0 +1,2 @@
+import type { IEmbedBlockContribution } from '../../types/embed-ui';
+export declare function createBasesEmbedBlockContribution(): IEmbedBlockContribution;

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

@@ -0,0 +1,9 @@
+import type { IEmbedContentSizeProvider } from '../../types/embed-ui';
+interface IBaseContentSizeActiveState {
+    activeTableId?: string;
+    activeViewId?: string;
+}
+export declare function createBasesContentSizeProvider(baseUIStateService?: {
+    getState?: () => IBaseContentSizeActiveState | undefined;
+}): IEmbedContentSizeProvider;
+export {};

package/lib/types/products/bases/embed-host-adapter.d.ts

@@ -0,0 +1,6 @@
+import type { IBaseUIStateService } from '@univerjs-pro/bases-ui';
+import type { EmbedHostAnchorModelService, IEmbedHostAdapterContribution } from '@univerjs-pro/embed';
+import type { IUniverInstanceService } from '@univerjs/core';
+import type { IEmbedHostContainerContribution } from '../../types/embed-ui';
+export declare function createBasesTableListBlockUIHostAdapterContribution(anchorModelService?: EmbedHostAnchorModelService, univerInstanceService?: IUniverInstanceService, baseUIStateService?: IBaseUIStateService | (() => IBaseUIStateService | undefined)): IEmbedHostAdapterContribution;
+export declare function createBasesTableListBlockHostContainerContribution(): IEmbedHostContainerContribution;

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

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

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

@@ -0,0 +1,13 @@
+import type { Injector } from '@univerjs/core';
+import { IBaseEmbedRuntimeService } from '@univerjs-pro/bases-ui';
+import { EmbedModelService } from '@univerjs-pro/embed';
+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 createBasesEmbedRuntimeService(params: {
+    embedModelService: EmbedModelService;
+    restoreService: EmbedHostRestoreService;
+    mountService: EmbedMountService;
+    activationService: EmbedActivationService;
+}): IBaseEmbedRuntimeService;

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

@@ -0,0 +1,38 @@
+import type { IEmbedFloatDomData } from '../../components/EmbedFloatDomRenderer';
+import { IRenderManagerService } from '@univerjs/engine-render';
+export interface IEmbedDocsCustomBlockRuntimeProps {
+    customBlockRenderViewport?: {
+        bleedLeft?: number;
+        bleedWidth?: number;
+        contentHeight?: number;
+        contentWidth?: number;
+        height?: 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;
+    sheetLike: boolean;
+    viewportHeight?: number;
+}): number;
+export declare function resolveDocsCustomBlockRuntimeOuterHeight(params: {
+    contentHeight: number;
+    menuInsetTop: number;
+    sheetLike: boolean;
+}): number;
+export declare function resolveDocsTableLikeCustomBlockRuntimeContentWidth(authoritativeContentWidth: number | undefined, measureFallback: () => number): number;
+export declare function shouldSyncDocsTableLikeCustomBlockBleedOnScroll(root: HTMLElement, target: EventTarget | null): boolean;

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

@@ -0,0 +1,7 @@
+import type { IEmbedFloatingMenuContribution } from '../../types/embed-ui';
+export declare function createDocsFloatingMenuContributions(): IEmbedFloatingMenuContribution[];
+export declare function resolveDocsFloatingMenuClassName(params: {
+    entry: string;
+    fullscreen: boolean;
+    stage: 'inactive' | 'stage2';
+}): string;

package/lib/types/products/docs/embed-block.d.ts

@@ -0,0 +1,3 @@
+import type { IEmbedBlockContribution, IEmbedChildViewContribution } from '../../types/embed-ui';
+export declare function createDocsEmbedBlockContribution(): IEmbedBlockContribution;
+export declare function createDocsEmbedChildViewContribution(): IEmbedChildViewContribution;

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

@@ -0,0 +1,25 @@
+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 { IRenderManagerService } from '@univerjs/engine-render';
+import { EmbedContentSizeRegistryService } from '../../services/embed-content-size-registry.service';
+export declare class EmbedDocsCustomBlockBleedRenderController extends Disposable implements IRenderModule {
+    private readonly _context;
+    private readonly _univerInstanceService;
+    private readonly _commandService;
+    private readonly _contentSizeRegistry?;
+    private readonly _embedModelService?;
+    private readonly _renderManagerService?;
+    private readonly _resolvedChildUnits;
+    private readonly _pendingChildUnits;
+    constructor(_context: IRenderContext<DocumentDataModel>, _univerInstanceService: IUniverInstanceService, _commandService: ICommandService, _contentSizeRegistry?: EmbedContentSizeRegistryService | undefined, _embedModelService?: EmbedModelService | undefined, _renderManagerService?: IRenderManagerService | undefined);
+    private _getHostUnit;
+    private _getHostSnapshot;
+    private _rerenderHostDoc;
+    private _refreshHostDocZoom;
+    private _resolveChildUnitId;
+    private _getChildUnitForMeasurement;
+    private _getDocsLeft;
+    private _getVisibleCanvasDocumentRect;
+}

package/lib/types/products/docs/embed-host-adapter.d.ts

@@ -0,0 +1,6 @@
+import type { EmbedHostAnchorModelService, IEmbedHostAdapterContribution } from '@univerjs-pro/embed';
+import type { IUniverInstanceService } from '@univerjs/core';
+import type { IRenderManagerService } from '@univerjs/engine-render';
+import type { IEmbedHostContainerContribution } from '../../types/embed-ui';
+export declare function createDocsCustomBlockUIHostAdapterContribution(anchorModelService?: EmbedHostAnchorModelService, univerInstanceService?: IUniverInstanceService, renderManagerService?: IRenderManagerService): IEmbedHostAdapterContribution;
+export declare function createDocsCustomBlockHostContainerContribution(): IEmbedHostContainerContribution;

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

@@ -0,0 +1,3 @@
+import type { Injector } from '@univerjs/core';
+import type { IEmbedPassiveViewportProvider } from '../../types/embed-ui';
+export declare function createDocsPassiveViewportProvider(injector: Injector): IEmbedPassiveViewportProvider;

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

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

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

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

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

@@ -0,0 +1,8 @@
+import type { IEmbedBlockContribution, IEmbedChildContainerContext, IEmbedChildViewContribution } from '../../types/embed-ui';
+export declare function createSheetsEmbedBlockContribution(): IEmbedBlockContribution;
+export declare function createSheetsEmbedChildViewContribution(): IEmbedChildViewContribution;
+export declare function shouldShowEmbeddedSheetChrome(context: Pick<IEmbedChildContainerContext, 'renderScope'>): boolean;
+export declare function applyEmbeddedSheetChromeInset(canvasRoot: HTMLElement, chrome: {
+    formulaBar: boolean;
+    sheetBar: boolean;
+}): import("@wendellhu/redi").IDisposable;

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

@@ -0,0 +1,57 @@
+import type { IMenuItem, IMenuSchema, IValueOption } 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';
+type SheetFloatingMenuStage = 'inactive' | 'stage2';
+export type SheetFloatingToolbarItem = {
+    id: string;
+    type: 'button' | 'dropdown';
+} | {
+    id: string;
+    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 resolveSheetsFloatingMenuClassName(params: {
+    entry: string;
+    fullscreen: boolean;
+    stage: SheetFloatingMenuStage;
+}): string;
+export declare function isFloatingDropdownOwnSurfaceTarget(target: EventTarget | null, embedId: string): boolean;
+export declare function keepFloatingDropdownOpenForOwnSurface(event: {
+    target: EventTarget | null;
+    preventDefault: () => void;
+}, embedId: string): void;
+export {};

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

@@ -0,0 +1,2 @@
+import type { IEmbedContentSizeProvider } from '../../types/embed-ui';
+export declare function createSheetsContentSizeProvider(): IEmbedContentSizeProvider;

package/lib/types/products/sheets/embed-host-adapter.d.ts

@@ -0,0 +1,3 @@
+import type { IEmbedHostContainerContribution } from '../../types/embed-ui';
+export declare function createSheetsFloatingObjectHostContainerContribution(): IEmbedHostContainerContribution;
+export declare function createSheetsSheetTabHostContainerContribution(): IEmbedHostContainerContribution;

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

@@ -0,0 +1,3 @@
+import type { Injector } from '@univerjs/core';
+import type { IEmbedPassiveViewportProvider } from '../../types/embed-ui';
+export declare function createSheetsPassiveViewportProvider(rootInjector: Injector): IEmbedPassiveViewportProvider;

package/lib/types/products/sheets/embed-product-menu.d.ts

@@ -0,0 +1,2 @@
+import type { IDisposable, Injector } from '@univerjs/core';
+export declare function registerSheetsEmbedProductMenus(injector: Pick<Injector, 'get' | 'has'>): IDisposable | undefined;

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

@@ -0,0 +1,28 @@
+import type { Injector } from '@univerjs/core';
+import { EmbedModelService } from '@univerjs-pro/embed';
+import { ISheetEmbedRuntimeService } from '@univerjs/sheets-ui';
+import { CanvasFloatDomPreviewService } from '@univerjs/ui';
+import { Subscription } from 'rxjs';
+import { EmbedActivationService } from '../../services/embed-activation.service';
+import { EmbedFloatPreviewService } from '../../services/embed-float-preview.service';
+import { EmbedHostRestoreService } from '../../services/embed-host-restore.service';
+import { EmbedMountService } from '../../services/embed-mount.service';
+export declare function registerSheetsEmbedUIContributions(injector: Injector): void;
+export declare function createSheetsEmbedRuntimeService(params: {
+    embedModelService: EmbedModelService;
+    mountService: EmbedMountService;
+    activationService: EmbedActivationService;
+    restoreService: EmbedHostRestoreService;
+}): ISheetEmbedRuntimeService;
+export declare function wireSheetsFloatPreviewBridge(params: {
+    previewService: EmbedFloatPreviewService;
+    embedModelService: EmbedModelService;
+    canvasFloatDomPreviewService: CanvasFloatDomPreviewService;
+}): Subscription;
+export declare function ensureSheetsFloatPreviewBridge(params: {
+    injector: Pick<Injector, 'get' | 'has'>;
+    previewService: EmbedFloatPreviewService;
+    retry?: boolean;
+    maxRetries?: number;
+    retryDelay?: number;
+}): Subscription | undefined;

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

@@ -0,0 +1,3 @@
+import type { IEmbedChildContainerContext, IEmbedChildViewContribution } from '../../types/embed-ui';
+export declare function createSlidesEmbedChildViewContribution(): IEmbedChildViewContribution;
+export declare function shouldUseSlideEmbedFloatingPreview(context: Pick<IEmbedChildContainerContext, 'layout' | 'renderScope'>): boolean;

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

@@ -0,0 +1,28 @@
+import type { SlideModel } from '@univerjs-pro/slides';
+import type { ICommandService, IUniverInstanceService } from '@univerjs/core';
+import type { Observable } from 'rxjs';
+import type { EmbedFloatingActiveService } from '../../../../services/embed-floating-active.service';
+export interface ISlideEmbedFloatingMenuProps {
+    hostUnitId: string;
+    entry: string;
+    embedId: string;
+    childUnitId: string;
+    slideModel: SlideModel | null;
+    floatingActiveService: EmbedFloatingActiveService;
+    commandService: ICommandService;
+    instanceService: IUniverInstanceService;
+    fullscreen: boolean;
+    usesDomFloatingStage: boolean;
+    renderScopeActive$: Observable<boolean>;
+}
+export declare function createSlideEmbedFloatingMenuClassName(params: {
+    entry: string;
+    fullscreen: boolean;
+    isStage2: boolean;
+}): string;
+export declare function SlideEmbedFloatingMenu(props: ISlideEmbedFloatingMenuProps): import("react").JSX.Element;
+export declare function resolveSlideFloatingMenuClassName(params: {
+    entry: string;
+    fullscreen: boolean;
+    stage: 'inactive' | 'stage2';
+}): string;

package/lib/types/products/slides/components/embed-floating-preview/SlideEmbedFloatingPreview.d.ts

@@ -0,0 +1,24 @@
+import type { IRender } from '@univerjs/engine-render';
+import type { Observable } from 'rxjs';
+export interface ISlideFloatPageFrameSize {
+    width: number;
+    height: number;
+}
+export declare function resolveSlideFloatPageFrameSize(containerSize: {
+    width: number;
+    height: number;
+}, aspectRatio?: number): ISlideFloatPageFrameSize;
+/**
+ * Lightweight slide runtime for embed float blocks.
+ *
+ * Host chrome owns selection, moving, resizing, and menus. This view only owns
+ * the slide page content and the minimum editing overlays needed in stage2.
+ */
+export declare function SlideEmbedFloatingPreview(props?: {
+    unitId?: string;
+    active$?: Observable<boolean>;
+}): import("react").JSX.Element;
+export declare function SlideEmbedReadonlyFloatingPreview(props?: {
+    unitId?: string;
+    render?: IRender;
+}): import("react").JSX.Element;

package/lib/types/products/slides/embed-block.d.ts

@@ -0,0 +1,2 @@
+import type { IEmbedBlockContribution } from '../../types/embed-ui';
+export declare function createSlidesEmbedBlockContribution(): IEmbedBlockContribution;

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

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

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

@@ -0,0 +1,3 @@
+import type { IEmbedFloatingMenuContribution } from '../../types/embed-ui';
+export declare function createSlidesAsSheetFloatingMenuContribution(): IEmbedFloatingMenuContribution;
+export declare function createSlidesFloatingMenuContributions(): IEmbedFloatingMenuContribution[];

package/lib/types/products/slides/embed-host-adapter.d.ts

@@ -0,0 +1,7 @@
+import type { EmbedHostAnchorModelService, IEmbedHostAdapterContribution } from '@univerjs-pro/embed';
+import type { ISlideEmbedRuntimeService } from '@univerjs-pro/slides-ui';
+import type { IUniverInstanceService } from '@univerjs/core';
+import type { IEmbedHostContainerContribution } from '../../types/embed-ui';
+export declare function createSlidesPageListBlockUIHostAdapterContribution(anchorModelService?: EmbedHostAnchorModelService, univerInstanceService?: IUniverInstanceService, embedRuntimeService?: ISlideEmbedRuntimeService): IEmbedHostAdapterContribution;
+export declare function createSlidesFloatingObjectHostContainerContribution(): IEmbedHostContainerContribution;
+export declare function createSlidesPageListBlockHostContainerContribution(): IEmbedHostContainerContribution;

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

@@ -0,0 +1,2 @@
+import type { IEmbedPassiveViewportProvider } from '../../types/embed-ui';
+export declare function createSlidesPassiveViewportProvider(): IEmbedPassiveViewportProvider;

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

@@ -0,0 +1,25 @@
+import type { Injector } from '@univerjs/core';
+import { EmbedModelService } from '@univerjs-pro/embed';
+import { ISlideEmbedRuntimeService } from '@univerjs-pro/slides-ui';
+import { EmbedActivationService } from '../../services/embed-activation.service';
+import { EmbedFloatPreviewService } from '../../services/embed-float-preview.service';
+import { EmbedHostRestoreService } from '../../services/embed-host-restore.service';
+import { EmbedMountService } from '../../services/embed-mount.service';
+import { EmbedPassiveViewportRegistryService } from '../../services/embed-passive-viewport-registry.service';
+import { EmbedPassiveWheelHandlerRegistryService } from '../../services/embed-passive-wheel-handler-registry.service';
+import { EmbedRuntimeHostLeaseService } from '../../services/embed-runtime-host-lease.service';
+import { EmbedSceneCanvasCaptureService } from '../../services/embed-scene-canvas-capture.service';
+export declare function registerSlidesEmbedUIContributions(injector: Injector): void;
+interface ISlidesEmbedRuntimeServiceDependencies {
+    embedModelService: EmbedModelService;
+    mountService: EmbedMountService;
+    activationService: EmbedActivationService;
+    restoreService: EmbedHostRestoreService;
+    previewService: EmbedFloatPreviewService;
+    runtimeHostLeaseService: EmbedRuntimeHostLeaseService;
+    passiveViewportRegistry: EmbedPassiveViewportRegistryService;
+    passiveWheelHandlerRegistry: EmbedPassiveWheelHandlerRegistryService;
+    sceneCanvasCaptureService: EmbedSceneCanvasCaptureService | undefined;
+}
+export declare function createSlidesEmbedRuntimeService(params: ISlidesEmbedRuntimeServiceDependencies): ISlideEmbedRuntimeService;
+export {};

package/lib/types/products/slides/services/EmbedSlideReadonlyPreviewProvider.d.ts

@@ -0,0 +1,15 @@
+import type { IDisposable } from '@univerjs/core';
+import type { IEmbedReadonlyPreviewContext, IEmbedReadonlyPreviewProvider, IEmbedReadonlyPreviewWheelContext } from '../../../types/embed-ui';
+import type { ISlideEmbedFloatViewState } from './embed-slide-float-preview.provider';
+import { IUniverInstanceService, UniverInstanceType } from '@univerjs/core';
+import { IRenderManagerService } from '@univerjs/engine-render';
+export declare class SlideEmbedReadonlyPreviewProvider implements IEmbedReadonlyPreviewProvider<ISlideEmbedFloatViewState> {
+    private readonly _instanceService;
+    private readonly _renderManagerService;
+    readonly childType = UniverInstanceType.UNIVER_SLIDE;
+    readonly supportedLayouts: "aspect-fit"[];
+    constructor(_instanceService: IUniverInstanceService, _renderManagerService: IRenderManagerService);
+    mount(context: IEmbedReadonlyPreviewContext<ISlideEmbedFloatViewState>): IDisposable | undefined;
+    handleWheel(context: IEmbedReadonlyPreviewWheelContext<ISlideEmbedFloatViewState>): boolean;
+    private _getSlideModel;
+}

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

@@ -0,0 +1,34 @@
+import type { EmbedFloatPreviewRenderResult, IEmbedChildContainerContext, IEmbedFloatPreviewProvider, IEmbedFloatPreviewRenderRequest } from '../../../types/embed-ui';
+import { IUniverInstanceService, UniverInstanceType } from '@univerjs/core';
+import { IRenderManagerService } from '@univerjs/engine-render';
+export interface ISlideEmbedFloatViewState {
+    unitId: string;
+    pageId: string;
+    scaleMode: 'fit' | 'custom';
+    zoomRatio?: number;
+}
+export declare class SlideEmbedFloatPreviewProvider implements IEmbedFloatPreviewProvider<ISlideEmbedFloatViewState> {
+    private readonly _instanceService;
+    private readonly _renderManagerService;
+    readonly childType = UniverInstanceType.UNIVER_SLIDE;
+    constructor(_instanceService: IUniverInstanceService, _renderManagerService: IRenderManagerService);
+    collectViewState(context: IEmbedChildContainerContext): ISlideEmbedFloatViewState;
+    restoreViewState(context: IEmbedChildContainerContext, state: ISlideEmbedFloatViewState): void;
+    renderPreview(request: IEmbedFloatPreviewRenderRequest<ISlideEmbedFloatViewState>): EmbedFloatPreviewRenderResult | undefined;
+    private _getSlideModel;
+    private _getOrCreateRender;
+}
+export interface ICenteredAspectCrop {
+    sx: number;
+    sy: number;
+    sWidth: number;
+    sHeight: number;
+}
+export declare function resolveCenteredAspectCrop(sourceWidth: number, sourceHeight: number, aspectRatio: number): ICenteredAspectCrop;
+export interface ISlidePageRectLike {
+    left?: number;
+    top?: number;
+    width?: number;
+    height?: number;
+}
+export declare function resolveSlidePageCanvasCrop(sourceWidth: number, sourceHeight: number, pageRect: ISlidePageRectLike, scaleX: number, scaleY: number): ICenteredAspectCrop | undefined;

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

@@ -0,0 +1,27 @@
+import type { ISlideEmbedPresentationMountParams } from '@univerjs-pro/slides-ui';
+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';
+import type { EmbedPassiveWheelHandlerRegistryService } from '../../../services/embed-passive-wheel-handler-registry.service';
+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;
+export interface ISlidePresentationEmbedDependencies {
+    embedModelService: EmbedModelService;
+    restoreService: EmbedHostRestoreService;
+    previewService: EmbedFloatPreviewService;
+    runtimeHostLeaseService: EmbedRuntimeHostLeaseService;
+    passiveViewportRegistry: EmbedPassiveViewportRegistryService;
+    passiveWheelHandlerRegistry: EmbedPassiveWheelHandlerRegistryService;
+    sceneCanvasCaptureService: EmbedSceneCanvasCaptureService | undefined;
+}
+/**
+ * Mounts the real Embed runtime for Slides presentation when available. Input is
+ * intentionally presentation-local: wheel is routed through the existing passive
+ * contributions, while activation and editing gestures terminate at the gate.
+ * 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 normalizePresentationPreviewResult(result: EmbedFloatPreviewRenderResult): string | undefined;
+export {};

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

@@ -0,0 +1,44 @@
+import type { IEmbedDescriptor } from '@univerjs-pro/embed';
+import type { IEmbedHostMenuOverride } from '../types/embed-ui';
+import { EmbedFocusOwnerService, EmbedHostAdapterRegistryService } from '@univerjs-pro/embed';
+import { IContextService, IUniverInstanceService } from '@univerjs/core';
+import { ILayoutService } from '@univerjs/ui';
+import { EmbedBlockRegistryService } from './embed-block-registry.service';
+import { EmbedFloatingActiveService } from './embed-floating-active.service';
+import { EmbedHostMenuOverrideService } from './embed-host-menu-override.service';
+import { EmbedMountService } from './embed-mount.service';
+export interface IEmbedFloatingActivationOptions {
+    portalContainer?: HTMLElement | null;
+}
+export declare class EmbedActivationService {
+    private readonly _univerInstanceService;
+    private readonly _focusOwnerService;
+    private readonly _hostAdapterRegistry;
+    private readonly _menuOverrideService;
+    private readonly _mountService;
+    private readonly _blockRegistry?;
+    private readonly _floatingActiveService?;
+    private readonly _contextService?;
+    private readonly _layoutService?;
+    private readonly _previousChildCurrentUnits;
+    private readonly _floatingHostFocusRestorers;
+    constructor(_univerInstanceService: IUniverInstanceService, _focusOwnerService: EmbedFocusOwnerService, _hostAdapterRegistry: EmbedHostAdapterRegistryService, _menuOverrideService: EmbedHostMenuOverrideService, _mountService: EmbedMountService, _blockRegistry?: EmbedBlockRegistryService | undefined, _floatingActiveService?: EmbedFloatingActiveService | undefined, _contextService?: IContextService | undefined, _layoutService?: ILayoutService | undefined);
+    activateTab(descriptor: IEmbedDescriptor): IEmbedHostMenuOverride | null;
+    activateFloating(descriptor: IEmbedDescriptor, stage?: 'stage1' | 'stage2', _options?: IEmbedFloatingActivationOptions): void;
+    focusFloatingRuntime(descriptor: IEmbedDescriptor, options?: IEmbedFloatingActivationOptions): void;
+    activateFullscreen(descriptor: IEmbedDescriptor): void;
+    clearFullscreen(descriptor: IEmbedDescriptor): void;
+    clearFloating(embedId?: string, hostUnitId?: string): void;
+    clearTab(embedId?: string): void;
+    private _rememberPreviousChildCurrentUnit;
+    private _restorePreviousChildCurrentUnit;
+    private _getCurrentUnitId;
+    private _hasUnit;
+    private _findFallbackUnitId;
+    private _focusUnit;
+    private _setCurrentUnitForType;
+    private _focusLayout;
+    private _preserveHostGlobalFocusForFloating;
+    private _releaseFloatingHostFocusRestorers;
+    private _assertResolvedChild;
+}