@univerjs-pro/embed-ui 1.0.0-insiders.20260709-5fcadb2

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

@@ -0,0 +1,57 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+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,68 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+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 _registerChildProductPlugins;
+    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,37 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+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,24 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { IDisposable, UniverInstanceType } from '@univerjs/core';
+import type { EmbedLayout } from '@univerjs-pro/embed';
+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,24 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+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,17 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+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,33 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+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,29 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+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,23 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+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,23 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { DependencyIdentifier, Injector, UniverInstanceType } from '@univerjs/core';
+import type { IEmbedFloatPreviewProvider } from '../types/embed-ui';
+import type { IEmbedRenderManagerServiceLike } from './embed-render-child-view-contribution';
+export interface ICreateEmbedRenderCanvasPreviewProviderOptions {
+    childType: UniverInstanceType;
+    renderManagerService: DependencyIdentifier<IEmbedRenderManagerServiceLike>;
+}
+export declare function createEmbedRenderCanvasPreviewProvider(injector: Injector, options: ICreateEmbedRenderCanvasPreviewProviderOptions): IEmbedFloatPreviewProvider;

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

@@ -0,0 +1,76 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { DependencyIdentifier, IDisposable, UniverInstanceType } from '@univerjs/core';
+import type { EmbedLayout } from '@univerjs-pro/embed';
+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 IEmbedRenderManagerServiceLike {
+    getRenderById: (unitId: string) => IEmbedRenderLike | null | undefined | void;
+    createRender: (unitId: string, options?: {
+        embeddedRender?: boolean;
+        makeCurrent?: boolean;
+        renderParentInjector?: Injector;
+        skipAutoRender?: boolean;
+    }) => IEmbedRenderLike;
+    removeRender?: (unitId: string) => void;
+}
+export interface ICreateEmbedRenderChildViewContributionOptions {
+    childType: UniverInstanceType;
+    supportedLayouts: readonly EmbedLayout[];
+    renderManagerService: DependencyIdentifier<IEmbedRenderManagerServiceLike>;
+}
+export interface IMountEmbedRenderChildUnitOptions {
+    activate?: boolean;
+    scopedRenderInjector?: boolean;
+    scopedInjector?: Injector;
+}
+export declare function createEmbedRenderChildViewContribution(options: ICreateEmbedRenderChildViewContributionOptions): IEmbedChildViewContribution;
+export declare function mountEmbedRenderChildUnit(context: IEmbedChildContainerContext, renderManagerServiceIdentifier: DependencyIdentifier<IEmbedRenderManagerServiceLike>, target?: HTMLElement, options?: IMountEmbedRenderChildUnitOptions): IDisposable | undefined;
+export declare function observeEmbedRenderTargetResize(render: IEmbedRenderLike, target: HTMLElement, options?: {
+    activate?: boolean;
+}): IDisposable;
+export declare function ensureEmbedChildRender(renderManagerService: IEmbedRenderManagerServiceLike, childUnitId: string, renderParentInjector?: Injector): IEmbedRenderLike | undefined;
+export declare function createEmbedChildRender(renderManagerService: IEmbedRenderManagerServiceLike, 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,91 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+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;
+}

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

@@ -0,0 +1,43 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { IDisposable } from '@univerjs/core';
+import type { IEmbedDescriptor } from '@univerjs-pro/embed';
+export interface IEmbedRuntimeAncestor {
+    hostUnitId: string;
+    embedId: string;
+    childUnitId: string;
+}
+export interface IEmbedRuntimeMountDecision {
+    allowed: boolean;
+    reason?: 'max-depth' | 'cycle';
+    ancestry: readonly IEmbedRuntimeAncestor[];
+}
+export interface IEmbedRuntimePolicyConfig {
+    maxDepth?: number;
+}
+type EmbedRuntimeDescriptor = Pick<IEmbedDescriptor, 'hostUnitId' | 'embedId'> & {
+    childUnitId: string;
+};
+export declare class EmbedRuntimePolicyService {
+    private readonly _childUnitAncestry;
+    private readonly _maxDepth;
+    constructor(config?: IEmbedRuntimePolicyConfig);
+    canMount(descriptor: EmbedRuntimeDescriptor): IEmbedRuntimeMountDecision;
+    registerMountedRuntime(descriptor: EmbedRuntimeDescriptor): IDisposable;
+    getAncestryForHostUnit(hostUnitId: string): readonly IEmbedRuntimeAncestor[];
+    getParentEmbedId(hostUnitId: string): string | undefined;
+}
+export {};

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

@@ -0,0 +1,30 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { UniverInstanceType } from '@univerjs/core';
+export declare const EMBED_FLOAT_DOM_ATTRIBUTE = "data-embed-float-dom";
+export declare const EMBED_ID_ATTRIBUTE = "data-embed-id";
+export declare const EMBED_HOST_UNIT_ID_ATTRIBUTE = "data-embed-host-unit-id";
+export declare const EMBED_CHILD_UNIT_ID_ATTRIBUTE = "data-embed-child-unit-id";
+export declare const EMBED_CHILD_TYPE_ATTRIBUTE = "data-embed-child-type";
+export interface IEmbedRuntimeDomScope {
+    embedId: string;
+    hostUnitId?: string;
+    childUnitId?: string;
+    childType?: UniverInstanceType;
+}
+export declare function resolveEmbedRuntimeDomScope(element: HTMLElement | null | undefined): IEmbedRuntimeDomScope | undefined;
+export declare function resolveActiveEmbedRuntimeDomScope(ownerDocument?: Document): IEmbedRuntimeDomScope | undefined;
+export declare function resolveEmbedFloatDomContainer(element: HTMLElement | null | undefined, embedId?: string): HTMLElement | undefined;

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

@@ -0,0 +1,39 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { IDisposable, UniverInstanceType } from '@univerjs/core';
+import type { IEmbedChildContainerContext } from '../types/embed-ui';
+export type EmbedSceneCanvasCaptureResult = string | HTMLCanvasElement | ImageBitmap;
+export interface IEmbedSceneCanvasCaptureProvider {
+    childType: UniverInstanceType;
+    capture(context: IEmbedChildContainerContext): Promise<EmbedSceneCanvasCaptureResult | null | undefined> | EmbedSceneCanvasCaptureResult | null | undefined;
+}
+export declare class EmbedSceneCanvasCaptureService {
+    private readonly _providers;
+    private readonly _contextsByEmbedId;
+    private readonly _contextsByHostAnchorId;
+    private readonly _contextsByChildUnitId;
+    register(provider: IEmbedSceneCanvasCaptureProvider): IDisposable;
+    get(childType: UniverInstanceType): IEmbedSceneCanvasCaptureProvider | undefined;
+    registerContext(context: IEmbedChildContainerContext): IDisposable;
+    getContextByEmbedId(embedId: string): IEmbedChildContainerContext | undefined;
+    getContextByHostAnchorId(hostAnchorId: string): IEmbedChildContainerContext | undefined;
+    getContextByChildUnitId(childUnitId: string): IEmbedChildContainerContext | undefined;
+    capture(context: IEmbedChildContainerContext): Promise<EmbedSceneCanvasCaptureResult | null | undefined>;
+    captureByEmbedId(embedId: string): Promise<EmbedSceneCanvasCaptureResult | null | undefined>;
+    captureByHostAnchorId(hostAnchorId: string): Promise<EmbedSceneCanvasCaptureResult | null | undefined>;
+    captureByChildUnitId(childUnitId: string): Promise<EmbedSceneCanvasCaptureResult | null | undefined>;
+}
+export declare function captureEmbedContextSceneCanvas(context: IEmbedChildContainerContext): string | undefined;