fika-editor 3.0.0 → 3.0.2

package/dist/types/views/Screen/PresenterToolbar.d.ts

@@ -0,0 +1,30 @@
+import type { LaserColorId } from '../../configs/laser';
+export type PresenterToolbarProps = {
+    execPrev: () => void;
+    execNext: () => void;
+    turnSlideToIndex: (index: number) => void;
+    penActive: boolean;
+    laserActive: boolean;
+    laserColor: LaserColorId;
+    toggleLaserColor: (color: LaserColorId) => void;
+    timerVisible: boolean;
+    fullscreenState: boolean;
+    autoPlayTimer: ReturnType<typeof setInterval> | null;
+    autoPlay: () => void;
+    closeAutoPlay: () => void;
+    loopPlay: boolean;
+    onOpenPen: () => void;
+    onToggleLaser: () => void;
+    onToggleTimer: () => void;
+    onOpenAllSlides: () => void;
+    onPresenterView: () => void;
+    onAudienceView: () => void;
+    onEnterFullscreen: () => void;
+    onExitFullscreen: () => void;
+    onToggleLoop: () => void;
+    onEnd: () => void;
+};
+declare const PresenterToolbar: import("react").ForwardRefExoticComponent<PresenterToolbarProps & import("react").RefAttributes<{
+    reveal: () => void;
+}>>;
+export default PresenterToolbar;

package/dist/types/views/Screen/PresenterView.d.ts

@@ -0,0 +1,3 @@
+export default function PresenterView({ changeViewMode }: {
+    changeViewMode: (mode: 'base' | 'presenter') => void;
+}): import("react").JSX.Element;

package/dist/types/views/Screen/ScreenElement.d.ts

@@ -0,0 +1,12 @@
+import { type PPTElement, type Slide, type SlideBackground } from '../../types/slides';
+export type IScreenElementProps = {
+    elementInfo: PPTElement;
+    elementIndex: number;
+    animationIndex: number;
+    slideType?: Slide['type'];
+    background?: SlideBackground;
+    turnSlideToId: (id: string) => void;
+    manualExitFullscreen: () => void;
+};
+declare const ScreenElement: import("react").MemoExoticComponent<(props: IScreenElementProps) => import("react").JSX.Element>;
+export default ScreenElement;

package/dist/types/views/Screen/ScreenShell.d.ts

@@ -0,0 +1,2 @@
+/** Instant present backdrop: theme/slide fill only, no slide tree. */
+export default function ScreenShell(): import("react").ReactPortal;

package/dist/types/views/Screen/ScreenSlide.d.ts

@@ -0,0 +1,11 @@
+import type { Slide } from '../../types/slides';
+export type IScreenSlideProps = {
+    slide: Slide;
+    scale: number;
+    animationIndex: number;
+    turnSlideToId: (id: string) => void;
+    manualExitFullscreen: () => void;
+    paintElements?: boolean;
+};
+declare const ScreenSlide: import("react").MemoExoticComponent<(props: IScreenSlideProps) => import("react").JSX.Element>;
+export default ScreenSlide;

package/dist/types/views/Screen/ScreenSlideList.d.ts

@@ -0,0 +1,15 @@
+import { type MouseEventHandler, type TouchEventHandler, type WheelEventHandler } from 'react';
+export type IScreenSlideListProps = {
+    slideWidth: number;
+    slideHeight: number;
+    animationIndex: number;
+    turnSlideToId: (id: string) => void;
+    manualExitFullscreen: () => void;
+    variant?: 'theater' | 'paper';
+    onWheel?: WheelEventHandler<HTMLDivElement>;
+    onTouchStart?: TouchEventHandler<HTMLDivElement>;
+    onTouchEnd?: TouchEventHandler<HTMLDivElement>;
+    onClick?: MouseEventHandler<HTMLDivElement>;
+    onContextMenu?: MouseEventHandler<HTMLDivElement>;
+};
+export default function ScreenSlideList({ slideWidth, slideHeight, animationIndex, turnSlideToId, manualExitFullscreen, variant, onWheel, onTouchStart, onTouchEnd, onClick, onContextMenu, }: IScreenSlideListProps): import("react").JSX.Element;

package/dist/types/views/Screen/SlideThumbnails.d.ts

@@ -0,0 +1,7 @@
+export type ISlideThumbnailsProps = {
+    turnSlideToIndex: (index: number) => void;
+} & {
+    onClose?: () => void;
+};
+declare const SlideThumbnails: import("react").MemoExoticComponent<(props: ISlideThumbnailsProps) => import("react").JSX.Element>;
+export default SlideThumbnails;

package/dist/types/views/Screen/WritingBoardTool.d.ts

@@ -0,0 +1,9 @@
+export type IWritingBoardToolProps = {
+    slideWidth: number;
+    slideHeight: number;
+    left?: number;
+    top?: number;
+    drawing?: boolean;
+    onClose?: () => void;
+};
+export default function WritingBoardTool({ slideWidth, slideHeight, left, top, drawing, onClose, }: IWritingBoardToolProps): import("react").JSX.Element;

package/dist/types/views/Screen/hooks/useExecPlay.d.ts

@@ -0,0 +1,33 @@
+import { type LaserColorId, type ScreenTool } from '../../../configs/laser';
+export default _default;
+declare function _default(): {
+    autoPlayTimer: NodeJS.Timeout;
+    autoPlayInterval: number;
+    setAutoPlayInterval: (interval: number) => void;
+    autoPlay: () => void;
+    closeAutoPlay: () => void;
+    loopPlay: boolean;
+    setLoopPlay: (loop: boolean) => void;
+    mousewheelListener: import("../../../utils/debounce").Debounced<(e: WheelEvent) => void>;
+    touchStartListener: (e: TouchEvent) => void;
+    touchEndListener: (e: TouchEvent) => void;
+    turnPrevSlide: () => void;
+    turnNextSlide: () => void;
+    turnSlideToIndex: (index: number) => void;
+    turnSlideToId: (id: string) => void;
+    execPrev: (broadcast?: boolean) => void;
+    execNext: () => void;
+    handleSlideClick: (e: MouseEvent) => void;
+    animationIndex: number;
+    setAnimationIndex: (value: number) => void;
+    restoreAnimationState: (targetIndex: number) => void;
+    laserActive: boolean;
+    laserColor: LaserColorId;
+    penActive: boolean;
+    penSession: boolean;
+    switchTool: (next: ScreenTool | null) => void;
+    toggleTool: (next: ScreenTool) => void;
+    toggleLaserColor: (color: LaserColorId) => void;
+    closePenSession: () => void;
+    broadcastExit: () => void;
+};

package/dist/types/views/Screen/hooks/useFullscreen.d.ts

@@ -0,0 +1,5 @@
+export default _default;
+declare function _default(): {
+    fullscreenState: boolean;
+    manualExitFullscreen: () => void;
+};

package/dist/types/views/Screen/hooks/useScreenTools.d.ts

@@ -0,0 +1,20 @@
+import type { LaserColorId, ScreenTool } from '../../../configs/laser';
+/**
+ * Exclusive presenter tools. Selecting one deactivates the previous tool.
+ * Pen ink stays mounted until the user closes it — switching to laser must
+ * not tear down the writing board.
+ *
+ * Tool / color live in refs. Callbacks always read current values so
+ * empty-deps listeners in useExecPlay stay correct.
+ */
+export declare const useScreenTools: () => {
+    tool: ScreenTool;
+    laserColor: LaserColorId;
+    laserActive: boolean;
+    penActive: boolean;
+    penSession: boolean;
+    switchTool: (next: ScreenTool | null) => void;
+    toggleTool: (next: ScreenTool) => void;
+    toggleLaserColor: (color: LaserColorId) => void;
+    closePenSession: () => void;
+};

package/dist/types/views/Screen/hooks/useSlideSize.d.ts

@@ -0,0 +1,11 @@
+export declare const measureSlideSize: (viewportRatio: number, wrap?: HTMLElement | null) => {
+    slideWidth: number;
+    slideHeight: number;
+};
+export default _default;
+declare function _default(wrapRef?: {
+    current: HTMLElement | null;
+}): {
+    slideWidth: number;
+    slideHeight: number;
+};

package/dist/types/views/Screen/index.d.ts

@@ -0,0 +1,2 @@
+import './screen-portal.scss';
+export default function Screen(): import("react").ReactPortal;

package/dist/types/views/Screen/lazy.d.ts

@@ -0,0 +1,2 @@
+export declare const importScreen: () => Promise<typeof import("./index")>;
+export declare const prefetchScreen: () => void;

package/dist/types/views/Screen/screenWindow.d.ts

@@ -0,0 +1,11 @@
+import type { TurningMode } from '../../types/slides';
+/** Neighbors kept in the turning window (current ± 1). */
+export declare const SCREEN_PRELOAD_RADIUS = 1;
+/** Filmstrip / bottom-rail thumbs that keep a raster attached. */
+export declare const SCREEN_THUMB_RADIUS = 6;
+export declare const screenWindowRange: (current: number, length: number, radius?: number) => {
+    start: number;
+    end: number;
+};
+export declare const isInScreenWindow: (index: number, current: number, radius?: number) => boolean;
+export declare const resolveTurningMode: (slideId: string, turningMode?: TurningMode) => TurningMode;

package/dist/types/views/components/ThumbnailSlide/LiveSlideThumb.d.ts

@@ -0,0 +1,21 @@
+import type { Slide } from '../../../types/slides';
+export type ILiveSlideThumbProps = {
+    slide: Slide;
+    width: number;
+    /** Opt into the identity-keyed snapshot cache (editor rail only). */
+    snapshot?: boolean;
+};
+/**
+ * A thumbnail that IS the slide: the genuine ScreenSlide tree, scaled to the
+ * thumbnail box. With `snapshot` enabled, a row that already has a fresh
+ * bitmap renders only the <img>. A row without one mounts the live tree —
+ * the virtualizer screenshots that tree with snapdom before tearing the row
+ * down, so the next visit is the bitmap. Nothing is captured ahead of the
+ * viewport; only a row that was actually shown is snapshotted on leave.
+ *
+ * During a gutter drag only this light wrapper tracks the live width; the
+ * mounted ScreenSlide keeps its drag-start scale and is visually scaled by a
+ * composited transform — the heavy tree never re-renders mid-drag.
+ */
+declare const LiveSlideThumb: import("react").MemoExoticComponent<(props: ILiveSlideThumbProps) => import("react").JSX.Element>;
+export default LiveSlideThumb;

package/dist/types/views/components/ThumbnailSlide/index.d.ts

@@ -0,0 +1,21 @@
+import type { Slide } from '../../../types/slides';
+export type IThumbnailSlideProps = {
+    slide: Slide | {
+        id: string;
+    };
+    size: number;
+    visible?: boolean;
+    showPlaceholders?: boolean;
+    className?: string;
+    /** Opt into the identity-keyed snapshot cache (editor rail only). */
+    snapshot?: boolean;
+};
+export declare function areThumbnailSlidePropsEqual(prev: IThumbnailSlideProps, next: IThumbnailSlideProps): boolean;
+/**
+ * The thumbnail IS the slide: the real ScreenSlide DOM scaled into the thumb
+ * box (see LiveSlideThumb). The rail stays faithful to the editor canvas by
+ * construction and updates live while editing — no raster pipeline, no
+ * per-element capture booths, nothing to fall behind.
+ */
+declare const ThumbnailSlide: import("react").MemoExoticComponent<(props: IThumbnailSlideProps) => import("react").JSX.Element>;
+export default ThumbnailSlide;

package/dist/types/views/components/ThumbnailSlide/paintedSlide.d.ts

@@ -0,0 +1,29 @@
+import type { Slide } from '../../../types/slides';
+import { diffPaintedSlide, type PaintedSlide, type PaintedSlideDiff } from '../../../utils/diffPaintedSlide';
+export type { PaintedSlide, PaintedSlideDiff };
+export { diffPaintedSlide };
+export type RailSlideMeta = {
+    id: string;
+    sectionTag: Slide['sectionTag'];
+};
+export declare function selectPaintedSlide<T extends {
+    slides: Slide[];
+}>(state: T, slideId: string): Slide | undefined;
+export declare const paintedSlideAuthoredKey: (slide: Slide | undefined) => string;
+export declare const paintedSlidePaintKey: (slide: Slide | undefined) => string;
+export declare const selectPaintedSlideAuthoredKey: <T extends {
+    slides: Slide[];
+}>(state: T, slideId: string) => string;
+export declare const selectPaintedSlidePaintKey: <T extends {
+    slides: Slide[];
+}>(state: T, slideId: string) => string;
+/** Slide object identity is stable across content writes (immer + autoFreeze: false). */
+export declare const paintedSlideContentEqual: (a: Slide | undefined, b: Slide | undefined) => boolean;
+export declare function arePaintedSlideIdentitiesEqual(a: PaintedSlide | undefined, b: PaintedSlide | undefined): boolean;
+export declare function areRailItemSlidesEqual(a: Slide | undefined, b: Slide | undefined): boolean;
+export declare function areRailSlideMetasEqual(a: RailSlideMeta[], b: RailSlideMeta[]): boolean;
+export declare function areRailSlidesEqual(a: Slide[], b: Slide[]): boolean;
+export declare function usePaintedSlide(slideId: string, fallback: Slide): Slide;
+export declare function useRailItemSlide(slideId: string): Slide | undefined;
+export declare function useRailSlideMetas(): RailSlideMeta[];
+export declare function useRailSlides(): Slide[];

package/dist/types/views/components/ThumbnailSlide/thumbSnapshot.d.ts

@@ -0,0 +1,54 @@
+import type { Slide } from '../../../types/slides';
+export type ThumbSnapshot = {
+    url: string;
+    cssWidth: number;
+    cssHeight: number;
+};
+export type ThumbSnapshotDeps = {
+    slideId: string;
+    slide: Slide | undefined;
+    theme: unknown;
+    viewportRatio: number;
+    viewportSize: number;
+    cssWidth: number;
+    dpr: number;
+};
+export declare const thumbSnapshotStats: {
+    hits: number;
+    misses: number;
+    captures: number;
+    failed: number;
+    hostileSkips: number;
+    evictions: number;
+    invalidated: number;
+    captureMs: number[];
+};
+/** Re-render when snapshots arrive or are cleared. */
+export declare const useThumbSnapshotVersion: () => number;
+/**
+ * Fresh lookup for the current render. A stored snapshot whose key no longer
+ * matches is revoked on the spot — stale pixels are never handed out.
+ */
+export declare function lookupThumbSnapshot(deps: ThumbSnapshotDeps): ThumbSnapshot | null;
+export declare function clearThumbSnapshots(): void;
+export declare function hasFreshSnapshotFor(slideId: string): boolean;
+export declare function canCaptureThumb(slideId: string): boolean;
+export declare const isRailScrollIdle: () => boolean;
+export declare function requestThumbCapture(deps: ThumbSnapshotDeps, getNode: () => HTMLElement | null): void;
+/** Screenshot a live thumb now — used before the virtualizer tears the row down. */
+export declare function requestTeardownCapture(deps: ThumbSnapshotDeps, getNode: () => HTMLElement | null): Promise<boolean>;
+export declare function teardownThumbSnapshot(slideId: string, getNode: () => HTMLElement | null): Promise<boolean>;
+export declare const readThumbSnapshotReport: () => {
+    hits: number;
+    misses: number;
+    captures: number;
+    failed: number;
+    hostileSkips: number;
+    evictions: number;
+    invalidated: number;
+    captureMs: number[];
+    captureMsAvg: number;
+    captureMsMax: number;
+    cached: number;
+    hostile: number;
+};

package/dist/types/views/components/element/AudioElement/ScreenAudioElement.d.ts

@@ -0,0 +1,6 @@
+import type { PPTAudioElement } from '../../../../types/slides';
+export type IScreenAudioElementProps = {
+    elementInfo: PPTAudioElement;
+};
+declare const ScreenAudioElement: import("react").MemoExoticComponent<(props: IScreenAudioElementProps) => import("react").JSX.Element>;
+export default ScreenAudioElement;

package/dist/types/views/components/element/AudioElement/index.d.ts

@@ -0,0 +1,9 @@
+import type { PPTAudioElement } from '../../../../types/slides';
+import type { ContextmenuItem } from '../../../../components/Contextmenu/types';
+export type IAudioElementProps = {
+    elementInfo: PPTAudioElement;
+    selectElement: (e: MouseEvent | TouchEvent, element: PPTAudioElement, canMove?: boolean) => void;
+    contextmenus: () => ContextmenuItem[] | null;
+};
+declare const AudioElement: import("react").MemoExoticComponent<(props: IAudioElementProps) => import("react").JSX.Element>;
+export default AudioElement;

package/dist/types/views/components/element/ChartElement/BaseChartElement.d.ts

@@ -0,0 +1,9 @@
+import type { PPTChartElement, SlideBackground } from '../../../../types/slides';
+export type IBaseChartElementProps = {
+    elementInfo: PPTChartElement;
+    target?: string;
+    background?: SlideBackground;
+    themeBackgroundColor?: string;
+};
+declare const BaseChartElement: import("react").MemoExoticComponent<(props: IBaseChartElementProps) => import("react").JSX.Element>;
+export default BaseChartElement;

package/dist/types/views/components/element/ChartElement/Chart.d.ts

@@ -0,0 +1,13 @@
+import type { ChartData, ChartOptions, ChartType } from '../../../../types/slides';
+export type IChartProps = {
+    width: number;
+    height: number;
+    type: ChartType;
+    data: ChartData;
+    themeColors: string[];
+    textColor?: string;
+    lineColor?: string;
+    options?: ChartOptions;
+};
+declare const Chart: import("react").MemoExoticComponent<(props: IChartProps) => import("react").JSX.Element>;
+export default Chart;

package/dist/types/views/components/element/ChartElement/chartOption.d.ts

@@ -0,0 +1,17 @@
+import type { ComposeOption } from 'echarts/core';
+import type { BarSeriesOption, LineSeriesOption, PieSeriesOption, ScatterSeriesOption, RadarSeriesOption } from 'echarts/charts';
+import type { GridComponentOption, LegendComponentOption, RadarComponentOption } from 'echarts/components';
+import type { ChartData, ChartType } from '../../../../types/slides';
+type EChartOption = ComposeOption<BarSeriesOption | LineSeriesOption | PieSeriesOption | ScatterSeriesOption | RadarSeriesOption | GridComponentOption | LegendComponentOption | RadarComponentOption>;
+export declare const expandChartThemeColors: (themeColors: string[]) => string[];
+export interface ChartOptionPayload {
+    type: ChartType;
+    data: ChartData;
+    themeColors: string[];
+    textColor?: string;
+    lineColor?: string;
+    lineSmooth?: boolean;
+    stack?: boolean;
+}
+export declare const getChartOption: ({ type, data, themeColors, textColor, lineColor, lineSmooth, stack }: ChartOptionPayload) => EChartOption | null;
+export {};

package/dist/types/views/components/element/ChartElement/index.d.ts

@@ -0,0 +1,9 @@
+import type { PPTChartElement } from '../../../../types/slides';
+import type { ContextmenuItem } from '../../../../components/Contextmenu/types';
+export type IChartElementProps = {
+    elementInfo: PPTChartElement;
+    selectElement: (e: MouseEvent | TouchEvent, element: PPTChartElement, canMove?: boolean) => void;
+    contextmenus: () => ContextmenuItem[] | null;
+};
+declare const ChartElement: import("react").MemoExoticComponent<(props: IChartElementProps) => import("react").JSX.Element>;
+export default ChartElement;

package/dist/types/views/components/element/CodeElement/BaseCodeElement.d.ts

@@ -0,0 +1,6 @@
+import type { PPTCodeElement } from '../../../../types/slides';
+export type IBaseCodeElementProps = {
+    elementInfo: PPTCodeElement;
+};
+declare const BaseCodeElement: import("react").MemoExoticComponent<(props: IBaseCodeElementProps) => import("react").JSX.Element>;
+export default BaseCodeElement;

package/dist/types/views/components/element/CodeElement/CodeBlockSkeleton.d.ts

@@ -0,0 +1,13 @@
+import type { PPTCodeElement } from '../../../../types/slides';
+export type ICodeBlockSkeletonProps = {
+    code?: string;
+    fontSize?: number;
+    showLineNumbers?: boolean;
+    theme?: string;
+};
+declare const CodeBlockSkeleton: import("react").MemoExoticComponent<(props: ICodeBlockSkeletonProps) => import("react").JSX.Element>;
+export type ICodeElementPlaceholderProps = {
+    elementInfo: PPTCodeElement;
+};
+export declare const CodeElementPlaceholder: import("react").MemoExoticComponent<(props: ICodeElementPlaceholderProps) => import("react").JSX.Element>;
+export default CodeBlockSkeleton;

package/dist/types/views/components/element/CodeElement/CodeContent.d.ts

@@ -0,0 +1,6 @@
+import type { PPTCodeElement } from '../../../../types/slides';
+export type ICodeContentProps = {
+    elementInfo: PPTCodeElement;
+};
+declare const CodeContent: import("react").MemoExoticComponent<(props: ICodeContentProps) => import("react").JSX.Element>;
+export default CodeContent;

package/dist/types/views/components/element/CodeElement/index.d.ts

@@ -0,0 +1,9 @@
+import type { PPTCodeElement } from '../../../../types/slides';
+import type { ContextmenuItem } from '../../../../components/Contextmenu/types';
+export type ICodeElementProps = {
+    elementInfo: PPTCodeElement;
+    selectElement: (e: MouseEvent | TouchEvent, element: PPTCodeElement, canMove?: boolean) => void;
+    contextmenus: () => ContextmenuItem[] | null;
+};
+declare const CodeElement: import("react").MemoExoticComponent<(props: ICodeElementProps) => import("react").JSX.Element>;
+export default CodeElement;

package/dist/types/views/components/element/ElementOutline.d.ts

@@ -0,0 +1,8 @@
+import type { PPTElementOutline } from '../../../types/slides';
+export type IElementOutlineProps = {
+    width: number;
+    height: number;
+    outline?: PPTElementOutline;
+};
+declare const ElementOutline: import("react").MemoExoticComponent<(props: IElementOutlineProps) => import("react").JSX.Element>;
+export default ElementOutline;

package/dist/types/views/components/element/ImageElement/BaseImageElement.d.ts

@@ -0,0 +1,6 @@
+import type { PPTImageElement } from '../../../../types/slides';
+export type IBaseImageElementProps = {
+    elementInfo: PPTImageElement;
+};
+declare const BaseImageElement: import("react").MemoExoticComponent<(props: IBaseImageElementProps) => import("react").JSX.Element>;
+export default BaseImageElement;

package/dist/types/views/components/element/ImageElement/ImageBitmapSurface.d.ts

@@ -0,0 +1,10 @@
+import { type CSSProperties, type DragEventHandler } from 'react';
+export type IImageBitmapSurfaceProps = {
+    src: string;
+    className?: string;
+    style?: CSSProperties;
+    draggable?: boolean;
+    onDragStart?: DragEventHandler<HTMLCanvasElement>;
+};
+declare const ImageBitmapSurface: import("react").MemoExoticComponent<(props: IImageBitmapSurfaceProps) => import("react").JSX.Element>;
+export default ImageBitmapSurface;

package/dist/types/views/components/element/ImageElement/ImageClipHandler.d.ts

@@ -0,0 +1,15 @@
+import { type ImageClipedEmitData } from '../../../../types/edit';
+import type { ImageElementClip } from '../../../../types/slides';
+export type IImageClipHandlerProps = {
+    src: string;
+    clipPath: string;
+    width: number;
+    height: number;
+    top: number;
+    left: number;
+    rotate: number;
+    clipData?: ImageElementClip;
+    onClip?: (payload: ImageClipedEmitData | null) => void;
+};
+declare const ImageClipHandler: import("react").MemoExoticComponent<(props: IImageClipHandlerProps) => import("react").JSX.Element>;
+export default ImageClipHandler;

package/dist/types/views/components/element/ImageElement/ImageOutline/ImageEllipseOutline.d.ts

@@ -0,0 +1,8 @@
+import type { PPTElementOutline } from '../../../../../types/slides';
+export type IImageEllipseOutlineProps = {
+    width: number;
+    height: number;
+    outline?: PPTElementOutline;
+};
+declare const ImageEllipseOutline: import("react").MemoExoticComponent<(props: IImageEllipseOutlineProps) => import("react").JSX.Element>;
+export default ImageEllipseOutline;

package/dist/types/views/components/element/ImageElement/ImageOutline/ImagePolygonOutline.d.ts

@@ -0,0 +1,9 @@
+import type { PPTElementOutline } from '../../../../../types/slides';
+export type IImagePolygonOutlineProps = {
+    width: number;
+    height: number;
+    createPath: (width: number, height: number) => string;
+    outline?: PPTElementOutline;
+};
+declare const ImagePolygonOutline: import("react").MemoExoticComponent<(props: IImagePolygonOutlineProps) => import("react").JSX.Element>;
+export default ImagePolygonOutline;

package/dist/types/views/components/element/ImageElement/ImageOutline/ImageRectOutline.d.ts

@@ -0,0 +1,9 @@
+import type { PPTElementOutline } from '../../../../../types/slides';
+export type IImageRectOutlineProps = {
+    width: number;
+    height: number;
+    outline?: PPTElementOutline;
+    radius?: string;
+};
+declare const ImageRectOutline: import("react").MemoExoticComponent<(props: IImageRectOutlineProps) => import("react").JSX.Element>;
+export default ImageRectOutline;

package/dist/types/views/components/element/ImageElement/ImageOutline/index.d.ts

@@ -0,0 +1,6 @@
+import type { PPTImageElement } from '../../../../../types/slides';
+export type IImageOutlineProps = {
+    elementInfo: PPTImageElement;
+};
+declare const ImageOutline: import("react").MemoExoticComponent<(props: IImageOutlineProps) => import("react").JSX.Element>;
+export default ImageOutline;

package/dist/types/views/components/element/ImageElement/index.d.ts

@@ -0,0 +1,9 @@
+import type { PPTImageElement } from '../../../../types/slides';
+import type { ContextmenuItem } from '../../../../components/Contextmenu/types';
+export type IImageElementProps = {
+    elementInfo: PPTImageElement;
+    selectElement: (e: MouseEvent | TouchEvent, element: PPTImageElement, canMove?: boolean) => void;
+    contextmenus: () => ContextmenuItem[] | null;
+};
+declare const ImageElement: import("react").MemoExoticComponent<(props: IImageElementProps) => import("react").JSX.Element>;
+export default ImageElement;

package/dist/types/views/components/element/ImageElement/useClipImage.d.ts

@@ -0,0 +1,10 @@
+export default _default;
+declare function _default(element: any): {
+    clipShape: import("../../../../configs/imageClip").ClipPathItem;
+    imgPosition: {
+        top: string;
+        left: string;
+        width: string;
+        height: string;
+    };
+};

package/dist/types/views/components/element/ImageElement/useFilter.d.ts

@@ -0,0 +1,4 @@
+export default _default;
+declare function _default(filters: any): {
+    filter: string;
+};

package/dist/types/views/components/element/ImageElement/useImageBitmap.d.ts

@@ -0,0 +1,2 @@
+export declare const useImageBitmap: (src: string) => ImageBitmap | null;
+export declare const useSyncImageBitmapCache: () => void;

package/dist/types/views/components/element/LatexElement/BaseLatexElement.d.ts

@@ -0,0 +1,6 @@
+import type { PPTLatexElement } from '../../../../types/slides';
+export type IBaseLatexElementProps = {
+    elementInfo: PPTLatexElement;
+};
+declare const BaseLatexElement: import("react").MemoExoticComponent<(props: IBaseLatexElementProps) => import("react").JSX.Element>;
+export default BaseLatexElement;

package/dist/types/views/components/element/LatexElement/LatexContent.d.ts

@@ -0,0 +1,6 @@
+import type { PPTLatexElement } from '../../../../types/slides';
+export type ILatexContentProps = {
+    elementInfo: PPTLatexElement;
+};
+declare const LatexContent: import("react").MemoExoticComponent<(props: ILatexContentProps) => import("react").JSX.Element>;
+export default LatexContent;

package/dist/types/views/components/element/LatexElement/index.d.ts

@@ -0,0 +1,9 @@
+import type { PPTLatexElement } from '../../../../types/slides';
+import type { ContextmenuItem } from '../../../../components/Contextmenu/types';
+export type ILatexElementProps = {
+    elementInfo: PPTLatexElement;
+    selectElement: (e: MouseEvent | TouchEvent, element: PPTLatexElement, canMove?: boolean) => void;
+    contextmenus: () => ContextmenuItem[] | null;
+};
+declare const LatexElement: import("react").MemoExoticComponent<(props: ILatexElementProps) => import("react").JSX.Element>;
+export default LatexElement;

package/dist/types/views/components/element/LineElement/BaseLineElement.d.ts

@@ -0,0 +1,6 @@
+import type { PPTLineElement } from '../../../../types/slides';
+export type IBaseLineElementProps = {
+    elementInfo: PPTLineElement;
+};
+declare const BaseLineElement: import("react").MemoExoticComponent<(props: IBaseLineElementProps) => import("react").JSX.Element>;
+export default BaseLineElement;

package/dist/types/views/components/element/LineElement/LinePointMarker.d.ts

@@ -0,0 +1,12 @@
+import type { LinePoint } from '../../../../types/slides';
+type NonEmptyLinePoint = Exclude<LinePoint, ''>;
+export type ILinePointMarkerProps = {
+    id: string;
+    position: 'start' | 'end';
+    type: NonEmptyLinePoint;
+    baseSize: number;
+    color?: string;
+    preview?: boolean;
+};
+declare const LinePointMarker: import("react").MemoExoticComponent<(props: ILinePointMarkerProps) => import("react").JSX.Element>;
+export default LinePointMarker;

package/dist/types/views/components/element/LineElement/index.d.ts

@@ -0,0 +1,9 @@
+import type { PPTLineElement } from '../../../../types/slides';
+import type { ContextmenuItem } from '../../../../components/Contextmenu/types';
+export type ILineElementProps = {
+    elementInfo: PPTLineElement;
+    selectElement: (e: MouseEvent | TouchEvent, element: PPTLineElement, canMove?: boolean) => void;
+    contextmenus: () => ContextmenuItem[] | null;
+};
+declare const LineElement: import("react").MemoExoticComponent<(props: ILineElementProps) => import("react").JSX.Element>;
+export default LineElement;