fika-editor 3.0.0 → 3.0.1

package/dist/types/utils/textContrast.d.ts

@@ -0,0 +1,204 @@
+import type { Gradient, PPTElement, PPTTableElement, Slide, SlideBackground } from '../types/slides';
+/**
+ * Painter's-algorithm text contrast repair for AI-imported decks.
+ *
+ * The query engine answers "what is painted under this text?" by sampling
+ * points inside the text's bounds and walking the slide's element list from
+ * the text downwards (elements render in array order, so the first hit while
+ * walking backwards is the topmost layer below the text). A layer only
+ * counts when it actually covers the sample: empty / transparent fills and
+ * outline-only (border) shapes are see-through; filled shapes are hit-tested
+ * against their path (ellipse corners are not a rectangle). Themed table
+ * cells sit on zinc paper with an opaque ink header (same as the renderer).
+ * Images are `unknown` unless a sampled color cache is supplied (AI import
+ * prefetches overlap regions via `fast-average-color`). Patterns and charts stay
+ * `unknown`.
+ *
+ * Texts whose worst-case WCAG contrast falls below {@link CONTRAST_TRIGGER}
+ * are recolored with a stark black ↔ white inversion based on the
+ * *background* polarity (dark fill → white ink, light fill → black ink).
+ * Text that already has the right polarity is left alone — flipping white
+ * numbers on a mid-teal chip to black "improves" the WCAG ratio (2.98 → 7)
+ * but looks worse. Mid-tone "barely AA" greys of the *wrong* polarity are
+ * still snapped to black/white; AI decks need decisive contrast.
+ */
+/** Fix texts below this ratio (WCAG AA minimum for large text). */
+export declare const CONTRAST_TRIGGER = 3;
+/** Stark fixes (black/white) clear this comfortably; kept for callers/tests. */
+export declare const CONTRAST_TARGET = 4.5;
+interface ThemeColors {
+    backgroundColor: string;
+    fontColor: string;
+}
+/** Canvas-space rectangle with a sampled average hex (from `fast-average-color`). */
+export interface ImageRegionPaint {
+    minX: number;
+    maxX: number;
+    minY: number;
+    maxY: number;
+    hex: string;
+}
+/**
+ * Prefetched image paints for one slide. Without this, photographs stay
+ * `unknown` and the fixer leaves overlapping text alone.
+ */
+export interface ImagePaintCache {
+    /** Image element id → sampled text∩image regions. */
+    byElementId: Map<string, ImageRegionPaint[]>;
+    /** Slide image-background regions (cover-mapped), if any. */
+    slideBackground?: ImageRegionPaint[];
+}
+export interface ContrastContext {
+    images?: ImagePaintCache;
+}
+/** Flatten a gradient to a single representative color (average of stops). */
+export declare const gradientAverageColor: (gradient: Gradient) => string;
+/**
+ * Representative surface color of a slide background. Gradients average their
+ * stops; images fall back to `fallback` (usually the theme background) because
+ * the pixel paint is unknown without a sample cache. Translucent solids are
+ * composited over white so polarity matches what the user actually sees.
+ */
+export declare const resolveSlideSurfaceColor: (background: SlideBackground | undefined, fallback?: string) => string;
+/** Effective opaque fill of one cell (explicit backcolor, else theme stripe). */
+export declare const resolveTableCellFill: (el: PPTTableElement, row: number, col: number) => string | null;
+export interface BackgroundQueryResult {
+    /** Distinct opaque colors found under the sampled points. */
+    colors: string[];
+    /** True when any sample hit a layer that can't be evaluated (image, …). */
+    unknown: boolean;
+}
+/**
+ * Query engine: resolve what is painted under the element at `index`.
+ * Samples the element's bounds and, per sample, returns the topmost paint of
+ * the elements below it in painter order, falling back to the slide
+ * background.
+ */
+export declare const queryBackgroundsUnder: (elements: PPTElement[], index: number, background: SlideBackground | undefined, theme: ThemeColors, ctx?: ContrastContext) => BackgroundQueryResult;
+/**
+ * Return a readable replacement for `color` against every background, or
+ * `null` when the original should be kept.
+ *
+ * Preferred ink follows the *background*: dark fill → white, light fill →
+ * black. Text that already has that polarity is never flipped — white on a
+ * mid-luminance teal chip is ~2.98:1 (just under {@link CONTRAST_TRIGGER})
+ * but inverting it to black is the numbered-chip regression. Wrong-polarity
+ * text below the trigger snaps to the preferred ink (no muddy mid-tones).
+ */
+export declare const fixColorForBackgrounds: (color: string, backgrounds: string[]) => string | null;
+export declare const isDefaultInk: (color: string) => boolean;
+export type InkPolarity = '#ffffff' | '#000000';
+/**
+ * Canonical default ink for a set of surfaces (solid fill or every gradient stop).
+ *
+ * WCAG `mostReadable` prefers black on hot pink (`#e64980` 5.63 vs 3.73) even
+ * though white also clears 3:1 and is what a dark slide should use. Rule:
+ * 1. If only one of black/white meets {@link CONTRAST_TRIGGER} against every
+ *    surface, use that one.
+ * 2. Otherwise (both pass, both fail, mixed stops) use perceived darkness of
+ *    the darkest surface — not max-contrast, not `isDark()`.
+ *
+ * Do **not** use {@link fixColorForBackgrounds} for defaults: that helper is
+ * conservative AI-import repair and will keep `#333` on magenta because 3.4:1
+ * already passes the trigger.
+ */
+export declare const preferredInk: (surfaces: string | string[] | null | undefined) => InkPolarity;
+/** Every evaluable paint in a slide fill (gradient stops, else the flat surface). */
+export declare const resolveSlideSurfaceColors: (background: SlideBackground | undefined, fallback?: string) => string[];
+/** Surfaces the element's text actually sits on: opaque own fill, else the slide. */
+export declare const resolveElementSurfaces: (options?: {
+    fill?: string;
+    background?: SlideBackground;
+    fallbackSurface?: string;
+}) => string[];
+/**
+ * Default body ink for new / unstyled text: strictly black or white from
+ * {@link preferredInk}. Explicit saturated colors pass through.
+ */
+export declare const resolveDefaultFontColor: (color: string, surface: string | string[] | null | undefined) => string;
+/** Default font color against a slide background (and optional own fill). */
+export declare const resolveElementDefaultFontColor: (preferred: string, options?: {
+    fill?: string;
+    background?: SlideBackground;
+    fallbackSurface?: string;
+}) => string;
+/**
+ * Chart axis / legend / label ink. Same rules as text: default greys / black /
+ * white snap to {@link preferredInk} on the chart fill, else the slide.
+ * Explicit saturated colors pass through.
+ */
+export declare const resolveChartLabelColor: (chart: {
+    textColor?: string;
+    fill?: string;
+}, options?: {
+    background?: SlideBackground;
+    fallbackSurface?: string;
+    fontColor?: string;
+}) => string;
+/** Lift only series that disappear into the slide (Ink #171717 is ~1.1:1). */
+export declare const CHART_SERIES_CONTRAST = 2;
+/**
+ * Series fills/strokes must clear the slide (or chart fill). Ink's #171717
+ * on #0c0d10 is ~1:1 — lift it instead of painting invisible bars/lines.
+ */
+export declare const resolveChartSeriesColors: (colors: string[] | undefined, surfaces: string | string[] | null | undefined) => string[];
+export declare const resolveChartElementSeriesColors: (chart: {
+    themeColors?: string[];
+    fill?: string;
+}, options?: {
+    background?: SlideBackground;
+    fallbackSurface?: string;
+}) => string[];
+/**
+ * Placeholder ink is the same binary polarity as body text — never a mixed grey.
+ */
+export declare const resolvePlaceholderColor: (options: {
+    author?: string;
+    body?: string;
+    surfaces: string[];
+}) => InkPolarity;
+/** Distinct normalized text colors declared in an HTML content string. */
+export declare const collectHtmlTextColors: (html: string) => string[];
+/** Rewrite `color:` declarations via `replace` (return null to keep as-is). */
+export declare const rewriteHtmlTextColors: (html: string, replace: (color: string) => string | null) => string;
+export type ContrastAction = {
+    kind: 'fix';
+    slideIndex: number;
+    elementIndex: number;
+    elementType: 'text' | 'shape' | 'latex' | 'table';
+    target: 'html' | 'defaultColor' | 'latex' | 'tableCell';
+    from: string;
+    to: string;
+    backgrounds: string[];
+    ratioBefore: number;
+    ratioAfter: number;
+    snippet?: string;
+} | {
+    kind: 'skip';
+    slideIndex: number;
+    elementIndex: number;
+    elementType: 'text' | 'shape' | 'latex' | 'table';
+    reason: string;
+    colors?: string[];
+    backgrounds?: string[];
+    snippet?: string;
+};
+/**
+ * Same decisions as {@link fixSlideTextContrast}, but returns a per-target
+ * action log (fixes + skips) instead of mutating. Used for verification.
+ */
+export declare const diagnoseSlideTextContrast: (slide: Slide, theme: ThemeColors, slideIndex?: number, ctx?: ContrastContext) => ContrastAction[];
+/**
+ * Repair unreadable text colors on a slide in place. Returns the number of
+ * applied fixes. Used for AI-generated imports only — user background changes
+ * go through {@link applySlideBackgroundWithContrast} / {@link preferredInk}.
+ */
+export declare const fixSlideTextContrast: (slide: Slide, theme: ThemeColors, ctx?: ContrastContext) => number;
+export declare const rewriteDefaultInksInHtml: (html: string, ink: string) => string;
+/**
+ * Clone a slide and snap *default* ink (theme grey / black / white) to
+ * {@link preferredInk} for the new slide fill. Explicit colors and text on
+ * opaque own fills are left alone. Mutates nothing on the input.
+ */
+export declare const applySlideBackgroundWithContrast: (slide: Slide, theme: ThemeColors) => Slide;
+export {};

package/dist/types/utils/textFit.d.ts

@@ -0,0 +1,195 @@
+/**
+ * Shared text-fitting primitives built on `@chenglou/pretext`.
+ *
+ * Given a fixed-size text box, find the largest uniform font factor at which
+ * the content still fits — by measuring wrapped line count with pretext, then
+ * painting that factor as *actual font sizes* (Excel shrink-to-fit). Never a
+ * CSS zoom of the authored layout: zoom keeps the original wraps and scales
+ * paragraph gaps, which leaves a large empty region under the last line.
+ *
+ * pretext uses canvas, so this only does real work in a DOM/canvas runtime;
+ * callers wrap usage so a non-DOM context falls back gracefully.
+ */
+import { prepare as pretextPrepare } from '@chenglou/pretext';
+/** ProseMirror's default text size (assets/styles/prosemirror.scss). */
+export declare const DEFAULT_TEXT_FONT_SIZE = 16;
+/** Matches `ul, ol { padding-inline-start: 1em }` when the list has no inline pad. */
+export declare const DEFAULT_LIST_PADDING_EM = 1;
+/** Matches `li { padding-inline-start: 0.4em }` (marker-to-text gap). */
+export declare const LIST_MARKER_GAP_EM = 0.4;
+/**
+ * @deprecated Prefer per-block `listIndentPx` from the imported list padding.
+ * Kept as a fallback indent (px) when a list item has no padding of its own.
+ */
+export declare const BULLET_INDENT = 40;
+/** A single measurable text block (one paragraph or one list item). */
+export interface TextFitBlock {
+    /** Plain text of the block (markers stripped). */
+    text: string;
+    /** Authored font size in px (its largest run, to stay safe). */
+    size: number;
+    bold?: boolean;
+    italic?: boolean;
+    fontFamily: string;
+    /** When true, a list marker indent is subtracted from the text column. */
+    listItem?: boolean;
+    /** `ul`/`ol` padding-inline-start in px, when authored as px. */
+    listIndentPx?: number;
+    /** `ul`/`ol` padding-inline-start in em, when authored as em. */
+    listIndentEm?: number;
+}
+export interface MeasureBlocksOptions {
+    /** Box content width in px (insets already removed). */
+    innerWidth: number;
+    /** Line height multiplier (e.g. 1.5). */
+    lineHeight: number;
+    /**
+     * Vertical gap between consecutive blocks, in px. CSS `--paragraphSpace` is
+     * a fixed px value on the box — it does **not** shrink with the font (Excel
+     * cell padding / our fittedContent paint). Do not scale this with sizeScale.
+     */
+    blockSpace?: number;
+    /** Fallback list gutter in px when a list item has no `listIndentPx`/`Em`. */
+    bulletIndent?: number;
+    letterSpacing?: number;
+    /** Multiply every block's font size by this factor before measuring (default 1). */
+    sizeScale?: number;
+}
+/** Extra inner-height reserved so overflow:hidden does not clip glyph ink that
+ *  sits outside the CSS line box (PowerPoint lnSpcReduction / line-height < 1).
+ *  Sized from the font, not a fixed slab — large pads look like over-shrink. */
+export declare function fitClipPadding(maxFontSize: number, lineHeight: number): number;
+export declare const MIN_FIT_SCALE = 0.2;
+/**
+ * Excel-style shrink-to-fit from a *real* laid-out height: the largest scale
+ * `<= 1` at which `contentHeight * scale <= innerHeight`. Never grows past 100%.
+ * When content already fits, returns 1 (empty space in a tall box is authored).
+ */
+export declare function fitScaleFromContentHeight(contentHeight: number, innerHeight: number, options?: {
+    minScale?: number;
+}): number;
+/**
+ * Natural (unzoomed) scroll height of a text-fit host. Forces zoom to 1 for
+ * one synchronous layout read (no clone — cloning a focused ProseMirror can
+ * under-measure and snap the scale back to 100% on click). Width is locked to
+ * the box inner width because Chrome `zoom` shrinks `clientWidth`.
+ */
+/**
+ * Content-box size of the clipped text frame (padding already removed).
+ * Prefers the live DOM box so shrink-to-fit tracks applyLiveSize / resize
+ * instead of the last committed store width/height.
+ */
+export declare function innerBoxFromContentElement(box: HTMLElement | null | undefined, fallback: {
+    innerWidth: number;
+    innerHeight: number;
+}): {
+    innerWidth: number;
+    innerHeight: number;
+};
+/**
+ * Inner box from applyLiveSize inline styles + authored inset.
+ * No getComputedStyle / clientWidth — safe on the resize hot path.
+ */
+export declare function innerBoxFromLiveStyles(box: HTMLElement | null | undefined, el: {
+    width: number;
+    height: number;
+    inset?: [number, number, number, number];
+}): {
+    innerWidth: number;
+    innerHeight: number;
+};
+export declare function contentBoxOfHost(host: HTMLElement | null | undefined): HTMLElement | null;
+export declare function measureUnzoomedScrollHeight(host: HTMLElement, innerWidth: number): number;
+/**
+ * Total wrapped height (px) of `blocks` laid out in a column of `innerWidth`,
+ * with each block's font size multiplied by `sizeScale`. Each block is measured
+ * independently with pretext, then summed with the (unscaled, px-fixed)
+ * inter-block gap. Returns 0 for an empty input.
+ */
+export declare function measureTextBlocksHeight(blocks: TextFitBlock[], options: MeasureBlocksOptions): number;
+export interface FitFontScaleOptions {
+    innerWidth: number;
+    innerHeight: number;
+    lineHeight: number;
+    blockSpace?: number;
+    bulletIndent?: number;
+    letterSpacing?: number;
+    /** Smallest font factor to fall back to before clipping takes over (default 0.1). */
+    minScale?: number;
+}
+/**
+ * Largest uniform font factor in `[minScale, 1]` at which `blocks` fit
+ * `innerHeight`, found by binary search over pretext measurements. The factor
+ * multiplies the authored font sizes; because wrapping changes as the type
+ * shrinks, this re-measures at each candidate (not a single geometric divide).
+ * Returns 1 when content already fits (or measurement isn't possible).
+ */
+export declare function fitFontScaleForBlocks(blocks: TextFitBlock[], options: FitFontScaleOptions): number;
+/**
+ * Uniform zoom factor `innerHeight / height(authored)` — wrapping stays at the
+ * authored size. Only for the live editor (authored HTML + CSS zoom). Fitted
+ * static/thumbnail paint must use {@link fitFontScaleForBlocks} instead.
+ */
+export declare function fitZoomScaleForBlocks(blocks: TextFitBlock[], options: FitFontScaleOptions): number;
+export type FitMeasureSession = {
+    key: string;
+    lineHeight: number;
+    maxFont: number;
+    items: Array<{
+        block: TextFitBlock;
+        size: number;
+        handle: ReturnType<typeof pretextPrepare>;
+    }>;
+};
+export declare function fitSessionKey(html: string, fontFamily: string, lineHeight: number, letterSpacing: number, locale: string, defaultSize?: number): string;
+/**
+ * One-time pretext `prepare()` for authored font sizes. Resize then only
+ * calls `layout()` with the new width (no canvas, no DOM, no re-prepare).
+ */
+export declare function createFitMeasureSession(html: string, options: {
+    key: string;
+    defaultFontFamily: string;
+    lineHeight: number;
+    letterSpacing?: number;
+    /** Painted size for runs with no inline `font-size` (placeholder body is 20, not 16). */
+    defaultSize?: number;
+}): FitMeasureSession | null;
+/** Resize hot path: pure `layout()` over cached prepare handles. */
+export declare function measureSessionHeight(session: FitMeasureSession, innerWidth: number, blockSpace?: number, bulletIndent?: number): number;
+export declare function fitZoomScaleFromSession(session: FitMeasureSession, innerWidth: number, innerHeight: number, blockSpace?: number): number;
+/**
+ * One-shot locked-box scale for a rich-text HTML string. Editor resize keeps a
+ * cached session; preview/export call this so they shrink with the same math.
+ */
+export declare function textFitScaleForHtml(html: string, options: {
+    innerWidth: number;
+    innerHeight: number;
+    defaultFontFamily?: string;
+    defaultSize?: number;
+    lineHeight: number;
+    letterSpacing?: number;
+    blockSpace?: number;
+    locale?: string;
+}): number;
+export interface ExtractedContent {
+    blocks: TextFitBlock[];
+}
+export interface ExtractOptions {
+    defaultFontFamily: string;
+    defaultSize?: number;
+}
+/**
+ * Parse a Fika rich-text HTML string into measurable blocks. Each list item
+ * and top-level paragraph/quote becomes one block; a block's representative font
+ * size is the largest inline size in it (so measurement never under-estimates).
+ * Returns no blocks when there's no DOM parser or no text. List items are tagged
+ * so the marker indent is accounted for.
+ */
+export declare function extractFitBlocksFromHtml(html: string, options: ExtractOptions): ExtractedContent;
+/**
+ * Return a copy of `html` with every inline `font-size:Npx` multiplied by
+ * `scale` (rounded to 0.1px). Text without an explicit size is untouched here —
+ * the renderer scales that through the `--text-fit-base-size` CSS variable. A
+ * scale >= 1 (or a non-DOM context) returns the HTML unchanged.
+ */
+export declare function scaleHtmlFontSizes(html: string, scale: number): string;

package/dist/types/utils/textParser.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Convert plain text to HTML string with paragraph information
+ * @param text Text
+ */
+export declare const parseText2Paragraphs: (text: string) => string;

package/dist/types/utils/tooltipBind.d.ts

@@ -0,0 +1,10 @@
+import 'tippy.js/dist/tippy.css';
+import 'tippy.js/animations/scale.css';
+import '../directive/tooltip.scss';
+/**
+ * Tippy tooltips for `[data-tooltip]`. Call once from the app/embed entry.
+ *
+ * Standalone presentation mode portals into `#fika-portals`, a sibling of
+ * `#app`. Watch the shell (or the embed root) so slideshow toolbar tips bind.
+ */
+export declare function bindTooltips(root?: ParentNode): () => void;

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

@@ -0,0 +1,13 @@
+import type { AlignmentLineAxis, SnapKind } from '../../../types/edit';
+export type IAlignmentLineProps = {
+    type: 'vertical' | 'horizontal';
+    axis: AlignmentLineAxis;
+    length: number;
+    canvasScale: number;
+    kind?: SnapKind;
+    marks?: number[];
+    label?: string;
+};
+export declare function areAlignmentLinePropsEqual(prev: IAlignmentLineProps, next: IAlignmentLineProps): boolean;
+declare const AlignmentLine: import("react").MemoExoticComponent<(props: IAlignmentLineProps) => import("react").JSX.Element>;
+export default AlignmentLine;

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

@@ -0,0 +1,16 @@
+interface ViewportStyles {
+    width: number;
+    height: number;
+    left: number;
+    top: number;
+}
+export type ICanvasScrollbarsProps = {
+    canvasRef: HTMLElement | {
+        current?: HTMLElement | null;
+    } | null;
+    viewportStyles: ViewportStyles;
+    canvasScale: number;
+    pan: (dx: number, dy: number) => void;
+};
+declare const CanvasScrollbars: import("react").MemoExoticComponent<(props: ICanvasScrollbarsProps) => import("react").JSX.Element>;
+export default CanvasScrollbars;

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

@@ -0,0 +1,13 @@
+import { type CSSProperties } from 'react';
+import { type PPTElement } from '../../../types/slides';
+export type IEditableElementProps = {
+    elementInfo: PPTElement;
+    elementIndex: number;
+    isMultiSelect: boolean;
+    isEditing?: boolean;
+    selectElement: (e: MouseEvent | TouchEvent, element: PPTElement, canMove?: boolean) => void;
+    openLinkDialog: () => void;
+    style?: CSSProperties;
+};
+declare const EditableElement: import("react").MemoExoticComponent<(props: IEditableElementProps) => import("react").JSX.Element>;
+export default EditableElement;

package/dist/types/views/Editor/Canvas/EditableElement.equal.d.ts

@@ -0,0 +1,17 @@
+import type { CSSProperties } from 'react';
+import type { PPTElement } from '../../../types/slides';
+export type EditableElementCompareProps = {
+    elementInfo: PPTElement;
+    elementIndex: number;
+    isMultiSelect: boolean;
+    isEditing?: boolean;
+    style?: CSSProperties;
+};
+export declare const sameEditableGeometry: (a: PPTElement, b: PPTElement) => boolean;
+/**
+ * EditableElement is a per-element instance: sibling content cannot invalidate
+ * this wrapper. Canvas JSON-clones the whole list on every store write, so
+ * compare identity / geometry / lock / edit flags — not object identity, and
+ * not ProseMirror-owned content while this element is editing.
+ */
+export declare const areEditableElementPropsEqual: (prev: EditableElementCompareProps, next: EditableElementCompareProps) => boolean;

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

@@ -0,0 +1,6 @@
+import type { CreateElementSelectionData } from '../../../types/edit';
+export type IElementCreateSelectionProps = {
+    onCreated?: (payload: CreateElementSelectionData) => void;
+};
+declare const ElementCreateSelection: import("react").MemoExoticComponent<(props: IElementCreateSelectionProps) => import("react").JSX.Element>;
+export default ElementCreateSelection;

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

@@ -0,0 +1,9 @@
+import type { PPTElement } from '../../../../types/slides';
+import type { getElementRange } from '../../../../utils/element';
+export type IAnimationIndexProps = {
+    elementInfo: PPTElement;
+    range: ReturnType<typeof getElementRange>;
+    indexList: number[];
+};
+declare const AnimationIndex: import("react").MemoExoticComponent<(props: IAnimationIndexProps) => import("react").JSX.Element>;
+export default AnimationIndex;

package/dist/types/views/Editor/Canvas/ElementFloatLayer/FloatingToolbar/BorderPanel.d.ts

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

package/dist/types/views/Editor/Canvas/ElementFloatLayer/FloatingToolbar/ChartToolbar.d.ts

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

package/dist/types/views/Editor/Canvas/ElementFloatLayer/FloatingToolbar/CodeToolbar.d.ts

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

package/dist/types/views/Editor/Canvas/ElementFloatLayer/FloatingToolbar/ImageToolbar.d.ts

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

package/dist/types/views/Editor/Canvas/ElementFloatLayer/FloatingToolbar/LatexToolbar.d.ts

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

package/dist/types/views/Editor/Canvas/ElementFloatLayer/FloatingToolbar/LineToolbar.d.ts

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

package/dist/types/views/Editor/Canvas/ElementFloatLayer/FloatingToolbar/ShapeToolbar.d.ts

@@ -0,0 +1,7 @@
+import type { PPTShapeElement } from '../../../../../types/slides';
+export type IShapeToolbarProps = {
+    elementInfo: PPTShapeElement;
+    onResize?: () => void;
+};
+declare const ShapeToolbar: import("react").MemoExoticComponent<(props: IShapeToolbarProps) => import("react").JSX.Element>;
+export default ShapeToolbar;

package/dist/types/views/Editor/Canvas/ElementFloatLayer/FloatingToolbar/TableToolbar.d.ts

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

package/dist/types/views/Editor/Canvas/ElementFloatLayer/FloatingToolbar/TextStyleControls.d.ts

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

package/dist/types/views/Editor/Canvas/ElementFloatLayer/FloatingToolbar/TextToolbar.d.ts

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

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

@@ -0,0 +1,8 @@
+import { type PPTElement } from '../../../../../types/slides';
+export type IFloatingToolbarProps = {
+    elementInfo: PPTElement;
+    toolbarStyle: Record<string, string>;
+    onMeasure?: (width: number) => void;
+};
+declare const FloatingToolbar: import("react").MemoExoticComponent<(props: IFloatingToolbarProps) => import("react").JSX.Element>;
+export default FloatingToolbar;

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

@@ -0,0 +1,8 @@
+import type { PPTElement } from '../../../../types/slides';
+export type ILinkHandlerProps = {
+    elementInfo: PPTElement;
+    handlerStyle: Record<string, string>;
+    openLinkDialog: () => void;
+};
+declare const LinkHandler: import("react").MemoExoticComponent<(props: ILinkHandlerProps) => import("react").JSX.Element>;
+export default LinkHandler;

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

@@ -0,0 +1,15 @@
+import type { PPTElement, Slide } from '../../../../types/slides';
+type SlidesLookup = {
+    slides: Slide[];
+    slideIndex: number;
+};
+export declare function findSlideElement(state: SlidesLookup, id: string): PPTElement;
+export declare function elementLayoutSignature(element: PPTElement): string;
+export declare function elementListLayoutEqual(prev: PPTElement[], next: PPTElement[]): boolean;
+export declare function sameOffsetStyle(prev?: Record<string, string>, next?: Record<string, string>): boolean;
+export declare function sameElementId<T extends {
+    elementInfo: {
+        id: string;
+    };
+}>(prev: T, next: T): boolean;
+export {};

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;