fika-editor 3.0.0 → 3.0.2

package/dist/types/views/Editor/Canvas/ElementFloatLayer/index.d.ts

@@ -0,0 +1,12 @@
+import { type PPTElement } from '../../../../types/slides';
+import type useViewportSize from '../hooks/useViewportSize';
+export type IElementFloatLayerProps = {
+    elementList: PPTElement[];
+    canvasRef: HTMLElement | {
+        current?: HTMLElement | null;
+    } | null;
+    viewportStyles: ReturnType<typeof useViewportSize>['viewportStyles'];
+    openLinkDialog: () => void;
+};
+declare const ElementFloatLayer: import("react").MemoExoticComponent<(props: IElementFloatLayerProps) => import("react").JSX.Element>;
+export default ElementFloatLayer;

package/dist/types/views/Editor/Canvas/GridLines.d.ts

@@ -0,0 +1,6 @@
+export type IGridLinesProps = {
+    size?: number;
+    ephemeral?: boolean;
+};
+declare const GridLines: import("react").MemoExoticComponent<({ size, ephemeral }: IGridLinesProps) => import("react").JSX.Element>;
+export default GridLines;

package/dist/types/views/Editor/Canvas/HitLayer.d.ts

@@ -0,0 +1,19 @@
+import type { PPTElement } from '../../../types/slides';
+export type IHitLayerProps = {
+    elementList: PPTElement[];
+    canvasScale: number;
+    hiddenElementIdList: string[];
+    activeElementIdList: string[];
+    editingElementId: string | null;
+    clipingImageElementId: string;
+    disabled: boolean;
+    selectElement: (e: MouseEvent | TouchEvent, element: PPTElement, canMove?: boolean, andEdit?: boolean) => void;
+    beginEdit: (elementId: string, caret?: {
+        left: number;
+        top: number;
+    }) => void;
+    openLinkDialog: () => void;
+    className?: string;
+};
+declare const HitLayer: import("react").MemoExoticComponent<(props: IHitLayerProps) => import("react").JSX.Element>;
+export default HitLayer;

package/dist/types/views/Editor/Canvas/LinkDialog.d.ts

@@ -0,0 +1,5 @@
+export type ILinkDialogProps = {
+    onClose?: () => void;
+};
+declare const LinkDialog: import("react").MemoExoticComponent<(props: ILinkDialogProps) => import("react").JSX.Element>;
+export default LinkDialog;

package/dist/types/views/Editor/Canvas/MouseSelection.d.ts

@@ -0,0 +1,8 @@
+export type IMouseSelectionProps = {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+};
+declare const MouseSelection: import("react").MemoExoticComponent<(props: IMouseSelectionProps) => import("react").JSX.Element>;
+export default MouseSelection;

package/dist/types/views/Editor/Canvas/Operate/BorderLine.d.ts

@@ -0,0 +1,11 @@
+import { type CSSProperties, type MouseEvent as ReactMouseEvent } from 'react';
+import type { OperateBorderLines } from '../../../../types/edit';
+export type IBorderLineProps = {
+    type: OperateBorderLines;
+    isWide?: boolean;
+    className?: string;
+    style?: CSSProperties;
+    onMouseDown?: (e: ReactMouseEvent<HTMLDivElement>) => void;
+};
+declare const BorderLine: import("react").MemoExoticComponent<({ type, isWide, className, style, onMouseDown }: IBorderLineProps) => import("react").JSX.Element>;
+export default BorderLine;

package/dist/types/views/Editor/Canvas/Operate/CommonElementOperate.d.ts

@@ -0,0 +1,11 @@
+import type { PPTVideoElement, PPTLatexElement, PPTAudioElement, PPTChartElement } from '../../../../types/slides';
+import type { OperateResizeHandlers } from '../../../../types/edit';
+type PPTElement = PPTVideoElement | PPTLatexElement | PPTAudioElement | PPTChartElement;
+export type ICommonElementOperateProps = {
+    elementInfo: PPTElement;
+    handlerVisible: boolean;
+    rotateElement: (e: MouseEvent, element: PPTElement) => void;
+    scaleElement: (e: MouseEvent, element: PPTElement, command: OperateResizeHandlers) => void;
+};
+declare const CommonElementOperate: import("react").MemoExoticComponent<(props: ICommonElementOperateProps) => import("react").JSX.Element>;
+export default CommonElementOperate;

package/dist/types/views/Editor/Canvas/Operate/ContextMenuBridge.d.ts

@@ -0,0 +1,9 @@
+import type { MutableRefObject } from 'react';
+import type { PPTElement } from '../../../../types/slides';
+import type { ContextmenuItem } from '../../../../components/Contextmenu/types';
+export type ElementContextmenus = (element: PPTElement, isMultiSelect: boolean) => ContextmenuItem[] | null;
+/** Isolates context-menu store subscriptions so operate chrome does not rerender on keystroke. */
+export default function ContextMenuBridge({ openLinkDialog, menuRef, }: {
+    openLinkDialog: () => void;
+    menuRef: MutableRefObject<ElementContextmenus | null>;
+}): any;

package/dist/types/views/Editor/Canvas/Operate/ImageElementOperate.d.ts

@@ -0,0 +1,10 @@
+import type { PPTImageElement } from '../../../../types/slides';
+import type { OperateResizeHandlers } from '../../../../types/edit';
+export type IImageElementOperateProps = {
+    elementInfo: PPTImageElement;
+    handlerVisible: boolean;
+    rotateElement: (e: MouseEvent, element: PPTImageElement) => void;
+    scaleElement: (e: MouseEvent, element: PPTImageElement, command: OperateResizeHandlers) => void;
+};
+declare const ImageElementOperate: import("react").MemoExoticComponent<(props: IImageElementOperateProps) => import("react").JSX.Element>;
+export default ImageElementOperate;

package/dist/types/views/Editor/Canvas/Operate/LineElementOperate.d.ts

@@ -0,0 +1,9 @@
+import type { PPTLineElement } from '../../../../types/slides';
+import { OperateLineHandlers } from '../../../../types/edit';
+export type ILineElementOperateProps = {
+    elementInfo: PPTLineElement;
+    handlerVisible: boolean;
+    dragLineElement: (e: MouseEvent, element: PPTLineElement, command: OperateLineHandlers) => void;
+};
+declare const LineElementOperate: import("react").MemoExoticComponent<(props: ILineElementOperateProps) => import("react").JSX.Element>;
+export default LineElementOperate;

package/dist/types/views/Editor/Canvas/Operate/MediaElementOperate.d.ts

@@ -0,0 +1,11 @@
+import type { PPTAudioElement, PPTVideoElement } from '../../../../types/slides';
+import type { OperateResizeHandlers } from '../../../../types/edit';
+type MediaElement = PPTVideoElement | PPTAudioElement;
+export type IMediaElementOperateProps = {
+    elementInfo: MediaElement;
+    handlerVisible: boolean;
+    rotateElement: (e: MouseEvent, element: MediaElement) => void;
+    scaleElement: (e: MouseEvent, element: MediaElement, command: OperateResizeHandlers) => void;
+};
+declare const MediaElementOperate: import("react").MemoExoticComponent<(props: IMediaElementOperateProps) => import("react").JSX.Element>;
+export default MediaElementOperate;

package/dist/types/views/Editor/Canvas/Operate/MultiSelectOperate.d.ts

@@ -0,0 +1,11 @@
+import type { PPTElement } from '../../../../types/slides';
+import type { OperateResizeHandlers, MultiSelectRange } from '../../../../types/edit';
+export type IMultiSelectOperateProps = {
+    elementList: PPTElement[];
+    scaleMultiElement: (e: MouseEvent, range: MultiSelectRange, command: OperateResizeHandlers) => void;
+    rotateGroupElement: (e: MouseEvent, elements: PPTElement[]) => void;
+    dragElement: (e: MouseEvent | TouchEvent, element: PPTElement) => void;
+    openLinkDialog: () => void;
+};
+declare const MultiSelectOperate: import("react").MemoExoticComponent<(props: IMultiSelectOperateProps) => import("react").JSX.Element>;
+export default MultiSelectOperate;

package/dist/types/views/Editor/Canvas/Operate/ResizeHandler.d.ts

@@ -0,0 +1,12 @@
+import { type CSSProperties, type MouseEvent as ReactMouseEvent } from 'react';
+import type { OperateResizeHandlers } from '../../../../types/edit';
+export type IResizeHandlerProps = {
+    type?: OperateResizeHandlers;
+    rotate?: number;
+    className?: string;
+    style?: CSSProperties;
+    'data-line-handle'?: string;
+    onMouseDown?: (e: ReactMouseEvent<HTMLDivElement>) => void;
+};
+declare const ResizeHandler: import("react").MemoExoticComponent<({ type, rotate, className, style, onMouseDown, 'data-line-handle': lineHandle }: IResizeHandlerProps) => import("react").JSX.Element>;
+export default ResizeHandler;

package/dist/types/views/Editor/Canvas/Operate/RotateHandler.d.ts

@@ -0,0 +1,8 @@
+import { type CSSProperties, type MouseEvent as ReactMouseEvent } from 'react';
+export type IRotateHandlerProps = {
+    className?: string;
+    style?: CSSProperties;
+    onMouseDown?: (e: ReactMouseEvent<HTMLDivElement>) => void;
+};
+declare const RotateHandler: import("react").NamedExoticComponent<IRotateHandlerProps>;
+export default RotateHandler;

package/dist/types/views/Editor/Canvas/Operate/ShapeElementOperate.d.ts

@@ -0,0 +1,11 @@
+import type { PPTShapeElement } from '../../../../types/slides';
+import type { OperateResizeHandlers } from '../../../../types/edit';
+export type IShapeElementOperateProps = {
+    elementInfo: PPTShapeElement;
+    handlerVisible: boolean;
+    rotateElement: (e: MouseEvent, element: PPTShapeElement) => void;
+    scaleElement: (e: MouseEvent, element: PPTShapeElement, command: OperateResizeHandlers) => void;
+    moveShapeKeypoint: (e: MouseEvent, element: PPTShapeElement, index: number) => void;
+};
+declare const ShapeElementOperate: import("react").MemoExoticComponent<(props: IShapeElementOperateProps) => import("react").JSX.Element>;
+export default ShapeElementOperate;

package/dist/types/views/Editor/Canvas/Operate/TableElementOperate.d.ts

@@ -0,0 +1,10 @@
+import type { PPTTableElement } from '../../../../types/slides';
+import type { OperateResizeHandlers } from '../../../../types/edit';
+export type ITableElementOperateProps = {
+    elementInfo: PPTTableElement;
+    handlerVisible: boolean;
+    rotateElement: (e: MouseEvent, element: PPTTableElement) => void;
+    scaleElement: (e: MouseEvent, element: PPTTableElement, command: OperateResizeHandlers) => void;
+};
+declare const TableElementOperate: import("react").MemoExoticComponent<(props: ITableElementOperateProps) => import("react").JSX.Element>;
+export default TableElementOperate;

package/dist/types/views/Editor/Canvas/Operate/TextElementOperate.d.ts

@@ -0,0 +1,10 @@
+import type { PPTTextElement } from '../../../../types/slides';
+import type { OperateResizeHandlers } from '../../../../types/edit';
+export type ITextElementOperateProps = {
+    elementInfo: PPTTextElement;
+    handlerVisible: boolean;
+    rotateElement: (e: MouseEvent, element: PPTTextElement) => void;
+    scaleElement: (e: MouseEvent, element: PPTTextElement, command: OperateResizeHandlers) => void;
+};
+declare const TextElementOperate: import("react").MemoExoticComponent<(props: ITextElementOperateProps) => import("react").JSX.Element>;
+export default TextElementOperate;

package/dist/types/views/Editor/Canvas/Operate/index.d.ts

@@ -0,0 +1,25 @@
+import { type CSSProperties } from 'react';
+import { type PPTElement, type PPTLineElement, type PPTVideoElement, type PPTAudioElement, type PPTShapeElement, type PPTChartElement } from '../../../../types/slides';
+import type { OperateLineHandlers, OperateResizeHandlers } from '../../../../types/edit';
+export type IOperateProps = {
+    elementInfo: PPTElement;
+    isSelected: boolean;
+    isActive: boolean;
+    isActiveGroupElement: boolean;
+    isMultiSelect: boolean;
+    isEditing: boolean;
+    rotateElement: (e: MouseEvent, element: Exclude<PPTElement, PPTChartElement | PPTLineElement | PPTVideoElement | PPTAudioElement>) => void;
+    scaleElement: (e: MouseEvent, element: Exclude<PPTElement, PPTLineElement>, command: OperateResizeHandlers) => void;
+    dragLineElement: (e: MouseEvent, element: PPTLineElement, command: OperateLineHandlers) => void;
+    moveShapeKeypoint: (e: MouseEvent, element: PPTShapeElement, index: number) => void;
+    dragElement: (e: MouseEvent | TouchEvent, element: PPTElement) => void;
+    beginEdit: (elementId: string, caret?: {
+        left: number;
+        top: number;
+    }) => void;
+    openLinkDialog: () => void;
+    className?: string;
+    style?: CSSProperties;
+};
+declare const Operate: import("react").MemoExoticComponent<(props: IOperateProps) => import("react").JSX.Element>;
+export default Operate;

package/dist/types/views/Editor/Canvas/Operate/operateCompare.d.ts

@@ -0,0 +1,33 @@
+import type { CSSProperties } from 'react';
+import type { PPTElement } from '../../../../types/slides';
+export declare function styleEqual(a?: CSSProperties, b?: CSSProperties): boolean;
+export declare function deepEqualIgnore(a: unknown, b: unknown, ignoreKeys: ReadonlySet<string>): boolean;
+export declare function elementChromeEqual(prev: PPTElement, next: PPTElement, ignoreContent?: boolean): boolean;
+export declare function boxGeometryChanged(prev: PPTElement, next: PPTElement): boolean;
+type OperateFlags = {
+    isSelected: boolean;
+    isActive: boolean;
+    isActiveGroupElement: boolean;
+    isMultiSelect: boolean;
+    isEditing: boolean;
+    className?: string;
+    style?: CSSProperties;
+    elementInfo: PPTElement;
+};
+export declare function operatePropsEqual(prev: OperateFlags, next: OperateFlags, ignoreContent?: boolean): boolean;
+export declare function typedOperateEqual<T extends {
+    elementInfo: PPTElement;
+    handlerVisible: boolean;
+}>(prev: T, next: T, ignoreContent?: boolean): boolean;
+export declare function multiSelectOperateEqual(prev: {
+    elementList: PPTElement[];
+}, next: {
+    elementList: PPTElement[];
+}, ignoreContent?: boolean): boolean;
+export declare function handlerChromeEqual<T extends {
+    type?: unknown;
+    rotate?: number;
+    className?: string;
+    style?: CSSProperties;
+}>(prev: T, next: T): boolean;
+export {};

package/dist/types/views/Editor/Canvas/Operate/operateMemo.d.ts

@@ -0,0 +1,12 @@
+import type { PPTElement } from '../../../../types/slides';
+import { operatePropsEqual } from './operateCompare';
+export declare function operateMemoEqual<T extends Parameters<typeof operatePropsEqual>[0]>(prev: T, next: T): boolean;
+export declare function typedOperateMemoEqual<T extends {
+    elementInfo: PPTElement;
+    handlerVisible: boolean;
+}>(prev: T, next: T): boolean;
+export declare function multiSelectOperateMemoEqual(prev: {
+    elementList: PPTElement[];
+}, next: {
+    elementList: PPTElement[];
+}): boolean;

package/dist/types/views/Editor/Canvas/Operate/stopHandleEvent.d.ts

@@ -0,0 +1,3 @@
+import type { MouseEvent as ReactMouseEvent, TouchEvent as ReactTouchEvent } from 'react';
+/** Stop the gesture so canvas blank-click / drag-ring / HitLayer cannot steal it. */
+export declare function stopHandleEvent(e: ReactMouseEvent | ReactTouchEvent): void;

package/dist/types/views/Editor/Canvas/Operate/useLatest.d.ts

@@ -0,0 +1,2 @@
+import { type MutableRefObject } from 'react';
+export declare function useLatest<T>(value: T): MutableRefObject<T>;

package/dist/types/views/Editor/Canvas/Ruler.d.ts

@@ -0,0 +1,14 @@
+import type { PPTElement } from '../../../types/slides';
+interface ViewportStyles {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+}
+export type IRulerProps = {
+    viewportStyles: ViewportStyles;
+    elementList: PPTElement[];
+};
+export declare function areRulerPropsEqual(prev: IRulerProps, next: IRulerProps): boolean;
+declare const Ruler: import("react").MemoExoticComponent<({ viewportStyles, elementList }: IRulerProps) => import("react").JSX.Element>;
+export default Ruler;

package/dist/types/views/Editor/Canvas/ShapeCreateCanvas.d.ts

@@ -0,0 +1,7 @@
+import type { CreateCustomShapeData, CustomShapeDrawMode } from '../../../types/edit';
+export type IShapeCreateCanvasProps = {
+    mode: CustomShapeDrawMode;
+    onCreated?: (payload: CreateCustomShapeData[]) => void;
+};
+declare const ShapeCreateCanvas: import("react").MemoExoticComponent<(props: IShapeCreateCanvasProps) => import("react").JSX.Element>;
+export default ShapeCreateCanvas;

package/dist/types/views/Editor/Canvas/ViewportBackground.d.ts

@@ -0,0 +1,2 @@
+declare const ViewportBackground: import("react").MemoExoticComponent<() => import("react").JSX.Element>;
+export default ViewportBackground;

package/dist/types/views/Editor/Canvas/elementListSync.d.ts

@@ -0,0 +1,12 @@
+import type { PPTElement, Slide } from '../../../types/slides';
+export declare const isContentLikeKey: (key: string, prev: PPTElement, next: PPTElement) => boolean;
+export type ElementListSyncAction = 'replace' | 'skip' | 'patch-chrome';
+export type SlideElementsSnap = {
+    id: string;
+    elements: PPTElement[];
+};
+export declare const snapSlideElements: (slide: Slide | undefined) => SlideElementsSnap | undefined;
+export declare const slideElementsSnapEqual: (prev: SlideElementsSnap | undefined, next: SlideElementsSnap | undefined, editingId: string) => boolean;
+export declare const classifyElementListSync: (prev: Slide | undefined, next: Slide | undefined, editingId: string) => ElementListSyncAction;
+export declare const isInPlaceEditingContentPatch: (prev: Slide | undefined, next: Slide | undefined, editingId: string) => boolean;
+export declare const patchEditingElementChrome: (list: PPTElement[], storeEl: PPTElement) => PPTElement[];

package/dist/types/views/Editor/Canvas/hooks/useCommonOperate.d.ts

@@ -0,0 +1,44 @@
+import { OperateResizeHandlers, OperateBorderLines } from '../../../../types/edit';
+export default _default;
+/**
+ * Handle/border lists only. Positions live in CSS against the operate wrapper
+ * so applyLiveSize can resize the box without a React re-render.
+ */
+declare function _default(): {
+    resizeHandlers: readonly [{
+        readonly direction: OperateResizeHandlers.LEFT_TOP;
+    }, {
+        readonly direction: OperateResizeHandlers.TOP;
+    }, {
+        readonly direction: OperateResizeHandlers.RIGHT_TOP;
+    }, {
+        readonly direction: OperateResizeHandlers.LEFT;
+    }, {
+        readonly direction: OperateResizeHandlers.RIGHT;
+    }, {
+        readonly direction: OperateResizeHandlers.LEFT_BOTTOM;
+    }, {
+        readonly direction: OperateResizeHandlers.BOTTOM;
+    }, {
+        readonly direction: OperateResizeHandlers.RIGHT_BOTTOM;
+    }];
+    textElementResizeHandlers: readonly [{
+        readonly direction: OperateResizeHandlers.LEFT;
+    }, {
+        readonly direction: OperateResizeHandlers.RIGHT;
+    }];
+    verticalTextElementResizeHandlers: readonly [{
+        readonly direction: OperateResizeHandlers.TOP;
+    }, {
+        readonly direction: OperateResizeHandlers.BOTTOM;
+    }];
+    borderLines: readonly [{
+        readonly type: OperateBorderLines.T;
+    }, {
+        readonly type: OperateBorderLines.B;
+    }, {
+        readonly type: OperateBorderLines.L;
+    }, {
+        readonly type: OperateBorderLines.R;
+    }];
+};

package/dist/types/views/Editor/Canvas/hooks/useDragElement.d.ts

@@ -0,0 +1,6 @@
+import type { PPTElement } from '../../../../types/slides';
+import type { AlignmentLineProps } from '../../../../types/edit';
+export default _default;
+declare function _default(elementList: PPTElement[], setElementList: (value: PPTElement[]) => void, _alignmentLines: AlignmentLineProps[], setAlignmentLines: (value: AlignmentLineProps[]) => void, canvasScale: number): {
+    dragElement: (e: MouseEvent | TouchEvent, element: PPTElement) => void;
+};

package/dist/types/views/Editor/Canvas/hooks/useDragLineElement.d.ts

@@ -0,0 +1,6 @@
+import type { PPTElement, PPTLineElement } from '../../../../types/slides';
+import { OperateLineHandlers } from '../../../../types/edit';
+export default _default;
+declare function _default(elementList: PPTElement[], setElementList: (value: PPTElement[]) => void): {
+    dragLineElement: (e: MouseEvent, element: PPTLineElement, command: OperateLineHandlers) => void;
+};

package/dist/types/views/Editor/Canvas/hooks/useDrop.d.ts

@@ -0,0 +1,4 @@
+export default _default;
+declare function _default(elementRef: {
+    current: HTMLElement | null;
+}): void;

package/dist/types/views/Editor/Canvas/hooks/useInsertFromCreateSelection.d.ts

@@ -0,0 +1,13 @@
+import type { CreateElementSelectionData } from '../../../../types/edit';
+export default _default;
+declare function _default(viewportRef: {
+    current: HTMLElement | null;
+}): {
+    formatCreateSelection: (selectionData: CreateElementSelectionData) => {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    };
+    insertElementFromCreateSelection: (selectionData: CreateElementSelectionData) => void;
+};

package/dist/types/views/Editor/Canvas/hooks/useMouseSelection.d.ts

@@ -0,0 +1,14 @@
+import type { PPTElement } from '../../../../types/slides';
+export default _default;
+declare function _default(elementList: PPTElement[], viewportRef: {
+    current: HTMLElement | null;
+}): {
+    mouseSelection: {
+        top: number;
+        left: number;
+        width: number;
+        height: number;
+    };
+    mouseSelectionVisible: boolean;
+    updateMouseSelection: (e: MouseEvent) => void;
+};

package/dist/types/views/Editor/Canvas/hooks/useMoveShapeKeypoint.d.ts

@@ -0,0 +1,5 @@
+import type { PPTElement, PPTShapeElement } from '../../../../types/slides';
+export default _default;
+declare function _default(elementList: PPTElement[], setElementList: (value: PPTElement[]) => void, canvasScale: number): {
+    moveShapeKeypoint: (e: MouseEvent | TouchEvent, element: PPTShapeElement, index?: number) => void;
+};

package/dist/types/views/Editor/Canvas/hooks/useOperateChrome.d.ts

@@ -0,0 +1,11 @@
+export default _default;
+/**
+ * Editor overlay polarity from the slide's known fill — O(1), no pixel reads.
+ * Image / gradient slides use the same representative surface as text contrast.
+ * A contrasting halo covers mixed patches (photo, white card on a dark slide)
+ * so guides stay visible without sampling during drag.
+ */
+declare function _default(): {
+    operateLineColor: string;
+    operateLineHalo: string;
+};

package/dist/types/views/Editor/Canvas/hooks/useRotateElement.d.ts

@@ -0,0 +1,7 @@
+import type { PPTElement, PPTLineElement, PPTVideoElement, PPTAudioElement, PPTChartElement } from '../../../../types/slides';
+export default _default;
+declare function _default(elementList: PPTElement[], setElementList: (value: PPTElement[]) => void, viewportRef: {
+    current: HTMLElement | null;
+}, canvasScale: number): {
+    rotateElement: (e: MouseEvent | TouchEvent, element: Exclude<PPTElement, PPTChartElement | PPTLineElement | PPTVideoElement | PPTAudioElement>) => void;
+};

package/dist/types/views/Editor/Canvas/hooks/useRotateGroupElement.d.ts

@@ -0,0 +1,7 @@
+import type { PPTElement } from '../../../../types/slides';
+export default _default;
+declare function _default(elementList: PPTElement[], setElementList: (value: PPTElement[]) => void, viewportRef: {
+    current: HTMLElement | null;
+}, canvasScale: number): {
+    rotateGroupElement: (e: MouseEvent, elements: PPTElement[]) => void;
+};

package/dist/types/views/Editor/Canvas/hooks/useScaleElement.d.ts

@@ -0,0 +1,12 @@
+import type { PPTElement, PPTLineElement } from '../../../../types/slides';
+import { OperateResizeHandlers, type MultiSelectRange } from '../../../../types/edit';
+export default _default;
+/**
+ * Live resize follows the pointer only. Snap/guides belong on move, not scale —
+ * setAlignmentLines during the gesture re-renders the canvas (even `[] !== []`)
+ * and makes the preview lag.
+ */
+declare function _default(elementList: PPTElement[], setElementList: (value: PPTElement[]) => void, canvasScale: number): {
+    scaleElement: (e: MouseEvent | TouchEvent, element: Exclude<PPTElement, PPTLineElement>, command: OperateResizeHandlers) => void;
+    scaleMultiElement: (e: MouseEvent, range: MultiSelectRange, command: OperateResizeHandlers) => void;
+};

package/dist/types/views/Editor/Canvas/hooks/useSelectElement.d.ts

@@ -0,0 +1,5 @@
+import type { PPTElement } from '../../../../types/slides';
+export default _default;
+declare function _default(elementList: PPTElement[], moveElement: (e: MouseEvent | TouchEvent, element: PPTElement) => void): {
+    selectElement: (e: MouseEvent | TouchEvent, element: PPTElement, startMove?: boolean, andEdit?: boolean) => void;
+};

package/dist/types/views/Editor/Canvas/hooks/useViewportSize.d.ts

@@ -0,0 +1,13 @@
+export default _default;
+declare function _default(canvasRef: {
+    current: HTMLElement | null;
+}): {
+    viewportStyles: {
+        width: number;
+        height: number;
+        left: number;
+        top: number;
+    };
+    dragViewport: (e: MouseEvent) => void;
+    panViewport: (dx: number, dy: number) => void;
+};

package/dist/types/views/Editor/Canvas/index.d.ts

@@ -0,0 +1,6 @@
+import { type CSSProperties } from 'react';
+declare const Canvas: import("react").MemoExoticComponent<({ className, style }: {
+    className?: string;
+    style?: CSSProperties;
+}) => import("react").JSX.Element>;
+export default Canvas;

package/dist/types/views/Editor/CanvasTool/ChartPool.d.ts

@@ -0,0 +1,8 @@
+import type { CSSProperties } from 'react';
+import type { ChartType } from '../../../types/slides';
+export type IChartPoolProps = {
+    className?: string;
+    style?: CSSProperties;
+    onSelect?: (payload: ChartType) => void;
+};
+export default function ChartPool(props: IChartPoolProps): import("react").JSX.Element;

package/dist/types/views/Editor/CanvasTool/LinePool.d.ts

@@ -0,0 +1,10 @@
+import { type CSSProperties } from 'react';
+import { type LinePoolItem } from '../../../configs/lines';
+export type ILinePoolProps = {
+    className?: string;
+    style?: CSSProperties;
+    onSelect?: (payload: LinePoolItem) => void;
+};
+declare function LinePool(props: ILinePoolProps): import("react").JSX.Element;
+declare const _default: import("react").MemoExoticComponent<typeof LinePool>;
+export default _default;

package/dist/types/views/Editor/CanvasTool/MediaPicker.d.ts

@@ -0,0 +1,7 @@
+import { type CSSProperties } from 'react';
+export type IMediaPickerProps = {
+    className?: string;
+    style?: CSSProperties;
+    onClose?: () => void;
+};
+export default function MediaPicker(props: IMediaPickerProps): import("react").JSX.Element;

package/dist/types/views/Editor/CanvasTool/SVGPathEditor.d.ts

@@ -0,0 +1,8 @@
+import { type CSSProperties } from 'react';
+export type ISVGPathEditorProps = {
+    className?: string;
+    style?: CSSProperties;
+    onClose?: () => void;
+    onInsert?: (path: string) => void;
+};
+export default function SVGPathEditor(props: ISVGPathEditorProps): import("react").JSX.Element;

package/dist/types/views/Editor/CanvasTool/ShapeItemThumbnail.d.ts

@@ -0,0 +1,12 @@
+import { type CSSProperties, type MouseEventHandler } from 'react';
+import type { ShapePoolItem } from '../../../configs/shapes';
+export type IShapeItemThumbnailProps = {
+    shape: ShapePoolItem;
+    className?: string;
+    style?: CSSProperties;
+    onClick?: MouseEventHandler<HTMLDivElement>;
+    onSelect?: (shape: ShapePoolItem) => void;
+};
+declare function ShapeItemThumbnail({ shape, className, style, onClick, onSelect }: IShapeItemThumbnailProps): import("react").JSX.Element;
+declare const _default: import("react").MemoExoticComponent<typeof ShapeItemThumbnail>;
+export default _default;

package/dist/types/views/Editor/CanvasTool/ShapePool.d.ts

@@ -0,0 +1,15 @@
+import { type CSSProperties } from 'react';
+import { type ShapePoolItem } from '../../../configs/shapes';
+import type { LinePoolItem } from '../../../configs/lines';
+export type IShapePoolProps = {
+    className?: string;
+    style?: CSSProperties;
+    onSelect?: (payload: ShapePoolItem) => void;
+    onSelectLine?: (payload: LinePoolItem) => void;
+    onScribble?: () => void;
+    onPolygon?: () => void;
+    onPathDraw?: () => void;
+};
+declare function ShapePool(props: IShapePoolProps): import("react").JSX.Element;
+declare const _default: import("react").MemoExoticComponent<typeof ShapePool>;
+export default _default;

package/dist/types/views/Editor/CanvasTool/SymbolPool.d.ts

@@ -0,0 +1,7 @@
+import { type CSSProperties } from 'react';
+export type ISymbolPoolProps = {
+    className?: string;
+    style?: CSSProperties;
+    onSelect?: () => void;
+};
+export default function SymbolPool(props: ISymbolPoolProps): import("react").JSX.Element;

package/dist/types/views/Editor/CanvasTool/TableGenerator.d.ts

@@ -0,0 +1,12 @@
+import { type CSSProperties } from 'react';
+interface InsertData {
+    row: number;
+    col: number;
+}
+export default function TableGenerator({ className, style, onInsert, }: {
+    className?: string;
+    style?: CSSProperties;
+    onInsert?: (payload: InsertData) => void;
+    onClose?: () => void;
+}): import("react").JSX.Element;
+export {};

package/dist/types/views/Editor/CanvasTool/VirtualSymbolGrid.d.ts

@@ -0,0 +1,10 @@
+import { type CSSProperties } from 'react';
+export type IVirtualSymbolGridProps = {
+    items: string[];
+    emoji?: boolean;
+    loading?: boolean;
+    className?: string;
+    style?: CSSProperties;
+    onSelect?: (value: string) => void;
+};
+export default function VirtualSymbolGrid({ items, emoji, loading, className, style, onSelect, }: IVirtualSymbolGridProps): import("react").JSX.Element;

package/dist/types/views/Editor/CanvasTool/index.d.ts

@@ -0,0 +1,7 @@
+import { type CSSProperties } from 'react';
+import 'overlayscrollbars/overlayscrollbars.css';
+declare const CanvasTool: import("react").MemoExoticComponent<({ className, style }: {
+    className?: string;
+    style?: CSSProperties;
+}) => import("react").JSX.Element>;
+export default CanvasTool;