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

package/lib/types/services/embed-block-contribution-factory.d.ts

@@ -0,0 +1,17 @@
+import type { Injector, UniverInstanceType } from '@univerjs/core';
+import type { IEmbedBlockContribution } from '../types/embed-ui';
+import { EmbedHostChromeMode } from '../types/embed-ui';
+export interface ICreateEmbedRibbonBlockContributionOptions {
+    childType: UniverInstanceType;
+    productName: string;
+    menuSchema?: unknown;
+}
+export interface ICreateEmbedNoHeaderBlockContributionOptions {
+    childType: UniverInstanceType;
+    productName: string;
+    hostChromeMode?: EmbedHostChromeMode.TITLE_ONLY | EmbedHostChromeMode.NONE;
+    hostHeaderMode?: 'none' | 'placeholder';
+}
+export declare function createEmbedRibbonBlockContribution(options: ICreateEmbedRibbonBlockContributionOptions): IEmbedBlockContribution;
+export declare function resolveEmbedProductRibbonMenuSchema(injector: Pick<Injector, 'get' | 'has'> | unknown, childType: UniverInstanceType, fallbackMenuSchema?: unknown): unknown;
+export declare function createEmbedNoHeaderBlockContribution(options: ICreateEmbedNoHeaderBlockContributionOptions): IEmbedBlockContribution;

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

@@ -0,0 +1,8 @@
+import type { IDisposable, UniverInstanceType } from '@univerjs/core';
+import type { IEmbedBlockContribution } from '../types/embed-ui';
+export declare class EmbedBlockRegistryService {
+    private readonly _contributions;
+    register(contribution: IEmbedBlockContribution): IDisposable;
+    get(childType: UniverInstanceType): IEmbedBlockContribution | undefined;
+    list(): IEmbedBlockContribution[];
+}

package/lib/types/services/embed-child-product-plugin-lease.d.ts

@@ -0,0 +1,15 @@
+import type { IUniverInstanceService, UniverInstanceType } from '@univerjs/core';
+export interface IEmbedChildProductCurrentUnitLeaseOptions {
+    instanceService: IUniverInstanceService;
+    childUnitId: string;
+    childType: UniverInstanceType;
+    restoreUnitId?: string;
+    shouldRestore?: () => boolean;
+    /**
+     * Product plugin registration may schedule already-started plugin lifecycle work on a short timer.
+     * Keep the child current/focused until that lifecycle queue has had a chance to observe it.
+     */
+    settleDelayMs?: number;
+    deferredRestoreDelaysMs?: readonly number[];
+}
+export declare function runWithEmbedChildProductCurrentUnit<T>(options: IEmbedChildProductCurrentUnitLeaseOptions, runner: () => T | Promise<T>): Promise<T>;

package/lib/types/services/embed-child-product-plugin-registry.service.d.ts

@@ -0,0 +1,35 @@
+import type { IDisposable, UniverInstanceType } from '@univerjs/core';
+import { Injector } from '@univerjs/core';
+import { EmbedRuntimeFocusCoordinator } from './embed-runtime-focus-coordinator.service';
+export interface IEmbedChildProductPluginPrepareContext {
+    injector: Injector;
+    childUnitId: string;
+    childType: UniverInstanceType;
+    descriptor?: unknown;
+}
+export interface IEmbedChildProductPluginContribution {
+    id?: string;
+    childType: UniverInstanceType;
+    order?: number;
+    prepare?(context: IEmbedChildProductPluginPrepareContext): void | Promise<void>;
+}
+export interface IEmbedChildProductPluginPrepareOptions {
+    childUnitId: string;
+    childType: UniverInstanceType;
+    restoreUnitId?: string;
+    descriptor?: unknown;
+    settleDelayMs?: number;
+}
+export declare function registerEmbedChildProductPluginContribution(injector: Pick<Injector, 'get' | 'has'>, contribution: IEmbedChildProductPluginContribution): IDisposable;
+export declare function flushPendingEmbedChildProductPluginContributions(injector: Pick<Injector, 'get' | 'has'>): void;
+export declare class EmbedChildProductPluginRegistryService {
+    private readonly _injector;
+    private readonly _focusCoordinator?;
+    private readonly _contributions;
+    private _nextIndex;
+    constructor(_injector: Injector, _focusCoordinator?: EmbedRuntimeFocusCoordinator | undefined);
+    register(contribution: IEmbedChildProductPluginContribution): IDisposable;
+    getAll(childType: UniverInstanceType): readonly IEmbedChildProductPluginContribution[];
+    prepare(options: IEmbedChildProductPluginPrepareOptions): Promise<void>;
+    private _hasContributionId;
+}

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

@@ -0,0 +1,7 @@
+import type { 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): {
+    runtimeScope: IEmbedChildRuntimeScope;
+    disposable: IDisposable;
+};

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

@@ -0,0 +1,6 @@
+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;
+export declare function createEmbedScopedConfigInjector(parentInjector: Injector, configOverrides: IEmbedScopedConfigOverrides): Injector | undefined;
+export declare function createEmbedScopedInjector(parentInjector: Injector, overrides: ReadonlyMap<unknown, unknown>, sharedRootInjector?: Injector): Injector;

package/lib/types/services/embed-child-view-registry.service.d.ts

@@ -0,0 +1,8 @@
+import type { UniverInstanceType } from '@univerjs/core';
+import type { IEmbedChildViewContribution } from '../types/embed-ui';
+export declare class EmbedChildViewRegistryService {
+    private readonly _contributions;
+    register(contribution: IEmbedChildViewContribution): void;
+    get(childType: UniverInstanceType): IEmbedChildViewContribution | undefined;
+    list(): IEmbedChildViewContribution[];
+}

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

@@ -0,0 +1,9 @@
+import type { IDisposable, UniverInstanceType } from '@univerjs/core';
+import type { IEmbedContentSize, IEmbedContentSizeMeasureContext, IEmbedContentSizeProvider } from '../types/embed-ui';
+export declare class EmbedContentSizeRegistryService {
+    private readonly _providers;
+    register(provider: IEmbedContentSizeProvider): IDisposable;
+    get(childType: UniverInstanceType): IEmbedContentSizeProvider | undefined;
+    list(): IEmbedContentSizeProvider[];
+    measureContentSize(context: IEmbedContentSizeMeasureContext): IEmbedContentSize | undefined;
+}

package/lib/types/services/embed-default-floating-menu.d.ts

@@ -0,0 +1,4 @@
+import type { IDisposable } from '@univerjs/core';
+import type { IEmbedFloatingMenuContribution, IEmbedFloatingMenuMountContext } from '../types/embed-ui';
+export declare function createDefaultEmbedFloatingMenuContributions(): IEmbedFloatingMenuContribution[];
+export declare function mountDefaultEmbedFloatingMenu(_context: IEmbedFloatingMenuMountContext): IDisposable;

package/lib/types/services/embed-docs-sticky-wheel.d.ts

@@ -0,0 +1,2 @@
+import type { EmbedLayout } from '@univerjs-pro/embed';
+export declare function shouldPassDocsStickyVerticalWheelToHost(layout: EmbedLayout, event: WheelEvent): boolean;

package/lib/types/services/embed-dom-passive-viewport-provider.d.ts

@@ -0,0 +1,8 @@
+import type { EmbedLayout } from '@univerjs-pro/embed';
+import type { UniverInstanceType } from '@univerjs/core';
+import type { IEmbedPassiveViewportProvider } from '../types/embed-ui';
+export interface ICreateEmbedDomPassiveViewportProviderOptions {
+    childType: UniverInstanceType;
+    supportedLayouts?: EmbedLayout[];
+}
+export declare function createEmbedDomPassiveViewportProvider(options: ICreateEmbedDomPassiveViewportProviderOptions): IEmbedPassiveViewportProvider;

package/lib/types/services/embed-float-preview.service.d.ts

@@ -0,0 +1,29 @@
+import type { IDisposable, UniverInstanceType } from '@univerjs/core';
+import type { IEmbedChildContainerContext, IEmbedFloatPreviewEntry, IEmbedFloatPreviewProvider, IEmbedFloatPreviewRenderRequest } from '../types/embed-ui';
+import { Subject } from 'rxjs';
+export declare class EmbedFloatPreviewService {
+    readonly previewUpdated$: Subject<IEmbedFloatPreviewEntry<unknown>>;
+    private readonly _providers;
+    private readonly _entriesByEmbedId;
+    private readonly _entriesByKey;
+    private readonly _queue;
+    private _rendering;
+    private _activeDrain;
+    registerProvider(provider: IEmbedFloatPreviewProvider<any>): IDisposable;
+    getProvider(childType: UniverInstanceType): IEmbedFloatPreviewProvider<any> | undefined;
+    getPreview(embedId: string): IEmbedFloatPreviewEntry | undefined;
+    requestPreview<TViewState = unknown>(request: IEmbedFloatPreviewRenderRequest<TViewState>): IEmbedFloatPreviewEntry<TViewState>;
+    collectViewState<TViewState = unknown>(context: IEmbedChildContainerContext): Promise<TViewState | undefined>;
+    restoreViewState<TViewState = unknown>(context: IEmbedChildContainerContext, viewState: TViewState | undefined): Promise<void>;
+    updateViewState<TViewState = unknown>(embedId: string, viewState: TViewState): void;
+    markStale(embedId: string, reason?: string): void;
+    invalidate(embedId: string): void;
+    getCacheKey(request: IEmbedFloatPreviewRenderRequest): string;
+    flushForTests(): Promise<void>;
+    dispose(): void;
+    private _drainQueue;
+    private _runQueue;
+    private _renderOne;
+    private _findPreviousReadyEntry;
+    private _setRenderFailure;
+}

package/lib/types/services/embed-floating-active.service.d.ts

@@ -0,0 +1,11 @@
+import type { EmbedFloatingStage, IEmbedFloatingActivation } from '../types/embed-ui';
+export declare class EmbedFloatingActiveService {
+    private readonly _active$;
+    readonly active$: import("rxjs").Observable<IEmbedFloatingActivation | null>;
+    getActive(): IEmbedFloatingActivation | null;
+    getStage(embedId: string): EmbedFloatingStage;
+    activate(next: IEmbedFloatingActivation, stage?: Exclude<EmbedFloatingStage, 'inactive'>): void;
+    setStage(embedId: string, stage: Exclude<EmbedFloatingStage, 'inactive'>): void;
+    promote(embedId: string): void;
+    clear(embedId?: string): void;
+}

package/lib/types/services/embed-floating-geometry.service.d.ts

@@ -0,0 +1,22 @@
+import type { IDisposable } from '@univerjs/core';
+export type EmbedFloatingGeometryInvalidationReason = 'host-scroll' | 'child-scroll' | 'resize' | 'stage-change' | 'wheel' | 'manual';
+export interface IEmbedFloatingGeometryInvalidation {
+    embedId?: string;
+    reason: EmbedFloatingGeometryInvalidationReason;
+}
+export interface IEmbedFloatingGeometryRegistration {
+    embedId: string;
+    childUnitId?: string;
+    root: HTMLElement;
+    viewport?: HTMLElement | null;
+    contentRoot?: HTMLElement | null;
+}
+export declare class EmbedFloatingGeometryService {
+    private readonly _registrations;
+    private readonly _geometryInvalidated$;
+    readonly geometryInvalidated$: import("rxjs").Observable<IEmbedFloatingGeometryInvalidation>;
+    register(registration: IEmbedFloatingGeometryRegistration): IDisposable;
+    getRegistration(embedId: string): IEmbedFloatingGeometryRegistration | undefined;
+    getRegistrationByChildUnitId(childUnitId: string): IEmbedFloatingGeometryRegistration | undefined;
+    invalidate(invalidation: IEmbedFloatingGeometryInvalidation): void;
+}

package/lib/types/services/embed-floating-menu-registry.service.d.ts

@@ -0,0 +1,11 @@
+import type { EmbedHostEntry } from '@univerjs-pro/embed';
+import type { IDisposable, UniverInstanceType } from '@univerjs/core';
+import type { IEmbedFloatingMenuContribution } from '../types/embed-ui';
+export declare class EmbedFloatingMenuRegistryService {
+    private readonly _contributions;
+    register(contribution: IEmbedFloatingMenuContribution): IDisposable;
+    get(hostType: UniverInstanceType, entry: EmbedHostEntry, childType?: UniverInstanceType): IEmbedFloatingMenuContribution | undefined;
+    hasExact(hostType: UniverInstanceType, entry: EmbedHostEntry, childType?: UniverInstanceType): boolean;
+    list(): IEmbedFloatingMenuContribution[];
+    private _key;
+}

package/lib/types/services/embed-floating-menu-root.d.ts

@@ -0,0 +1,2 @@
+import type { IEmbedFloatingMenuMountContext } from '../types/embed-ui';
+export declare function resolveEmbedFloatingMenuRoot(context: Pick<IEmbedFloatingMenuMountContext, 'renderScope' | 'runtimeScope'>): HTMLElement;

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

@@ -0,0 +1,12 @@
+import type { IEmbedDescriptor } from '@univerjs-pro/embed';
+import type { IEmbedFullscreenSession } from '../types/embed-ui';
+export declare class EmbedFullscreenService {
+    private readonly _session$;
+    private readonly _exited$;
+    readonly session$: import("rxjs").Observable<IEmbedFullscreenSession | null>;
+    readonly exited$: import("rxjs").Observable<IEmbedFullscreenSession>;
+    getSession(): IEmbedFullscreenSession | null;
+    enter(descriptor: IEmbedDescriptor): IEmbedFullscreenSession;
+    exit(embedId?: string): void;
+    notifyExited(session: IEmbedFullscreenSession): void;
+}

package/lib/types/services/embed-host-container-registry.service.d.ts

@@ -0,0 +1,11 @@
+import type { EmbedHostEntry } from '@univerjs-pro/embed';
+import type { UniverInstanceType } from '@univerjs/core';
+import type { IEmbedHostContainerContribution } from '../types/embed-ui';
+export declare class EmbedHostContainerRegistryService {
+    private readonly _contributions;
+    register(contribution: IEmbedHostContainerContribution): void;
+    get(hostType: UniverInstanceType, entry: EmbedHostEntry): IEmbedHostContainerContribution | undefined;
+    list(): IEmbedHostContainerContribution[];
+    supports(hostType: UniverInstanceType, entry: EmbedHostEntry, layout: IEmbedHostContainerContribution['layout']): boolean;
+    private _key;
+}

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

@@ -0,0 +1,14 @@
+import type { IEmbedDescriptor, IEmbedLayoutPolicy } from '@univerjs-pro/embed';
+import type { IEmbedHostMenuOverride } from '../types/embed-ui';
+export interface IEmbedHostMenuOverrideActivateOptions {
+    layoutPolicy?: IEmbedLayoutPolicy;
+    allowPlaceholder?: boolean;
+    portalContainer?: HTMLElement | null;
+}
+export declare class EmbedHostMenuOverrideService {
+    private readonly _override$;
+    readonly override$: import("rxjs").Observable<IEmbedHostMenuOverride | null>;
+    getOverride(): IEmbedHostMenuOverride | null;
+    activate(descriptor: IEmbedDescriptor, reason: IEmbedHostMenuOverride['reason'], options?: IEmbedHostMenuOverrideActivateOptions): IEmbedHostMenuOverride | null;
+    clear(embedId?: string): void;
+}

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

@@ -0,0 +1,18 @@
+import type { IEmbedDescriptor, IEmbedDescriptorMaterializeContext, IEmbedHostAnchorRecord } from '@univerjs-pro/embed';
+import type { ICreateUnitOptions } from '@univerjs/core';
+import { EmbedHostAdapterRegistryService, EmbedHostAnchorModelService, EmbedModelService, EmbedReferencedUnitMaterializeService } from '@univerjs-pro/embed';
+export interface IEmbedHostRestoreContext {
+    descriptor: IEmbedDescriptor;
+    hostAnchorRecord?: IEmbedHostAnchorRecord;
+    hostContext?: Record<string, unknown>;
+    createOptions?: ICreateUnitOptions;
+}
+export declare class EmbedHostRestoreService {
+    private readonly _modelService;
+    private readonly _materializeService;
+    private readonly _hostAdapterRegistry;
+    private readonly _anchorModelService;
+    constructor(_modelService: EmbedModelService, _materializeService: EmbedReferencedUnitMaterializeService, _hostAdapterRegistry: EmbedHostAdapterRegistryService, _anchorModelService: EmbedHostAnchorModelService);
+    materializeDescriptor(context: IEmbedDescriptorMaterializeContext): Promise<IEmbedDescriptor>;
+    restoreEmbed(context: IEmbedHostRestoreContext): Promise<IEmbedDescriptor>;
+}

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

@@ -0,0 +1,42 @@
+import type { IDisposable } from '@univerjs/core';
+export declare const EMBED_INTERACTION_BOUNDARY_OWNER_ATTRIBUTE = "data-embed-interaction-boundary-owner";
+export declare function getEmbedInteractionBoundaryOwnerId(element: HTMLElement | null | undefined): string | undefined;
+export declare function isEventTargetInSameEmbedInteractionBoundary(scopeElement: HTMLElement | null | undefined, target: EventTarget | null | undefined): boolean;
+export declare class EmbedInteractionBoundaryService {
+    private readonly _roots;
+    private readonly _portalObservers;
+    private readonly _activePortalOwners;
+    private _pendingPortalOwner;
+    registerRoot(embedId: string, root: HTMLElement): 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;
+    private _collectOwnedFloatingSurfaceRoots;
+    private _resolveFloatingSurfaceRoot;
+    private _dispatchEscapeToFloatingSurface;
+    private _isOwnedElement;
+    private _claimBodyPortals;
+    private _ensurePortalObserver;
+    private _markBodyPortalOwner;
+    private _markExistingBodyPortals;
+    private _isBodyPortalCandidate;
+    private _isAppShellEditorPortalCandidate;
+    private _isHostDocEditorPortal;
+    private _isUniverPortalCandidate;
+    private _isDetachedOffscreenPortalCandidate;
+    private _markRuntimeFocusRole;
+    private _markInteractionBoundaryOwnerTree;
+    private _isUniverPortalTreeElement;
+    private _getBodyPortalOwner;
+    private _getLatestActivePortalOwner;
+    private _cleanupOrdinaryBodyChromeClaims;
+    private _blurActiveElementBeforePortalReassignment;
+    private _releaseBodyPortalClaims;
+    private _focusDocumentBody;
+    private _focusTemporarySink;
+    private _removeRuntimeFocusRoleTree;
+}

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

@@ -0,0 +1,52 @@
+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 { EmbedHostContainerRegistryService } from './embed-host-container-registry.service';
+import { EmbedOverlayRootService } from './embed-overlay-root.service';
+import { EmbedRuntimePolicyService } from './embed-runtime-policy.service';
+import { EmbedSceneCanvasCaptureService } from './embed-scene-canvas-capture.service';
+export declare const EMBED_DUPLICATE_CHILD_UNIT_ERROR_CODE = "EMBED_DUPLICATE_CHILD_UNIT";
+export declare class EmbedDuplicateChildUnitError extends Error {
+    readonly childUnitId: string;
+    readonly existingEmbedId: string;
+    readonly code = "EMBED_DUPLICATE_CHILD_UNIT";
+    constructor(childUnitId: string, existingEmbedId: string);
+}
+export declare class EmbedMountService {
+    private readonly _hostContainerRegistry;
+    private readonly _childViewRegistry;
+    private readonly _overlayRootService;
+    private readonly _sceneCanvasCaptureService;
+    private readonly _univerInstanceService;
+    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);
+    mount(descriptor: IEmbedDescriptor): IEmbedMountSession;
+    mountIntoHostElement(descriptor: IEmbedDescriptor, hostElement: HTMLElement, runtimeRoots?: IEmbedHostMountResult['runtimeRoots']): IEmbedMountSession;
+    private _mountResolvedHost;
+    private _mountBlockedRuntime;
+    private _initializeFloatingSessionActiveState;
+    unmount(embedId: string): void;
+    getSession(embedId: string): IEmbedMountSession | undefined;
+    listSessions(): IEmbedMountSession[];
+    activateSession(embedId: string): void;
+    deactivateTabSessions(embedId?: string): IEmbedMountSession[];
+    deactivateFloatingSession(embedId: string): IEmbedMountSession | undefined;
+    setActive(embedId: string, active: boolean): void;
+    private _runChildBeforeDeactivate;
+    private _resolveLayout;
+    private _createRenderScope;
+    private _registerRuntimeBoundary;
+    private _normalizeHostMountResult;
+    private _mountFloatingMenu;
+    private _registerChildFocusBridge;
+    private _focusTabPeerSession;
+    private _activateTabPeerFocusLease;
+    private _releaseTabPeerFocusLeasesForHost;
+    private _releaseTabPeerFocusLease;
+    private _createMountFocusRestorer;
+    private _assertChildUnitAvailable;
+}

package/lib/types/services/embed-overlay-root.service.d.ts

@@ -0,0 +1,22 @@
+import type { IDisposable } from '@univerjs/core';
+export interface IEmbedOverlayRootRegistration {
+    childUnitId: string;
+    embedId?: string;
+    hostAnchorId?: string;
+    root: HTMLElement;
+}
+export declare class EmbedOverlayRootService {
+    private readonly _rootsByChildUnitId;
+    private readonly _rootsByEmbedId;
+    private readonly _rootsByHostAnchorId;
+    register(childUnitId: string, root: HTMLElement): IDisposable;
+    register(registration: IEmbedOverlayRootRegistration): IDisposable;
+    get(childUnitId: string): HTMLElement | null;
+    getByEmbedId(embedId: string): HTMLElement | null;
+    getByHostAnchorId(hostAnchorId: string): HTMLElement | null;
+    contains(target: EventTarget | Node | null | undefined, query: {
+        childUnitId?: string;
+        embedId?: string;
+        hostAnchorId?: string;
+    }): boolean;
+}

package/lib/types/services/embed-passive-viewport-registry.service.d.ts

@@ -0,0 +1,9 @@
+import type { EmbedLayout } from '@univerjs-pro/embed';
+import type { IDisposable, UniverInstanceType } from '@univerjs/core';
+import type { IEmbedPassiveViewportProvider } from '../types/embed-ui';
+export declare class EmbedPassiveViewportRegistryService {
+    private readonly _providers;
+    register(provider: IEmbedPassiveViewportProvider): IDisposable;
+    get(childType: UniverInstanceType, layout?: EmbedLayout): IEmbedPassiveViewportProvider | undefined;
+    list(): IEmbedPassiveViewportProvider[];
+}

package/lib/types/services/embed-passive-wheel-handler-registry.service.d.ts

@@ -0,0 +1,9 @@
+import type { IDisposable } from '@univerjs/core';
+import type { IEmbedPassiveViewportWheelContext, IEmbedPassiveWheelHandlerContribution } from '../types/embed-ui';
+export declare class EmbedPassiveWheelHandlerRegistryService {
+    private readonly _handlers;
+    register(handler: IEmbedPassiveWheelHandlerContribution): IDisposable;
+    handleWheel(context: IEmbedPassiveViewportWheelContext): boolean;
+    list(): IEmbedPassiveWheelHandlerContribution[];
+    private _sortHandlers;
+}

package/lib/types/services/embed-product-floating-menu-contributions.d.ts

@@ -0,0 +1,2 @@
+import type { IEmbedFloatingMenuContribution } from '../types/embed-ui';
+export declare function createEmbedProductFloatingMenuContributions(params: Pick<IEmbedFloatingMenuContribution, 'childType' | 'mount'>): IEmbedFloatingMenuContribution[];

package/lib/types/services/embed-product-menu-mounting.d.ts

@@ -0,0 +1,18 @@
+import type { DependencyIdentifier, IDisposable, Injector } from '@univerjs/core';
+import type { IEmbedProductMenuMountContext } from '../types/embed-ui';
+import { UniverInstanceType } from '@univerjs/core';
+import { IRibbonService } from '@univerjs/ui';
+export declare function mountEmbedProductRibbonMenu(context: IEmbedProductMenuMountContext): IDisposable | undefined;
+export declare function createEmbedProductRibbonRuntime(injector: Injector, params: {
+    childType: UniverInstanceType;
+    childUnitId?: string;
+    embedId?: string;
+    menuSchema?: unknown;
+    menuTitlePrefix?: string;
+    activeRibbonTab?: string;
+    scopedActionServiceTokens?: readonly DependencyIdentifier<unknown>[];
+}): {
+    injector: Injector;
+    ribbonService: IRibbonService;
+    disposable: IDisposable;
+};

package/lib/types/services/embed-product-menu-registry.service.d.ts

@@ -0,0 +1,14 @@
+import type { IDisposable, Injector, UniverInstanceType } from '@univerjs/core';
+import type { EmbedProductMenuSurface, IEmbedProductMenuContribution, IEmbedProductMenuMountContext } from '../types/embed-ui';
+export declare function registerEmbedProductMenuContribution(injector: Pick<Injector, 'get' | 'has'>, contribution: IEmbedProductMenuContribution): IDisposable | undefined;
+export declare function flushPendingEmbedProductMenuContributions(injector: Pick<Injector, 'get' | 'has'>): void;
+export declare class EmbedProductMenuRegistryService {
+    private readonly _contributions;
+    private _nextIndex;
+    constructor();
+    register(contribution: IEmbedProductMenuContribution): IDisposable;
+    get(childType: UniverInstanceType): IEmbedProductMenuContribution | undefined;
+    getAll(childType: UniverInstanceType, surface?: EmbedProductMenuSurface): readonly IEmbedProductMenuContribution[];
+    getMergedMenuSchema(childType: UniverInstanceType, surface?: EmbedProductMenuSurface): unknown | undefined;
+    mountMenu(context: Omit<IEmbedProductMenuMountContext, 'menuSchema'>): IDisposable | undefined;
+}

package/lib/types/services/embed-readonly-preview-registry.service.d.ts

@@ -0,0 +1,8 @@
+import type { UniverInstanceType } from '@univerjs/core';
+import type { IEmbedReadonlyPreviewProvider } from '../types/embed-ui';
+export declare class EmbedReadonlyPreviewRegistryService {
+    private readonly _providers;
+    register(provider: IEmbedReadonlyPreviewProvider<any>): void;
+    get(childType: UniverInstanceType): IEmbedReadonlyPreviewProvider<any> | undefined;
+    list(): IEmbedReadonlyPreviewProvider<any>[];
+}

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

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

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

@@ -0,0 +1,52 @@
+import type { EmbedLayout } from '@univerjs-pro/embed';
+import type { DependencyIdentifier, IDisposable, UniverInstanceType } from '@univerjs/core';
+import type { IRenderManagerService } from '@univerjs/engine-render';
+import type { IEmbedChildContainerContext, IEmbedChildViewContribution } from '../types/embed-ui';
+import { Injector } from '@univerjs/core';
+export interface IEmbedRenderLike {
+    isMainScene?: boolean;
+    engine: {
+        mount: (target: HTMLElement) => void;
+        unmount?: () => void;
+        resize: () => void;
+        getCanvasElement?: () => HTMLCanvasElement | undefined;
+        getCanvas?: () => {
+            getCanvasEle?: () => HTMLCanvasElement | undefined;
+        } | undefined;
+    };
+    activate?: () => void;
+    components: {
+        forEach: (callback: (component: {
+            makeForceDirty?: (dirty: boolean) => void;
+            makeDirty?: (dirty?: boolean) => void;
+        }) => void) => void;
+    };
+    mainComponent?: {
+        makeDirty?: (dirty?: boolean) => void;
+    } | null | void;
+    scene: {
+        makeDirty: () => void;
+        render?: () => void;
+    };
+    with?: <T>(dependency: DependencyIdentifier<T>) => T;
+}
+export interface ICreateEmbedRenderChildViewContributionOptions {
+    childType: UniverInstanceType;
+    supportedLayouts: readonly EmbedLayout[];
+    renderManagerService: DependencyIdentifier<IRenderManagerService>;
+}
+export interface IMountEmbedRenderChildUnitOptions {
+    activate?: boolean;
+    scopedRenderInjector?: boolean;
+    scopedInjector?: Injector;
+}
+export declare function createEmbedRenderChildViewContribution(options: ICreateEmbedRenderChildViewContributionOptions): IEmbedChildViewContribution;
+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;
+}): 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;
+export declare function refreshEmbedChildRender(render: IEmbedRenderLike, options?: {
+    activate?: boolean;
+}): void;

package/lib/types/services/embed-runtime-focus-coordinator.service.d.ts

@@ -0,0 +1,76 @@
+import type { IDisposable, UniverInstanceType } from '@univerjs/core';
+import { Subject } from 'rxjs';
+export declare const EMBED_RUNTIME_FOCUS_ROLE_ATTRIBUTE = "data-embed-runtime-focus-role";
+export type EmbedRuntimeFocusRole = 'runtime' | 'child-session' | 'child-editor' | 'child-popup' | 'floating-menu';
+export type EmbedRuntimeSessionMode = 'host-passive' | 'child-keyboard' | 'child-fullscreen' | 'child-tab';
+export interface IEmbedRuntimeFocusLeaseOptions {
+    embedId: string;
+    role: EmbedRuntimeFocusRole;
+    owner?: string;
+    sessionMode?: EmbedRuntimeSessionMode;
+    hostUnitId?: string;
+    childUnitId?: string;
+    childType?: UniverInstanceType;
+    associatedChildUnitIds?: string[];
+}
+export interface IEmbedRuntimeFocusElementRegistration {
+    embedId: string;
+    role: EmbedRuntimeFocusRole;
+    element: HTMLElement;
+}
+export interface IEmbedRuntimeScopeRegistration {
+    embedId: string;
+    hostUnitId?: string;
+    childUnitId?: string;
+    childType?: UniverInstanceType;
+    sessionMode?: EmbedRuntimeSessionMode;
+}
+export interface IEmbedRuntimeFocusLeaseQueryOptions {
+    ignoreOwners?: string[];
+}
+export declare class EmbedRuntimeFocusCoordinator {
+    private readonly _leases;
+    private readonly _elements;
+    private readonly _runtimeScopes;
+    private _leaseSequence;
+    readonly runtimeFocusChanged$: Subject<void>;
+    readonly runtimeSessionChanged$: Subject<void>;
+    acquireLease(options: IEmbedRuntimeFocusLeaseOptions): IDisposable;
+    hasChildInteractionLease(embedId: string | undefined): boolean;
+    hasBlockingChildFocusLease(embedId: string | undefined, options?: IEmbedRuntimeFocusLeaseQueryOptions): boolean;
+    hasAnyChildInteractionLease(): boolean;
+    hasAnyBlockingChildFocusLease(options?: IEmbedRuntimeFocusLeaseQueryOptions): boolean;
+    hasHostPreservingChildFocusLease(embedId: string | undefined, options?: IEmbedRuntimeFocusLeaseQueryOptions): boolean;
+    hasAnyHostPreservingChildFocusLease(options?: IEmbedRuntimeFocusLeaseQueryOptions): boolean;
+    hasHostPreservingChildFocusLeaseForHost(hostUnitId: string | undefined, options?: IEmbedRuntimeFocusLeaseQueryOptions): boolean;
+    isChildUnitInActiveSession(unitId: string | undefined): boolean;
+    registerRuntimeScope(options: IEmbedRuntimeScopeRegistration): IDisposable;
+    resolveRuntimeScopeByChildUnitId(childUnitId: string | undefined): IEmbedRuntimeScopeRegistration | undefined;
+    resolveActiveChildSessionRuntimeScope(): IEmbedRuntimeScopeRegistration | undefined;
+    isChildUnitRuntimeEvent(unitId: string | undefined, target: EventTarget | null | undefined, event?: Event): boolean;
+    shouldSuppressHostInteraction(unitId: string | undefined, target?: EventTarget | null, event?: Event, options?: IEmbedRuntimeFocusLeaseQueryOptions): boolean;
+    registerElement(options: IEmbedRuntimeFocusElementRegistration): IDisposable;
+    containsElement(embedId: string | undefined, target: EventTarget | null | undefined, event?: Event): boolean;
+    private _containsRegisteredElement;
+    private _isBlockingLease;
+    private _isHostPreservingLease;
+    private _leaseAppliesToHostUnit;
+    private _ownedRuntimeFocusAppliesToHost;
+    private _leaseAppliesToChildUnit;
+    private _ownedEmbedAppliesToChildUnit;
+    private _isBlockingRole;
+    private _getChildSessionPriority;
+    private _resolveChildSessionMode;
+    private _isOwnedBoundaryElement;
+    private _getOwnedEmbedIdFromTarget;
+    private _getOwnedEmbedIdFromEventPoint;
+    private _getEventClientPoint;
+    private _rectContainsPoint;
+    private _getActiveOwnedRuntimeFocusInfo;
+    private _isHTMLElement;
+    private _isRuntimeFocusRole;
+    private _getAnyActiveElement;
+    private _getActiveElement;
+    private _notifyRuntimeFocusChanged;
+    private _notifyRuntimeSessionChanged;
+}