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

package/lib/types/components/EmbedFloatDomRenderer.d.ts

@@ -2,6 +2,15 @@ import type { Observable } from 'rxjs';
 import type { EmbedFloatingStage, EmbedInteractionFlow, IEmbedChildContainerContext } from '../types/embed-ui';
 import { UniverInstanceType } from '@univerjs/core';
 export declare const EMBED_FLOAT_DRAG_HANDLE_POINTER_DOWN_EVENT = "univer:embed-float-drag-handle:pointerdown";
+export interface IEmbedFloatDragHandlePointerDownDetail {
+    embedId: string;
+    hostUnitId: string;
+    hostAnchorId: string;
+    pointerId?: number;
+    clientX: number;
+    clientY: number;
+    button?: number;
+}
 export interface IEmbedFloatDomData {
     version: 1;
     embedId: string;
@@ -30,12 +39,21 @@ export declare function EmbedFloatDomRenderer(props: {
     onHostWheel?: (event: WheelEvent, context: IEmbedChildContainerContext) => boolean | void;
     onRuntimeStageEnter?: (stage: EmbedFloatingStage) => void;
     onRuntimeStageExit?: () => void;
+    floatingChromeZIndex?: number;
     syncHostVerticalScroll?: boolean;
     enableStage1BodyDrag?: boolean;
+    fullscreenButtonInBlock?: boolean;
+    /**
+     * Avoid mounting and measuring body-level floating chrome while the block
+     * is inactive. Hosts with an in-block fullscreen affordance can use this
+     * to keep viewport movement independent of the number of float blocks.
+     */
+    deferInactiveFloatingChrome?: boolean;
+    resolveHostWheelGestureRoot?: (container: HTMLElement) => HTMLElement | null | undefined;
     isExternalHostInteraction?: (event: PointerEvent) => boolean;
 }): import("react").JSX.Element;
 export declare function syncRuntimeInteractionVisibility(container: HTMLElement, chrome: HTMLElement | undefined, visible: boolean, _stage: 'inactive' | 'stage1' | 'stage2'): void;
-export declare function syncChromeControlsVisibility(chrome: HTMLElement | undefined, visible: boolean, dragHandleVisible: boolean, stage: 'inactive' | 'stage1' | 'stage2'): void;
+export declare function syncChromeControlsVisibility(container: HTMLElement, chrome: HTMLElement | undefined, visible: boolean, dragHandleVisible: boolean, stage: 'inactive' | 'stage1' | 'stage2'): void;
 export declare function syncDocsSheetLikeChromePageArea(chrome: HTMLElement, chromeRect: DOMRect, pageRect: DOMRect): void;
 export declare function resolveChromeAnchorRect(container: HTMLElement): DOMRect;
 export declare function shouldAcquireOwnedInteractionPointerLease(options: {

package/lib/types/controllers/components.controller.d.ts

@@ -0,0 +1,7 @@
+import { Disposable } from '@univerjs/core';
+import { ComponentManager } from '@univerjs/ui';
+export declare class ComponentsController extends Disposable {
+    private readonly _componentManager;
+    constructor(_componentManager: ComponentManager);
+    private _registerComponents;
+}

package/lib/types/locale/en-US.d.ts

@@ -1,8 +1,16 @@
 declare const locale: {
     'embed-ui': {
+        deleteBlock: string;
         fullscreen: {
             exit: string;
         };
+        boardsFloating: {
+            fitContent: string;
+            zoomOut: string;
+            resetZoom: string;
+            zoomIn: string;
+            delete: string;
+        };
         basesFloating: {
             copySuffix: string;
             delete: string;
@@ -32,6 +40,7 @@ declare const locale: {
                 fontSize: string;
                 numberFormat: string;
                 bold: string;
+                filter: string;
                 resetColor: string;
                 textColor: {
                     main: string;

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

@@ -11,11 +11,6 @@ export declare function resolveBasesFloatingMenuStage(params: {
     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;

package/lib/types/products/boards/BoardEmbedHostRenderController.d.ts

@@ -0,0 +1,28 @@
+import type { BoardModel } from '@univerjs-pro/boards';
+import type { IRenderContext, IRenderModule } from '@univerjs/engine-render';
+import { IBoardElementService } from '@univerjs-pro/boards';
+import { BoardDomLayerService, IBoardElementStateService, IBoardUIStateService } from '@univerjs-pro/boards-ui';
+import { EmbedModelService } from '@univerjs-pro/embed';
+import { Disposable, ICommandService, IConfigService } from '@univerjs/core';
+export declare class BoardEmbedHostRenderController extends Disposable implements IRenderModule {
+    private readonly _context;
+    private readonly _embedModelService;
+    private readonly _domLayerService;
+    private readonly _boardElementService;
+    private readonly _boardElementStateService;
+    private readonly _boardUIStateService;
+    private readonly _configService;
+    private readonly _commandService;
+    private readonly _items;
+    private _activeDragCleanup;
+    constructor(_context: IRenderContext<BoardModel>, _embedModelService: EmbedModelService, _domLayerService: BoardDomLayerService, _boardElementService: IBoardElementService, _boardElementStateService: IBoardElementStateService, _boardUIStateService: IBoardUIStateService, _configService: IConfigService, _commandService: ICommandService);
+    dispose(): void;
+    private _sync;
+    private _itemId;
+    private readonly _routeWheelToHost;
+    private readonly _resolveHostWheelGestureRoot;
+    private _selectAnchor;
+    private _setAnchorTransformerVisible;
+    private _handleDragStart;
+    private _clearItems;
+}

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

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

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

@@ -0,0 +1,7 @@
+import type { EmbedFloatingStage, IEmbedFloatingActivation, IEmbedFloatingMenuContribution } from '../../types/embed-ui';
+export declare function createBoardsFloatingMenuContributions(): IEmbedFloatingMenuContribution[];
+export declare function resolveBoardsFloatingMenuStage(params: {
+    embedId: string;
+    active: IEmbedFloatingActivation | null;
+    fullscreen: boolean;
+}): EmbedFloatingStage;

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

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

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

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

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

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

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

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

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

@@ -1,7 +1,2 @@
 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-docs-custom-block-bleed.render-controller.d.ts

@@ -8,12 +8,12 @@ export declare class EmbedDocsCustomBlockBleedRenderController extends Disposabl
     private readonly _context;
     private readonly _univerInstanceService;
     private readonly _commandService;
-    private readonly _contentSizeRegistry?;
-    private readonly _embedModelService?;
-    private readonly _renderManagerService?;
+    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);
+    constructor(_context: IRenderContext<DocumentDataModel>, _univerInstanceService: IUniverInstanceService, _commandService: ICommandService, _contentSizeRegistry: EmbedContentSizeRegistryService, _embedModelService: EmbedModelService, _renderManagerService: IRenderManagerService);
     private _getHostUnit;
     private _getHostSnapshot;
     private _rerenderHostDoc;

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

@@ -2,7 +2,6 @@ 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';
@@ -44,14 +43,8 @@ export declare function resolveMenuCommandRequest(item: IMenuItem | undefined, p
 } | 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/slides/components/embed-floating-menu/SlideEmbedFloatingMenu.d.ts

@@ -4,7 +4,6 @@ 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;
@@ -15,14 +14,4 @@ export interface ISlideEmbedFloatingMenuProps {
     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/services/embed-activation.service.d.ts

@@ -16,13 +16,13 @@ export declare class EmbedActivationService {
     private readonly _hostAdapterRegistry;
     private readonly _menuOverrideService;
     private readonly _mountService;
-    private readonly _blockRegistry?;
-    private readonly _floatingActiveService?;
-    private readonly _contextService?;
-    private readonly _layoutService?;
+    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);
+    constructor(_univerInstanceService: IUniverInstanceService, _focusOwnerService: EmbedFocusOwnerService, _hostAdapterRegistry: EmbedHostAdapterRegistryService, _menuOverrideService: EmbedHostMenuOverrideService, _mountService: EmbedMountService, _blockRegistry: EmbedBlockRegistryService, _floatingActiveService: EmbedFloatingActiveService, _contextService: IContextService, _layoutService: ILayoutService);
     activateTab(descriptor: IEmbedDescriptor): IEmbedHostMenuOverride | null;
     activateFloating(descriptor: IEmbedDescriptor, stage?: 'stage1' | 'stage2', _options?: IEmbedFloatingActivationOptions): void;
     focusFloatingRuntime(descriptor: IEmbedDescriptor, options?: IEmbedFloatingActivationOptions): void;

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

@@ -24,10 +24,10 @@ export declare function registerEmbedChildProductPluginContribution(injector: Pi
 export declare function flushPendingEmbedChildProductPluginContributions(injector: Pick<Injector, 'get' | 'has'>): void;
 export declare class EmbedChildProductPluginRegistryService {
     private readonly _injector;
-    private readonly _focusCoordinator?;
+    private readonly _focusCoordinator;
     private readonly _contributions;
     private _nextIndex;
-    constructor(_injector: Injector, _focusCoordinator?: EmbedRuntimeFocusCoordinator | undefined);
+    constructor(_injector: Injector, _focusCoordinator: EmbedRuntimeFocusCoordinator);
     register(contribution: IEmbedChildProductPluginContribution): IDisposable;
     getAll(childType: UniverInstanceType): readonly IEmbedChildProductPluginContribution[];
     prepare(options: IEmbedChildProductPluginPrepareOptions): Promise<void>;

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

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