@univerjs-pro/shape-editor-ui 1.0.0-alpha.6 → 1.0.0-alpha.8

package/lib/types/services/formula-binding-unit-viewer.service.d.ts

@@ -0,0 +1,67 @@
+import type { BaseDataModel } from '@univerjs/core';
+import type { FormulaSequenceNode, IFormulaRefSelection } from '@univerjs/engine-formula';
+import type { IFormulaBindingHost, IFormulaBindingUnitResource } from '../config/config';
+import type { IFormulaBindingReferenceSelectionChange } from './formula-binding-editor';
+import { Disposable, IConfigService, IUniverInstanceService, LocaleService, ThemeService, Workbook } from '@univerjs/core';
+export type FormulaBindingViewerUnit = Workbook | BaseDataModel;
+export interface IFormulaBindingViewerFormulaContext {
+    formula: string;
+    sequenceNodes: FormulaSequenceNode[];
+    refSelections: IFormulaRefSelection[];
+    selectionStart: number;
+    selectionEnd: number;
+}
+/** Owns the real, isolated Univer rendered inside the cross-unit formula editor. */
+export declare class FormulaBindingUnitViewerService extends Disposable {
+    private readonly _configService;
+    private readonly _instanceService;
+    private readonly _localeService;
+    private readonly _themeService;
+    private _univer;
+    private _activeUnitId;
+    private _container;
+    private _generation;
+    private _selectionDisposables;
+    private _formulaContext;
+    private _host;
+    private _resource;
+    private _onSelectReferences;
+    private _activeWorkbook;
+    private _activeBase;
+    private _visibleReferenceIndexes;
+    private _isApplyingBaseHighlight;
+    private _pointerCtrlKey;
+    private _pointerListener;
+    private _selectionChangingDisposable;
+    private _controlDisposables;
+    private _isDraggingFormulaSelection;
+    private _closeRequest;
+    constructor(_configService: IConfigService, _instanceService: IUniverInstanceService, _localeService: LocaleService, _themeService: ThemeService);
+    listUnits(): Promise<IFormulaBindingUnitResource[]>;
+    mount(container: HTMLElement): void;
+    switchUnit(resource: IFormulaBindingUnitResource, host: IFormulaBindingHost, onSelectReferences: (change: IFormulaBindingReferenceSelectionChange) => void): Promise<FormulaBindingViewerUnit | null>;
+    private _makeBaseSnapshotReadOnly;
+    private _setBasePermissionsReadOnly;
+    updateFormulaContext(context: IFormulaBindingViewerFormulaContext): void;
+    close(): void;
+    /** Defers nested Univer disposal until the owning React tree has finished unmounting. */
+    scheduleClose(): void;
+    private _closeNow;
+    dispose(): void;
+    private _createUniver;
+    private _observeSheetSelection;
+    private _observeBaseSelection;
+    private _handleBaseSelectionChange;
+    private _getBaseReferenceSource;
+    private _emitSheetSelectionChange;
+    private _refreshFormulaSelections;
+    private _refreshSheetFormulaSelections;
+    private _refreshBaseFormulaSelection;
+    private _bindFormulaSelectionControls;
+    private _getEditingContext;
+    private _canSelectFormulaReference;
+    private _matchesSheetReference;
+    private _matchesUnitQualifier;
+    private _createExternalReference;
+    private _listLoadedUnits;
+}

package/lib/types/utils/activate-drawing-object.d.ts

@@ -14,7 +14,7 @@ interface ISceneLike {
     };
 }
 interface IRenderManagerLike {
-    getRenderById: (unitId: string) => {
+    getRenderUnitById: (unitId: string) => {
         scene?: ISceneLike;
     } | undefined;
 }

package/lib/types/views/FormulaBindingEditorDialog.d.ts

@@ -0,0 +1,11 @@
+import type { ReactNode } from 'react';
+import type { IFormulaBindingEditorResult, IFormulaBindingEditorValue, IFormulaBindingHost } from '../config/config';
+export interface IFormulaBindingEditorDialogProps {
+    open: boolean;
+    host: IFormulaBindingHost;
+    value: IFormulaBindingEditorValue;
+    footerLeading?: ReactNode;
+    onClose: () => void;
+    onConfirm: (result: IFormulaBindingEditorResult) => void;
+}
+export declare function FormulaBindingEditorDialog(props: IFormulaBindingEditorDialogProps): import("react").JSX.Element;

package/lib/types/views/FormulaBindingNumberFormat.d.ts

@@ -0,0 +1,23 @@
+export type FormulaBindingNumberFormatType = 'general' | 'accounting' | 'currency' | 'date' | 'number' | 'custom';
+export type FormulaBindingNumberFormatMenuEntry = {
+    kind: 'format';
+    key: string;
+    pattern: string;
+} | {
+    kind: 'separator';
+    key: string;
+} | {
+    kind: 'more';
+};
+export declare function createFormulaBindingNumberFormatMenuEntries(currencySymbol: string): FormulaBindingNumberFormatMenuEntry[];
+export declare function resolveFormulaBindingNumberFormatType(pattern: string): FormulaBindingNumberFormatType;
+export declare function FormulaBindingNumberFormatMenu(props: {
+    onSelect: (pattern: string) => void;
+    onMore: () => void;
+}): import("react").JSX.Element;
+export declare function FormulaBindingNumberFormatDialog(props: {
+    open: boolean;
+    pattern: string;
+    onClose: () => void;
+    onConfirm: (pattern: string) => void;
+}): import("react").JSX.Element;

package/lib/types/views/formula-binding-number-format-utils.d.ts

@@ -0,0 +1,17 @@
+export declare function getFormulaBindingCurrencyType(pattern: string): string | undefined;
+export declare function getFormulaBindingDecimalFromPattern(pattern: string, defaultValue?: number): number;
+export declare function setFormulaBindingPatternDecimal(patterns: string, decimalLength: number): string;
+export declare function getFormulaBindingCurrencyFormatOptions(symbol: string): {
+    label: string;
+    value: string;
+    color: string | undefined;
+}[];
+export declare function getFormulaBindingDateFormatOptions(): {
+    label: string;
+    value: string;
+}[];
+export declare function getFormulaBindingNumberFormatOptions(): {
+    label: string;
+    value: string;
+    color: string | undefined;
+}[];

package/lib/types/views/formula-shape/UseFormulaShapeToolbar.d.ts

@@ -0,0 +1,13 @@
+import type { IShapeData, IShapeFormulaBinding } from '@univerjs-pro/engine-shape';
+import type { IShapeFormulaIdentity } from '@univerjs-pro/shape-editor';
+import type { ReactNode } from 'react';
+import type { IShapeFloatingToolbarExtensionGroup } from '../shape-floating-toolbar/ShapeFloatingToolbar';
+interface IUseFormulaShapeToolbarOptions extends IShapeFormulaIdentity {
+    shapeData?: IShapeData;
+    onUpdateBinding: (binding: IShapeFormulaBinding) => void;
+}
+export declare function useFormulaShapeToolbar(options: IUseFormulaShapeToolbarOptions): {
+    extensionGroups?: IShapeFloatingToolbarExtensionGroup[];
+    panel: ReactNode;
+};
+export {};

package/lib/types/views/formula-shape/formula-shape-animation.d.ts

@@ -0,0 +1,33 @@
+import type { IShapeFormulaPresentation } from '@univerjs-pro/shape-editor';
+import type { UniverRenderingContext } from '@univerjs/engine-render';
+export declare const FORMULA_SHAPE_ANIMATION_DURATION = 360;
+export declare const FORMULA_SHAPE_TEXT_FLOAT_DISTANCE = 8;
+export interface IFormulaShapeAnimationLayer {
+    key: 'current' | 'previous';
+    offsetY: number;
+    opacity: number;
+    presentation: IShapeFormulaPresentation | undefined;
+}
+export declare function resolveFormulaShapeAnimationLayers(previous: IShapeFormulaPresentation | undefined, current: IShapeFormulaPresentation | undefined, progress: number): IFormulaShapeAnimationLayer[];
+export declare class FormulaShapeAnimationController {
+    private readonly _makeDirty;
+    private readonly _onAnimationCompleted;
+    private _current;
+    private _previous;
+    private _lastResolved;
+    private _progress;
+    private _startedAt;
+    private _frameId;
+    constructor(_makeDirty: () => void, _onAnimationCompleted?: () => void);
+    setPresentation(presentation: IShapeFormulaPresentation | undefined, animate?: boolean): void;
+    getLayers(): IFormulaShapeAnimationLayer[];
+    /**
+     * Returns the resolved presentations whose text must fit inside the shape while an animation is active.
+     * Keeping both endpoints prevents either the outgoing or incoming value from overflowing the transformer.
+     */
+    getAutoFitPresentations(): IShapeFormulaPresentation[];
+    dispose(): void;
+    private readonly _tick;
+    private _cancelFrame;
+}
+export declare function drawFormulaShapeAnimationLayers(ctx: UniverRenderingContext, controller: FormulaShapeAnimationController, draw: (ctx: UniverRenderingContext, presentation: IShapeFormulaPresentation | undefined, layerKey: IFormulaShapeAnimationLayer['key']) => void): void;

package/lib/types/views/formula-shape/formula-shape-auto-fit.d.ts

@@ -0,0 +1,15 @@
+import type { IShapeData, IShapeRect } from '@univerjs-pro/engine-shape';
+import type { IDocumentData } from '@univerjs/core';
+export interface IFormulaShapeAutoFitSize {
+    width: number;
+    height: number;
+}
+/** Resolves the runtime size implied by the standard OOXML shape-text auto-fit properties. */
+export declare function resolveFormulaShapeAutoFitSize(options: {
+    documentData: IDocumentData | readonly IDocumentData[];
+    height: number;
+    shapeData: IShapeData;
+    textRect: IShapeRect;
+    width: number;
+    widthBuffer?: number;
+}): IFormulaShapeAutoFitSize | null;

package/lib/types/views/shape-floating-toolbar/ShapeFloatingToolbar.d.ts

@@ -59,18 +59,20 @@ export interface IShapeFloatingToolbarProps {
     enableShapeStrokeReset?: boolean;
     enableTextBackgroundReset?: boolean;
     enableTextControls?: boolean;
-    deferUntilCollapsedStateLoaded?: boolean;
     defaultFillColor?: string;
     defaultGradientEndColor?: string;
     defaultStrokeColor?: string;
     onUpdateShapeData: (oldShapeJSON: {
         oldShapeData?: IShapeData;
-    }, shapeData?: IShapeData) => void;
+    }, shapeData?: IShapeData, patch?: IShapeData) => void;
     onUpdateText: (params: IShapeTextUpdateOptions) => void;
     onUpdateWrappingStyle?: (value: IShapeFloatingToolbarWrappingStyle) => void;
     groupAction?: IShapeFloatingToolbarGroupAction;
     layerActions?: IShapeFloatingToolbarLayerActions;
     extensionGroups?: IShapeFloatingToolbarExtensionGroup[];
+    collapseLabel?: string;
+    expandLabel?: string;
+    deleteLabel?: string;
     onOpenPanel?: () => void;
     onDelete?: () => void;
 }
@@ -82,17 +84,16 @@ export declare function ShapeFloatingToolbarContent(props: {
     children: ReactNode;
     className?: string;
     maxWidthClassName?: string;
-    dataAttributes?: Record<`data-${string}`, string>;
     onMouseDown?: (event: MouseEvent<HTMLDivElement>) => void;
 }): import("react").JSX.Element;
 export declare function ShapeFloatingToolbarButton(props: {
     title?: string;
-    titleKey?: string;
     active?: boolean;
     disabled?: boolean;
     children: ReactNode;
     className?: string;
     sizeClassName?: string;
+    tooltipVisible?: boolean;
     ariaExpanded?: boolean;
     onClick?: () => void;
     onMouseDown?: (event: MouseEvent<HTMLButtonElement>) => void;
@@ -100,7 +101,6 @@ export declare function ShapeFloatingToolbarButton(props: {
 }): import("react").JSX.Element;
 export declare function ShapeFloatingToolbarDropdownTrigger(props: {
     title?: string;
-    titleKey?: string;
     icon: ReactNode;
     active?: boolean;
     className?: string;
@@ -115,11 +115,15 @@ export declare function ShapeFloatingToolbarFontSizeSelect(props: {
     onAfterChange?: () => void;
 }): import("react").JSX.Element;
 export type ShapeStrokePanelMode = 'none' | 'solid' | 'dash' | 'dot';
+export declare function buildShapeStrokeDataUpdate(currentStroke: IShapeData['stroke'], resolvedStroke: NonNullable<IShapeData['stroke']>, partial: Partial<NonNullable<IShapeData['stroke']>>): {
+    nextShapeData: IShapeData;
+    patch: IShapeData;
+};
 export interface IShapeStrokePanelContentProps {
-    titleKey: string;
+    title: string;
     shapeData: IShapeData;
     disabled?: boolean;
-    resetLabelKey?: string;
+    resetLabel?: string;
     modeOptions?: ShapeStrokePanelMode[];
     showDashDropdown?: boolean;
     fallbackColor?: string;
@@ -134,37 +138,42 @@ export interface IShapeStrokePanelContentProps {
 }
 export declare function ShapeStrokePanelContent(props: IShapeStrokePanelContentProps): import("react").JSX.Element;
 export declare function ShapeStrokePanelButton(props: {
-    titleKey: string;
+    title: string;
     shapeData: IShapeData;
+    open?: boolean;
     disabled?: boolean;
-    resetLabelKey?: string;
+    resetLabel?: string;
     fallbackColor?: string;
     onReset?: () => void;
+    onOpenChange?: (open: boolean) => void;
     onUpdateShapeData: IShapeFloatingToolbarProps['onUpdateShapeData'];
 }): import("react").JSX.Element;
 export declare function ShapeFillButton(props: {
-    titleKey: string;
+    title: string;
     shapeData: IShapeData;
+    open?: boolean;
     disabled?: boolean;
     fallbackColor?: string;
     fallbackGradientEndColor?: string;
+    onOpenChange?: (open: boolean) => void;
     onUpdateShapeData: IShapeFloatingToolbarProps['onUpdateShapeData'];
 }): import("react").JSX.Element;
 export declare function TextFillButton(props: {
-    titleKey: string;
+    title: string;
     textStyle: ITextStyle;
     fallbackColor: string;
     onChange: (textStyle: ITextStyle) => void;
 }): import("react").JSX.Element;
 export declare function TextBackgroundColorButton(props: {
-    titleKey: string;
+    title: string;
     color: string;
     onApply: () => void;
     onReset?: () => void;
     onChange: (color: string) => void;
 }): import("react").JSX.Element;
 export declare function TypographyPanelButton(props: {
-    titleKey: string;
+    title: string;
+    fontFamily: string;
     textStyle: {
         isBold: boolean;
         isItalic: boolean;
@@ -179,7 +188,6 @@ export declare function TypographyPanelButton(props: {
 }): import("react").JSX.Element;
 export declare function ShapeFloatingToolbarMenuPanel(props: {
     title?: string;
-    titleKey?: string;
     children: ReactNode;
     className?: string;
     minWidthClassName?: string;
@@ -189,6 +197,7 @@ export declare function ShapeFloatingToolbarMenuItem(props: {
     labelKey?: string;
     shortcut?: string;
     disabled?: boolean;
+    danger?: boolean;
     onClick: () => void;
 }): import("react").JSX.Element;
 export declare function ShapeFloatingToolbar(props: IShapeFloatingToolbarProps): import("react").JSX.Element | null;

package/lib/types/views/shape-text-editor/ShapeTextPositionWrapper.d.ts

@@ -46,7 +46,7 @@ export declare function isShapeTextEditorPointerInsideContent(target: EventTarge
 export declare function resolveShapeTextEditorPositionTransform(options: {
     editingParams: Nullable<IShapeTextEditingParams>;
     positionOptions: IShapeTextEditorPositionOptions;
-    renderUnit: Nullable<ReturnType<IRenderManagerService['getRenderById']>>;
+    renderUnit: Nullable<ReturnType<IRenderManagerService['getRenderUnitById']>>;
     scene: Nullable<Scene>;
 }): Nullable<IShapeObjectLike>;
 /**

package/lib/types/views/shape-text-editor/shape-text-behavior.d.ts

@@ -1,8 +1,5 @@
 import type { IShapeData, IShapeTextData } from '@univerjs-pro/engine-shape';
 import type { Nullable, WrapStrategy as WrapStrategyType } from '@univerjs/core';
-export declare function createShapeTextBoxShapeData(options: Pick<IShapeData, 'fill' | 'stroke'> & {
-    isHorizontal: boolean;
-}): IShapeData;
 export declare function resolveShapeTextEditorBehaviorShapeData(shapeData: Nullable<IShapeData> | undefined, shapeTextData: IShapeTextData): IShapeData;
 export declare function resolveShapeTextEditorWrapStrategy(shapeData: IShapeData, fallbackWrapStrategy?: WrapStrategyType): WrapStrategyType;
 export declare function shouldClipShapeTextDocument(shapeData: IShapeData, wrapStrategy?: WrapStrategyType): boolean;

package/lib/types/views/shape-text-editor/shape-text-placeholder.d.ts

@@ -4,5 +4,6 @@ export declare function createShapeTextPlaceholderDocumentData(options: {
     documentData?: IDocumentData;
     isTextBox: boolean;
     placeholder: string;
+    showPlaceholder?: boolean;
     text?: string;
 }): IDocumentData | undefined;