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

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

@@ -0,0 +1,92 @@
+import type { IMenuItem } from '@univerjs/ui';
+import type { ReactNode } from 'react';
+import type { LocaleKey } from '../../locale/types';
+import { BorderStyleTypes, BorderType } from '@univerjs/core';
+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 NumberFormatDropdown(props: {
+    menuItem: IMenuItem | undefined;
+    onClick: () => void;
+}): import("react").JSX.Element | null;
+export declare function FontFamilyFloatingDropdown(props: {
+    embedId: string;
+    menuItem: IMenuItem | undefined;
+    title: LocaleKey;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onSelect: (value: string) => void;
+}): import("react").JSX.Element | null;
+export declare function FontSizeFloatingDropdown(props: {
+    embedId: string;
+    menuItem: IMenuItem | undefined;
+    title: LocaleKey;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onSelect: (value: string) => void;
+}): import("react").JSX.Element | null;
+export declare function HorizontalAlignDropdown(props: {
+    embedId: string;
+    menuItem: IMenuItem | undefined;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    execute: (item: IMenuItem | undefined, params?: object) => void;
+}): import("react").JSX.Element | null;
+export declare function VerticalAlignDropdown(props: {
+    embedId: string;
+    menuItem: IMenuItem | undefined;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    execute: (item: IMenuItem | undefined, params?: object) => void;
+}): import("react").JSX.Element | null;
+export declare function ColorDropdown(props: {
+    embedId: string;
+    menuItem: IMenuItem | undefined;
+    title: LocaleKey;
+    icon: ReactNode;
+    defaultColor: string;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onChange: (value: string) => void;
+    onReset: () => void;
+}): import("react").JSX.Element | null;
+export declare function BorderCompositeDropdown(props: {
+    embedId: string;
+    menuItem: IMenuItem | undefined;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onSelect: (type: BorderType, style?: BorderStyleTypes, color?: string) => void;
+}): import("react").JSX.Element | null;
+export declare function MergeDropdown(props: {
+    embedId: string;
+    menuItems: IResolvedSheetsFloatingToolbarMenuItems['merge'];
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    execute: (item: IMenuItem | undefined, params?: object) => void;
+}): import("react").JSX.Element | null;
+export declare function WrapDropdown(props: {
+    embedId: string;
+    menuItem: IMenuItem | undefined;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    execute: (commandId: string, params?: object) => void;
+}): import("react").JSX.Element | null;

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

@@ -0,0 +1,85 @@
+import type { IMenuItem, IValueOption } from '@univerjs/ui';
+import type { ButtonHTMLAttributes, HTMLAttributes, ReactNode } from 'react';
+import type { LocaleKey } from '../../locale/types';
+export declare const FloatingToolbarTrigger: import("react").ForwardRefExoticComponent<ButtonHTMLAttributes<HTMLButtonElement> & {
+    children: ReactNode;
+    title: string;
+} & import("react").RefAttributes<HTMLButtonElement>>;
+export declare const FloatingToolbarSplitTrigger: import("react").ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
+    title: string;
+    primary: ReactNode;
+    disabled?: boolean;
+    open?: boolean;
+    onPrimaryClick: () => void;
+} & import("react").RefAttributes<HTMLDivElement>>;
+export declare function MenuButton(props: {
+    children: ReactNode;
+    title: string;
+    className?: string;
+    disabled?: boolean;
+    active?: boolean;
+    onClick: () => void;
+}): import("react").JSX.Element;
+export declare function MenuButtonFromMenu(props: {
+    item: IMenuItem | undefined;
+    children: ReactNode;
+    title: LocaleKey;
+    onClick: () => void;
+}): import("react").JSX.Element | null;
+export declare function useMenuItemRuntimeState(item: IMenuItem | undefined): {
+    hidden: boolean;
+    disabled: boolean;
+    activated: boolean;
+    value: unknown;
+};
+export declare function getMenuTitle(item: IMenuItem): string;
+export declare function getOptionLabel(option: IValueOption): string;
+export declare function getWrapIcon(value: IValueOption['value']): ReactNode;
+export declare function keepFloatingPanelInteraction(event: React.MouseEvent<HTMLElement> | React.PointerEvent<HTMLElement>): void;
+export declare function isFloatingDropdownOwnSurfaceTarget(target: EventTarget | null, embedId: string): boolean;
+export declare function keepFloatingDropdownOpenForOwnSurface(event: {
+    target: EventTarget | null;
+    preventDefault: () => void;
+}, embedId: string): void;
+export declare function Panel(props: {
+    embedId: string;
+    children: ReactNode;
+    onPointerDown: (event: React.PointerEvent<HTMLElement>) => void;
+}): import("react").JSX.Element;
+export declare function PanelRow(props: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function InlineFloatingDropdown(props: {
+    embedId: string;
+    title: LocaleKey;
+    trigger: ReactNode;
+    overlay: ReactNode;
+    disabled?: boolean;
+    triggerClassName?: string;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+}): import("react").JSX.Element;
+export declare function MenuPanel(props: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function RibbonListPanel(props: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function RibbonListItem(props: {
+    children: ReactNode;
+    icon: ReactNode;
+    onClick: () => void;
+}): import("react").JSX.Element;
+export declare function MenuPanelItem(props: {
+    children: ReactNode;
+    icon?: ReactNode;
+    active?: boolean;
+    onClick: () => void;
+}): import("react").JSX.Element;
+export declare function PanelButton(props: {
+    title: string;
+    active?: boolean;
+    disabled?: boolean;
+    children: ReactNode;
+    onClick: () => void;
+}): import("react").JSX.Element;

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

@@ -1,2 +1,4 @@
 import type { IEmbedContentSizeProvider } from '../../types/embed-ui';
+export declare const DEFAULT_SHEET_COLUMN_HEADER_HEIGHT = 24;
 export declare function createSheetsContentSizeProvider(): IEmbedContentSizeProvider;
+export declare function resolveSheetsStickyHeaderHeight(childUnit: unknown): number;

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

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

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

@@ -1,5 +1,5 @@
+import type { Injector } from '@univerjs/core';
 import { EmbedModelService } from '@univerjs-pro/embed';
-import { type Injector } from '@univerjs/core';
 import { ISheetEmbedRuntimeService } from '@univerjs/sheets-ui';
 import { CanvasFloatDomPreviewService } from '@univerjs/ui';
 import { Subscription } from 'rxjs';

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

@@ -1,7 +1,7 @@
 import type { EmbedDisplayTarget } from '@univerjs-pro/embed';
 import type { SlideModel } from '@univerjs-pro/slides';
+import type { ICommandService } from '@univerjs/core';
 import type { IEmbedChildContainerContext, IEmbedChildViewContribution } from '../../types/embed-ui';
-import { type ICommandService } from '@univerjs/core';
 export declare function createSlidesEmbedChildViewContribution(commandService: ICommandService): IEmbedChildViewContribution;
 export declare function applySlideDisplayTarget(slide: SlideModel, target: EmbedDisplayTarget | undefined): void;
 export declare function shouldUseSlideEmbedFloatingPreview(context: Pick<IEmbedChildContainerContext, 'layout' | 'renderScope'>): boolean;

package/lib/types/services/embed-display-target-sync.d.ts

@@ -1,6 +1,4 @@
+import type { EmbedDisplayTarget } from '@univerjs-pro/embed';
+import type { ICommandService, IDisposable } from '@univerjs/core';
 import type { IEmbedChildContainerContext } from '../types/embed-ui';
-import { type EmbedDisplayTarget } from '@univerjs-pro/embed';
-import { type ICommandService, type IDisposable } from '@univerjs/core';
-type ApplyEmbedDisplayTarget = (target: EmbedDisplayTarget | undefined) => void;
-export declare function registerEmbedDisplayTargetSync(context: Pick<IEmbedChildContainerContext, 'descriptor' | 'embedId' | 'hostUnitId'>, commandService: ICommandService, applyTarget: ApplyEmbedDisplayTarget): IDisposable;
-export {};
+export declare function registerEmbedDisplayTargetSync(context: Pick<IEmbedChildContainerContext, 'descriptor' | 'embedId' | 'hostUnitId'>, commandService: ICommandService, applyTarget: (target: EmbedDisplayTarget | undefined) => void): IDisposable;

package/lib/types/services/embed-dom-wheel.d.ts

@@ -0,0 +1,40 @@
+import type { IDisposable } from '@univerjs/core';
+import type { IEmbedChildContainerContext } from '../types/embed-ui';
+import type { EmbedHostWheelGestureService } from './embed-host-wheel-gesture.service';
+import type { EmbedPassiveViewportRegistryService } from './embed-passive-viewport-registry.service';
+import type { EmbedPassiveWheelHandlerRegistryService } from './embed-passive-wheel-handler-registry.service';
+export declare function registerEmbedDomWheelRouting(options: {
+    container: HTMLElement;
+    gate: HTMLElement;
+    getChildContext: () => IEmbedChildContainerContext | undefined;
+    getStage: () => 'inactive' | 'stage1' | 'stage2';
+    hostScrollOffset: {
+        current: number;
+    };
+    hostWheelGestureService: EmbedHostWheelGestureService;
+    invalidate: (reason: 'child-scroll' | 'host-scroll' | 'wheel') => void;
+    liveRoot: HTMLElement;
+    onHostWheel?: (event: WheelEvent, context: IEmbedChildContainerContext) => boolean | void;
+    passiveViewportRegistry: EmbedPassiveViewportRegistryService;
+    passiveWheelHandlerRegistry: EmbedPassiveWheelHandlerRegistryService;
+    resizeDocsSheetLikeRendererByWheel?: (event: WheelEvent) => boolean;
+    routeHostGestures: boolean;
+    syncHostVerticalScroll?: boolean;
+    viewScale?: number;
+}): IDisposable;
+export declare function createEmbedWheelEventForViewScale(event: WheelEvent, viewScale: number | undefined): WheelEvent;
+export declare function createForwardedEmbedWheelEvent(source: WheelEvent, init: WheelEventInit): WheelEvent;
+export declare function isEmbedForwardedWheelEvent(event: Event | undefined): boolean;
+export declare function markHostVerticalWheelAttempted(event: WheelEvent): void;
+export declare function isHostVerticalWheelAttempted(event: WheelEvent): boolean;
+export declare function forwardWheelToEmbedRuntime(event: WheelEvent, liveRoot: HTMLElement): boolean;
+export declare function scrollEmbedRuntimeDom(event: WheelEvent, liveRoot: HTMLElement): boolean;
+export declare function scrollEmbedRuntimeDomElement(event: WheelEvent, element: HTMLElement): boolean;
+export declare function scrollHostScrollPortByWheel(container: HTMLElement, event: WheelEvent): boolean;
+export declare function findNearestEmbedScrollPort(element: HTMLElement): HTMLElement | null;
+export declare function clipsEmbedOverflow(element: HTMLElement): boolean;
+export declare function shouldPassVerticalWheelToHost(context: IEmbedChildContainerContext, event: WheelEvent, syncHostVerticalScroll?: boolean): boolean;
+export declare function shouldUseRuntimeDomHorizontalScroll(container: HTMLElement, event: WheelEvent): boolean;
+export declare function getHorizontalWheelDelta(event: WheelEvent): number;
+export declare function scrollDocsSheetLikeHorizontalWheel(deltaX: number, resizeRenderer: () => boolean, scrollChild: () => boolean): boolean;
+export declare function shouldRouteUnhandledWheelToHost(event: WheelEvent): boolean;

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

@@ -0,0 +1,26 @@
+import type { EmbedLayout, IEmbedDescriptor } from '@univerjs-pro/embed';
+import type { IDisposable, Injector } from '@univerjs/core';
+import type { IEmbedChildContainerContext, IEmbedRenderScope } from '../types/embed-ui';
+export declare function createFullscreenRenderScope(descriptor: IEmbedDescriptor, layout: EmbedLayout, roots: {
+    viewport: HTMLElement;
+    menuSlot: HTMLElement;
+    popupSlot?: HTMLElement;
+    footerSlot: HTMLElement;
+}): IEmbedRenderScope;
+export declare function registerFullscreenRuntimeOwnership(params: {
+    injector: Injector;
+    descriptor: IEmbedDescriptor;
+    renderScope: IEmbedRenderScope;
+    menuRoot: HTMLElement | null;
+    menuSlot: HTMLElement;
+    popupSlot: HTMLElement;
+    sidebarSlot: HTMLElement;
+    rightSidebarSlot: HTMLElement;
+    footerSlot: HTMLElement;
+}): IDisposable;
+export declare function mountFullscreenWorkbenchMenus(params: {
+    injector: Injector;
+    descriptor: IEmbedDescriptor;
+    childContext: IEmbedChildContainerContext;
+    menuContainer: HTMLElement;
+}): IDisposable | undefined;

package/lib/types/types/embed-ui.d.ts

@@ -179,7 +179,9 @@ export interface IEmbedPassiveViewportWheelContext extends IEmbedChildContainerC
 export interface IEmbedPassiveViewportProvider {
     childType: UniverInstanceType;
     supportedLayouts?: EmbedLayout[];
+    getStickyHeaderHeight?: (context: IEmbedChildContainerContext) => number | undefined;
     handleWheel: (context: IEmbedPassiveViewportWheelContext) => boolean | void;
+    subscribeVerticalScroll?: (context: IEmbedChildContainerContext, listener: (viewportScrollY: number) => void) => IDisposable | void;
 }
 export interface IEmbedPassiveWheelHandlerContribution {
     childType: UniverInstanceType;