fika-editor 3.0.0 → 3.0.2

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

@@ -0,0 +1,200 @@
+import type { PPTElement } from '../types/slides';
+import { type ClientCoords } from './prosemirror/caret';
+/** Temporary: paint every pointer hit target so the hit engine can be verified. */
+export declare const DEBUG_HIT_AREAS = false;
+/** Minimum visual-pixel size so thin lines remain hittable. */
+export declare const MIN_HIT_PX = 8;
+/**
+ * Drag-ring sizing in visual pixels, based on the box's effective side length.
+ *
+ * Inner eats the edit surface; outer is extra grab outside the box.
+ * Short/zoomed-out boxes shrink inner toward 0 so the whole interior stays editable.
+ */
+export declare const MIN_INNER_DRAG_PX = 1;
+export declare const MAX_INNER_DRAG_PX = 4;
+export declare const MIN_OUTER_DRAG_PX = 3;
+export declare const MAX_OUTER_DRAG_PX = 5;
+export declare const MIN_EDIT_INTERIOR_PX = 10;
+export declare const RING_SIZE_MIN = 20;
+export declare const RING_SIZE_MAX = 56;
+/** Inner/outer drag thickness for one axis (visual width or height). */
+export declare function dragRingMetrics(visualSize: number): {
+    innerPx: number;
+    outerPx: number;
+};
+/** Inward drag thickness on the constraining side (0 when the box is too short to spare any). */
+export declare function borderHitPx(width: number, height: number): number;
+export declare const HIT_RING_SIDES: readonly ['top', 'bottom', 'left', 'right'];
+export type HitRingSide = (typeof HIT_RING_SIDES)[number];
+/** Matches `.resize-handler` (10px box, centered on the edge with -5px margin). */
+export declare const RESIZE_HANDLE_SIZE_PX = 10;
+export declare const RESIZE_HANDLE_RADIUS_PX: number;
+export declare const RESIZE_HANDLE_DIRECTIONS: readonly ['left-top', 'top', 'right-top', 'left', 'right', 'left-bottom', 'bottom', 'right-bottom'];
+export type ResizeHandleDirection = (typeof RESIZE_HANDLE_DIRECTIONS)[number];
+export interface ResizeHandleCenter {
+    x: number;
+    y: number;
+    direction: ResizeHandleDirection;
+}
+/** Box-local centers of the 8 resize squares (origin = top-left). */
+export declare function resizeHandleCenters(width: number, height: number, directions?: readonly ResizeHandleDirection[]): ResizeHandleCenter[];
+/** Handles actually rendered for this element (none for lines). */
+export declare function resizeHandleDirectionsFor(element: PPTElement): readonly ResizeHandleDirection[];
+export interface HitRingLayout {
+    inset: string;
+    sides: Record<HitRingSide, Record<string, string>>;
+    vertical: {
+        innerPx: number;
+        outerPx: number;
+    };
+    horizontal: {
+        innerPx: number;
+        outerPx: number;
+    };
+}
+export interface HitRingLayoutOptions {
+    /**
+     * Cut these handle squares out of the move strips.
+     * Resize must beat move: the ring must not claim those pixels.
+     */
+    clearResizeHandles?: readonly ResizeHandleDirection[];
+}
+/**
+ * Per-side drag strips. Top/bottom follow visual height; left/right follow width.
+ * Outer grab does not consume the edit interior.
+ * When `clearResizeHandles` is set, handle squares are punched out so move cannot steal resize.
+ */
+export declare function hitRingLayout(width: number, height: number, options?: HitRingLayoutOptions): HitRingLayout;
+export interface VisualHitRect {
+    id: string;
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    rotate: number;
+    zIndex: number;
+    /**
+     * Empty placeholder slot (dashed prompt, no authored content). It is a
+     * background affordance: any element carrying visible content that
+     * overlaps it wins the pointer regardless of z-order — users click the
+     * text they SEE, not the dashed frame behind it.
+     */
+    yieldToContent?: boolean;
+}
+/** True when the element paints authored content the user can click "on". */
+export declare function elementHasClickableContent(element: PPTElement): boolean;
+/**
+ * Map a slide element to a hit rectangle in `.viewport-wrapper` visual pixels.
+ *
+ * Hit-testing must never go through the CSS-scaled unsized `.viewport`.
+ * That path fragments (glyph boxes, SVG fills) and offsets under zoom.
+ */
+export declare function elementVisualHitRect(element: PPTElement, canvasScale: number, zIndex: number): VisualHitRect;
+export declare function pointInVisualHitRect(x: number, y: number, rect: VisualHitRect): boolean;
+/** Topmost rect at a wrapper-local point (highest zIndex wins). RBush AABB, then pointInVisualHitRect refine. */
+export declare function hitTestVisualRects(rects: VisualHitRect[], x: number, y: number): VisualHitRect | null;
+export declare const TEXT_EDITABLE_TYPES: Set<string>;
+/**
+ * Clicking the interior opens the text editor. Drag from the border only.
+ * Includes text boxes and shapes/tables that already contain text.
+ */
+export declare function clicksToEditText(element: PPTElement): boolean;
+/** Interior stays interactive (text caret, or media playback). Drag from the border. */
+export declare function hasInteractiveSurface(element: PPTElement): boolean;
+export declare function canEditElementText(type: PPTElement['type']): boolean;
+/**
+ * Geometry / type / ring-vs-body identity for one element.
+ * Ignores HTML content except the empty↔text flip that changes hasInteractiveSurface.
+ */
+export declare function hitLayerElementUnchanged(prev: PPTElement, next: PPTElement): boolean;
+/** True when element order and per-element hit identity are unchanged. */
+export declare function hitLayerElementsUnchanged(prev: PPTElement[], next: PPTElement[]): boolean;
+/** Inputs that invalidate HitLayer `hitRects` / `occluderRects` memos. */
+export type HitLayerMemoInput = {
+    elementList: PPTElement[];
+    canvasScale: number;
+    hiddenElementIdList: string[];
+    activeElementIdList: string[];
+    editingElementId: string | null;
+    clipingImageElementId: string;
+    disabled: boolean;
+};
+export type VisualHitPlanInput = {
+    elementList: PPTElement[];
+    canvasScale: number;
+    hiddenElementIdList: Iterable<string>;
+    activeElementIdList: Iterable<string>;
+    editingElementId: string | null;
+    clipingImageElementId: string;
+};
+export type VisualHitPlan = {
+    hitRects: VisualHitRect[];
+    occluderRects: VisualHitRect[];
+    /** Rects of elements painting authored content — they beat empty placeholder slots. */
+    contentRects: VisualHitRect[];
+};
+/**
+ * Selected / editing / clipping boxes leave HitLayer so Operate or the live
+ * editor can own the pointer. Those boxes must still punch holes in every
+ * *lower* hit rect — otherwise the first click works, then hover/click/drag
+ * fall through to the card underneath. Empty placeholder slots additionally
+ * yield to ANY overlapping content rect regardless of z-order.
+ */
+export declare function collectVisualHitPlan(input: VisualHitPlanInput): VisualHitPlan;
+export declare function pointInAnyVisualHitRect(x: number, y: number, rects: VisualHitRect[]): boolean;
+/** Occluders that sit on top of `rect` (same stack level included). Empty placeholder slots yield to every occluder. */
+export declare function occludersAboveRect(rect: VisualHitRect, occluders: VisualHitRect[]): VisualHitRect[];
+/**
+ * Skip rebuilding hit rects when only HTML content changed,
+ * or the lists are reference-equal.
+ */
+export declare function hitLayerSkipRebuild(prev: HitLayerMemoInput, next: HitLayerMemoInput): boolean;
+/** Canvas-space corners of a (possibly rotated) hit rect. */
+export declare function visualHitCorners(rect: VisualHitRect): {
+    x: number;
+    y: number;
+}[];
+export declare function visualHitRectsOverlap(a: VisualHitRect, b: VisualHitRect): boolean;
+export declare function visualHitIntersectsBox(rect: VisualHitRect, box: {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}): boolean;
+/** Elements whose visual hit rect intersects a wrapper-space marquee. */
+export declare function elementIdsIntersectingSelection(elements: PPTElement[], box: {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}, canvasScale: number, hiddenIds?: Iterable<string>): string[];
+export declare function visualHitAabb(rect: VisualHitRect): {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+};
+/**
+ * Clip a hit rect so a higher selected/editing box can keep the pointer.
+ * HitLayer sits above the viewport; without this hole, lower cards steal
+ * hover/click/drag after the top element leaves the hit layer.
+ */
+export declare function hitRectClipPath(rect: VisualHitRect, occluders: VisualHitRect[]): string | undefined;
+/** True when the wrapper-local point sits on a resize handle square. */
+export declare function isPointOnResizeHandle(x: number, y: number, rect: VisualHitRect, directions?: readonly ResizeHandleDirection[]): boolean;
+/** True when the wrapper-local point sits on the inward drag border, not the edit interior. */
+export declare function isPointOnVisualBorder(x: number, y: number, rect: VisualHitRect, options?: {
+    clearResizeHandles?: readonly ResizeHandleDirection[];
+}): boolean;
+export type OperateHitTarget = 'resize' | 'move' | 'edit' | null;
+/**
+ * Selected-element hit kind. Resize handles beat the move ring; the move ring
+ * beats the edit interior. Used as the source of truth for operate-layer stacking.
+ */
+export declare function hitTestOperateTarget(x: number, y: number, rect: VisualHitRect, options: {
+    interactive: boolean;
+    handles?: readonly ResizeHandleDirection[];
+}): OperateHitTarget;
+export declare function retryPendingCaret(elementId: string): void;
+export declare function focusElementEditor(elementId: string, coords?: ClientCoords): void;
+export type { ClientCoords };

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

@@ -0,0 +1,53 @@
+import type { MouseEvent as ReactMouseEvent, TouchEvent as ReactTouchEvent } from 'react';
+/**
+ * Convert pointer events into slide-canvas coordinates.
+ *
+ * The slide `.viewport` is CSS-scaled (`transform: scale(canvasScale)`) and
+ * left unsized so absolute children are not laid out twice. Pair `clientX/Y`
+ * with the `.viewport-wrapper` rect (already in visual pixels) and divide by
+ * canvasScale, times any ancestor CSS zoom (`rect.width / offsetWidth`).
+ */
+export type ReactPointerEvent = ReactMouseEvent | ReactTouchEvent;
+export type PointerLike = MouseEvent | TouchEvent | ReactPointerEvent | {
+    clientX: number;
+    clientY: number;
+};
+export declare function nativePointerEvent(e: ReactPointerEvent | MouseEvent | TouchEvent): MouseEvent | TouchEvent;
+export declare function getPointerClient(e: PointerLike): {
+    x: number;
+    y: number;
+};
+export declare function renderedScale(renderedSize: number, unscaledSize: number, fallback: number): number;
+export declare function clientToCanvasPoint(clientX: number, clientY: number, originX: number, originY: number, scale: number): {
+    x: number;
+    y: number;
+};
+export declare function clientDeltaToCanvas(dx: number, dy: number, scale: number): {
+    x: number;
+    y: number;
+};
+export declare function findSlideViewport(from?: EventTarget | null): HTMLElement | null;
+/**
+ * The slide `.viewport` is intentionally unsized (absolute children + CSS
+ * scale). Measuring it would be 0×0 and assigning it the unscaled slide size
+ * double-applies zoom against `.viewport-wrapper`. Use the wrapper — already
+ * sized to the *visual* slide — and multiply by the store canvas scale.
+ */
+export declare function getScaleRoot(viewport: HTMLElement | null): HTMLElement | null;
+export declare function getViewportRenderedScale(viewport: HTMLElement | null, fallbackScale: number): number;
+export declare function clientToCanvas(e: PointerLike, viewport: HTMLElement, fallbackScale: number): {
+    x: number;
+    y: number;
+};
+/** Wrapper-local visual pixels — same space as HitLayer / `elementVisualHitRect`. */
+export declare function clientToWrapper(e: PointerLike, viewport: HTMLElement): {
+    x: number;
+    y: number;
+};
+export declare function pointerDeltaToCanvas(start: {
+    x: number;
+    y: number;
+}, current: PointerLike, viewport: HTMLElement | null, fallbackScale: number): {
+    x: number;
+    y: number;
+};

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

@@ -0,0 +1,36 @@
+/**
+ * Canvas zoom is the *displayed* scale (canvasScale × 100), not the internal
+ * occupancy percentage. Occupancy is derived so 200% means 200% of the slide
+ * pixel size — independent of how large the editor pane is.
+ */
+export declare const MIN_CANVAS_ZOOM = 10;
+export declare const MAX_CANVAS_ZOOM = 200;
+export declare const CANVAS_ZOOM_STEP = 5;
+/** Wheel pixels that correspond to one CANVAS_ZOOM_STEP. */
+export declare const WHEEL_ZOOM_PX_PER_STEP = 40;
+/**
+ * Chrome PDF viewer / Chromium page-zoom ladder, clipped to 10–200%.
+ * +/- jumps to the next (or previous) stop; values between stops snap directionally.
+ */
+export declare const CANVAS_ZOOM_PRESETS: readonly [10, 25, 33, 50, 67, 75, 80, 90, 100, 110, 125, 150, 175, 200];
+export declare function displayedZoomPercent(canvasScale: number): number;
+export declare function clampCanvasZoom(zoom: number): number;
+/**
+ * Step displayed zoom like Chrome PDF: walk `CANVAS_ZOOM_PRESETS`.
+ * Off-ladder values (wheel) snap to the next stop in that direction.
+ */
+export declare function stepCanvasZoom(current: number, direction: 1 | -1): number;
+export declare function addCanvasZoom(current: number, delta: number): number;
+export declare function wheelDeltaToZoom(deltaPx: number): number;
+/**
+ * Occupancy % that realizes `targetZoom` displayed percent given the current
+ * scale and occupancy. Fallback when the canvas element is not available.
+ */
+export declare function occupancyForDisplayedZoom(targetZoom: number, canvasScale: number, canvasPercentage: number): number;
+/**
+ * Occupancy % from pane + slide geometry so 200% is 200% of the slide pixel
+ * size regardless of a stale canvasScale (rapid +/- and wheel).
+ */
+export declare function occupancyForTargetZoom(targetZoom: number, canvasWidth: number, canvasHeight: number, viewportSize: number, viewportRatio: number): number;
+export declare function getPendingZoom(): number | null;
+export declare function setPendingZoom(zoom: number | null): void;

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

@@ -0,0 +1,9 @@
+/**
+ * Copy text to the clipboard.
+ * @param text Text to copy
+ */
+export declare const copyText: (text: string) => Promise<unknown>;
+export declare const readClipboard: () => Promise<string>;
+export declare const pasteCustomClipboardString: (text: string) => any;
+export declare const pasteExcelClipboardString: (text: string) => string[][] | null;
+export declare const pasteHTMLTableClipboardString: (text: string) => string[][] | null;

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

@@ -0,0 +1 @@
+export declare const clonePlain: <T>(value: T) => T;

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

@@ -0,0 +1,84 @@
+import { type CodeLanguageId, type CodeThemeId } from '../configs/code';
+type HighlighterCore = {
+    loadLanguage: (...langs: unknown[]) => Promise<void>;
+    loadTheme: (...themes: unknown[]) => Promise<void>;
+    getLoadedLanguages: () => string[];
+    getLoadedThemes: () => string[];
+    getLanguage: (...args: unknown[]) => unknown;
+    setTheme: (...args: unknown[]) => unknown;
+    codeToHtml: (code: string, options: {
+        lang: string;
+        theme: string;
+        structure?: 'classic' | 'inline';
+    }) => string;
+    codeToTokens: (code: string, options: {
+        lang: string;
+        theme: string;
+    }) => {
+        tokens: Array<Array<{
+            content: string;
+            offset: number;
+            color?: string;
+            bgColor?: string;
+            fontStyle?: number;
+        }>>;
+        fg?: string;
+        bg?: string;
+    };
+    getTheme: (theme: string) => {
+        bg: string;
+        fg: string;
+    };
+};
+export interface HighlightedCode {
+    html: string;
+    bg: string;
+    fg: string;
+    language: CodeLanguageId;
+    theme: CodeThemeId;
+}
+export declare function getHighlighter(): Promise<HighlighterCore>;
+/** Inner Shiki HTML with token spans + `\n` text nodes, no `.line` / `<br>`. */
+export declare function toEditorHighlightHtml(shikiHtml: string, code: string): string;
+export type HighlightedToken = {
+    content: string;
+    color?: string;
+};
+export type HighlightedTokens = {
+    lines: HighlightedToken[][];
+    bg: string;
+    fg: string;
+    language: CodeLanguageId;
+    theme: CodeThemeId;
+};
+export declare function highlightCodeTokens(code: string, language: string, theme: string): Promise<HighlightedTokens>;
+export declare function highlightCodeBlock(code: string, language: string, theme: string): Promise<HighlightedCode>;
+/** Warm Shiki + html-to-image so the first on-slide raster is not a cold start. */
+export declare function prefetchCodeRaster(language?: string, theme?: string): void;
+/** Load core + lang + theme. Safe to call before CodeMirror/Shiki highlighting. */
+export declare function prepareHighlighter(language: string, theme: string): Promise<{
+    bg: string;
+    fg: string;
+    language: "bash" | "cpp" | "csharp" | "css" | "go" | "html" | "java" | "javascript" | "json" | "kotlin" | "markdown" | "php" | "plaintext" | "python" | "ruby" | "rust" | "sql" | "swift" | "typescript" | "vue" | "xml" | "yaml";
+    theme: "andromeeda" | "aurora-x" | "ayu-dark" | "ayu-mirage" | "catppuccin-frappe" | "catppuccin-latte" | "catppuccin-macchiato" | "catppuccin-mocha" | "dracula" | "github-dark" | "github-light" | "horizon" | "houston" | "kanagawa-wave" | "laserwave" | "material-theme-ocean" | "material-theme-palenight" | "min-dark" | "min-light" | "monokai" | "night-owl" | "nord" | "one-dark-pro" | "one-light" | "plastic" | "poimandres" | "rose-pine" | "rose-pine-moon" | "synthwave-84" | "tokyo-night" | "vesper" | "vitesse-dark" | "vitesse-light";
+}>;
+/**
+ * Sync inner HTML for tests / non-editor consumers. Call `prepareHighlighter`
+ * first. Uses `structure: 'inline'` so the result round-trips through text.
+ */
+export declare function highlightEditorHtml(code: string, language: string, theme: string): string;
+export type CodeRasterInput = {
+    code: string;
+    language: string;
+    theme: string;
+    fontSize: number;
+    showLineNumbers: boolean;
+};
+/** Real gutter spans so SnapDOM / html-to-image do not depend on CSS counters. */
+export declare function injectBoothLineNumbers(shikiHtml: string, showLineNumbers: boolean): string;
+export declare function codeElementToBoothHtml(el: CodeRasterInput): Promise<string>;
+export declare function renderCodeElementPng(el: CodeRasterInput & {
+    width: number;
+    height: number;
+}): Promise<string>;
+export {};

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

@@ -0,0 +1,44 @@
+import { type CodeEditorPayload } from '../configs/code';
+export type CodePptxRun = {
+    text: string;
+    options: {
+        color: string;
+        breakLine?: boolean;
+    };
+};
+export type CodePptxText = {
+    runs: CodePptxRun[];
+    bg: string;
+    fg: string;
+};
+export declare function hexForPptx(color: string): string;
+export declare function mixHex(fg: string, bg: string, fgWeight: number): string;
+export declare function codeElementToPptxText(el: Pick<CodeEditorPayload, 'code' | 'language' | 'theme' | 'showLineNumbers'>): Promise<CodePptxText>;
+export declare function codeElementPptxBox(el: {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    fontSize: number;
+    rotate?: number;
+}, colors: Pick<CodePptxText, 'bg' | 'fg'>, ratioPx2Inch: number, ratioPx2Pt: number): {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    fontSize: number;
+    fontFace: string;
+    color: string;
+    fill: {
+        color: string;
+    };
+    valign: 'top';
+    align: 'left';
+    margin: [number, number, number, number];
+    rectRadius: number;
+    lineSpacingMultiple: number;
+    wrap: boolean;
+    vertOverflow: 'clip';
+    horzOverflow: 'clip';
+    rotate?: number;
+};

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

@@ -0,0 +1,17 @@
+export interface Command {
+    do(): void;
+    undo(): void;
+}
+export declare class CommandHistory {
+    private readonly maxSize;
+    private readonly onChange?;
+    private undoStack;
+    private redoStack;
+    constructor(maxSize?: number, onChange?: () => void);
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+    execute(command: Command): void;
+    undo(): boolean;
+    redo(): boolean;
+    clear(): void;
+}

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

@@ -0,0 +1,13 @@
+type Flusher = () => void;
+/** Pending editor/table drafts. Returns an unregister function. */
+export declare function registerCommitFlusher(flush: Flusher): () => void;
+/** Runs after drafts are persisted — canvas list sync, etc. */
+export declare function registerAfterCommitDrain(flush: Flusher): () => void;
+/** Persist in-flight drafts without leaving the editor. */
+export declare function flushCommitQueue(): void;
+/**
+ * Persist every in-flight draft, then sync dependents off the store.
+ * Presentation (and any other Activity hide) must call this before unmounting editors.
+ */
+export declare function drainCommitQueue(): void;
+export {};

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

@@ -0,0 +1,6 @@
+import type { PPTElement } from '../types/slides';
+export { applyLiveLayoutOntoStore } from './liveLayoutCommit';
+export declare const commitAllLiveEditors: () => void;
+export declare const commitAuthoritativeEditors: typeof commitAllLiveEditors;
+/** Flush the active editor, then persist live layout onto store-owned elements. */
+export declare const commitSlideElements: (liveList: PPTElement[]) => PPTElement[];

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

@@ -0,0 +1,30 @@
+/**
+ * Pad the number of digits
+ * @param digit number
+ * @param len length
+ */
+export declare const fillDigit: (digit: number, len: number) => string;
+/**
+ * Check the device
+ */
+export declare const isPC: () => boolean;
+/**
+ * True on macOS / iOS (Command key). False on Windows, Linux, etc.
+ */
+export declare const isMac: () => boolean;
+/**
+ * Check the URL string
+ */
+export declare const isValidURL: (url: string) => boolean;
+/**
+ * Convert HTML to plain text.
+ */
+export declare const htmlToText: (html: string) => string;
+/**
+ * Compare floating-point numbers.
+ */
+export declare const isFloatEqual: (a: number, b: number, epsilon?: number) => boolean;
+/**
+ * Round a number to a fixed number of fraction digits.
+ */
+export declare const toFixed: (num: number, fractionDigits?: number) => number;

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

@@ -0,0 +1,10 @@
+/**
+ * Encrypt
+ * @param msg String to be encrypted
+ */
+export declare const encrypt: (msg: string) => string;
+/**
+ * Decrypt
+ * @param ciphertext String to be decrypted
+ */
+export declare const decrypt: (ciphertext: string) => string;

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

@@ -0,0 +1,8 @@
+/** Compact a CSS length so pixel-units can split it (`13.5 pt` → `13.5pt`). */
+export declare const compactCssLength: (raw: string) => string;
+/** Convert a CSS length to px. Unknown / keyword / % values return undefined. */
+export declare const cssLengthToPx: (raw: string | null | undefined, basePx: number) => number | undefined;
+export declare const cssLengthParts: (raw: string | null | undefined, basePx: number) => {
+    px?: number;
+    em?: number;
+};

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

@@ -0,0 +1,4 @@
+/** Map local class names through a CSS module; leave unknown tokens (parent hashes) intact.
+ *  Local names emit both the hashed module class and the original token so
+ *  `:global(.name)` pierce selectors still match. */
+export declare function bindStyles(styles: Record<string, string>): (...args: Array<string | number | false | null | undefined | Record<string, unknown> | Array<unknown>>) => string;

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

@@ -0,0 +1,25 @@
+import Dexie, { type EntityTable } from 'dexie';
+import type { Patch } from 'immer';
+import type { Slide, SlideTemplate, SlideTheme } from '../types/slides';
+export interface writingBoardImg {
+    id: string;
+    dataURL: string;
+}
+export interface Snapshot {
+    id: number;
+    index: number;
+    title?: string;
+    theme?: SlideTheme;
+    viewportSize?: number;
+    viewportRatio?: number;
+    templates?: SlideTemplate[];
+    slides?: Slide[];
+    patches?: Patch[];
+    inversePatches?: Patch[];
+}
+export declare const deleteDiscardedDB: () => Promise<void>;
+declare const db: Dexie & {
+    snapshots: EntityTable<Snapshot, 'id'>;
+    writingBoardImgs: EntityTable<writingBoardImg, 'id'>;
+};
+export { db };

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

@@ -0,0 +1,19 @@
+export type DebounceOptions = {
+    leading?: boolean;
+    trailing?: boolean;
+};
+type DebounceConfig = DebounceOptions & {
+    maxWait?: number;
+};
+export type Debounced<T extends (...args: never[]) => void> = ((...args: Parameters<T>) => void) & {
+    cancel: () => void;
+    flush: () => void;
+};
+/**
+ * Lodash-compatible debounce: trailing by default, optional leading, cancel, flush.
+ * `maxWait` is what makes throttle a real throttle (invoke at least every wait in a burst).
+ */
+export declare function debounce<T extends (...args: never[]) => void>(fn: T, wait: number, options?: DebounceConfig): Debounced<T>;
+/** Throttle is debounce with maxWait = wait. Defaults: leading and trailing both on. */
+export declare function throttle<T extends (...args: never[]) => void>(fn: T, wait: number, options?: DebounceOptions): Debounced<T>;
+export {};

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

@@ -0,0 +1,11 @@
+import type { Slide } from '../types/slides';
+export type PaintedSlide = Pick<Slide, 'id' | 'elements' | 'background' | 'type'>;
+export type PaintedSlideDiff = {
+    added: string[];
+    removed: string[];
+    contentChanged: string[];
+    movedOnly: string[];
+    zOrderChanged: boolean;
+    backgroundChanged: boolean;
+};
+export declare function diffPaintedSlide(prev: PaintedSlide | undefined, next: PaintedSlide | undefined): PaintedSlideDiff;