@snowcone-app/canvas 0.1.0

package/dist/utils/WorkerExportManager.d.ts

@@ -0,0 +1,185 @@
+import { ExportConfig } from '../workers/export-protocol';
+import { ArtboardElement } from '../core/ArtboardElement';
+import { BaseElement } from '../core/BaseElement';
+/** Result of a worker export operation returning a data URL string. */
+export interface WorkerExportResult {
+    /** Base64-encoded data URL of the exported image. */
+    dataUrl: string;
+    artboardId: string;
+    artboardName: string;
+    /** Time spent rendering in the worker (ms). */
+    renderTime: number;
+    /** Total round-trip time including serialization and messaging (ms). */
+    totalTime: number;
+    /** Time the main thread was blocked during the export (should be near 0ms). */
+    mainThreadBlockTime: number;
+}
+/** Result of a worker export operation returning a Blob. More efficient for API uploads. */
+export interface WorkerBlobExportResult {
+    /** Binary Blob of the exported image. */
+    blob: Blob;
+    artboardId: string;
+    artboardName: string;
+    /** Time spent rendering in the worker (ms). */
+    renderTime: number;
+    /** Total round-trip time including serialization and messaging (ms). */
+    totalTime: number;
+    /** Time the main thread was blocked during the export (should be near 0ms). */
+    mainThreadBlockTime: number;
+}
+export interface ProgressEvent {
+    requestId: string;
+    progress: number;
+    message: string;
+}
+export type ProgressListener = (event: ProgressEvent) => void;
+/**
+ * Manages a Web Worker for non-blocking artboard export using OffscreenCanvas.
+ *
+ * Features:
+ * - Promise-based export API (data URL and Blob)
+ * - Request queuing for concurrent export operations
+ * - Bitmap caching in the worker (reduces main-thread memory by ~50%)
+ * - Automatic crash recovery with fallback to main-thread rendering
+ * - Idle timeout for worker cleanup (30s default)
+ * - Progress reporting via listeners
+ */
+export declare class WorkerExportManager {
+    private worker;
+    private workerBlobUrl;
+    private pendingRequests;
+    private requestQueue;
+    private blobRequestQueue;
+    private isProcessingQueue;
+    private isReady;
+    private readyPromise;
+    private requestIdCounter;
+    private workerCrashCount;
+    private readonly MAX_CRASHES_BEFORE_FALLBACK;
+    private lastCrashTime;
+    private readonly CRASH_RESET_TIMEOUT;
+    private progressListeners;
+    private idleTimeout;
+    private readonly IDLE_TIMEOUT_MS;
+    /**
+     * Add progress listener
+     */
+    onProgress(listener: ProgressListener): () => void;
+    /**
+     * Remove progress listener
+     */
+    offProgress(listener: ProgressListener): void;
+    /**
+     * Emit progress event to all listeners
+     */
+    private emitProgress;
+    /**
+     * Reset idle timer
+     */
+    private resetIdleTimer;
+    /**
+     * Register bitmaps with the worker's cache.
+     * This transfers the bitmaps to the worker (zero-copy) where they are cached.
+     */
+    private registerBitmapsWithWorker;
+    /**
+     * Clear all bitmaps from the worker's cache.
+     * Also clears the main thread's registration tracking.
+     * Call this when exiting editor mode to free memory.
+     */
+    clearWorkerBitmapCache(): void;
+    /**
+     * Clear a specific element's bitmaps from the worker's cache.
+     * Call this when an element is removed or its image source changes.
+     */
+    clearWorkerBitmap(elementId: string): void;
+    /**
+     * Check if browser supports OffscreenCanvas and Web Workers
+     */
+    static supportsWorkerExport(): boolean;
+    /**
+     * Initialize the worker
+     */
+    initialize(): Promise<void>;
+    /**
+     * Restart worker after crash
+     */
+    private restartWorker;
+    /**
+     * Export artboard to data URL using worker
+     * Uses request queue for concurrent exports
+     */
+    exportArtboardToDataURL(artboard: ArtboardElement, elements: BaseElement[], config?: ExportConfig): Promise<WorkerExportResult>;
+    /**
+     * Export artboard to Blob using worker
+     * Returns a Blob directly - more efficient for API uploads
+     * Uses request queue for concurrent exports
+     */
+    exportArtboardToBlob(artboard: ArtboardElement, elements: BaseElement[], config?: ExportConfig): Promise<WorkerBlobExportResult>;
+    /**
+     * Process the request queue
+     */
+    private processQueue;
+    /**
+     * Execute a single export request
+     */
+    private executeExportRequest;
+    /**
+     * Process the blob request queue
+     */
+    private processBlobQueue;
+    /**
+     * Execute a single blob export request
+     */
+    private executeBlobExportRequest;
+    /**
+     * Handle messages from worker
+     */
+    private handleWorkerMessage;
+    /**
+     * Handle successful export completion (dataUrl)
+     */
+    private handleExportComplete;
+    /**
+     * Handle successful blob export completion
+     */
+    private handleBlobExportComplete;
+    /**
+     * Handle export error
+     */
+    private handleExportError;
+    /**
+     * Handle worker errors
+     */
+    private handleWorkerError;
+    /**
+     * Terminate the worker
+     */
+    terminate(): void;
+    /**
+     * Get worker status
+     */
+    getStatus(): {
+        isReady: boolean;
+        pendingRequests: number;
+        queuedRequests: number;
+        crashCount: number;
+    };
+}
+/**
+ * Get the shared singleton `WorkerExportManager` instance.
+ *
+ * Creates the instance on first call. The shared instance is used internally
+ * by `ExportManager` and is the recommended way to access the worker for
+ * advanced cache control (e.g., `getSharedWorkerExportManager().clearWorkerBitmapCache()`).
+ *
+ * @returns The shared WorkerExportManager instance
+ */
+export declare function getSharedWorkerExportManager(): WorkerExportManager;
+/**
+ * Terminate the shared `WorkerExportManager` instance and release its Web Worker.
+ *
+ * Call this during app cleanup to free worker resources. The next call to
+ * `getSharedWorkerExportManager()` will create a fresh instance.
+ */
+export declare function terminateSharedWorkerExportManager(): void;

package/dist/utils/clickProtection.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Click Protection Utility
+ *
+ * Provides a mechanism to prevent deselection when clicking on overlays
+ * like color pickers, context menus, etc.
+ *
+ * Usage:
+ * 1. Call `protectNextClick()` before showing an overlay
+ * 2. In your click handler, check `shouldProtectClick()` before deselecting
+ * 3. The protection automatically expires after one click or a timeout
+ */
+declare class ClickProtectionManager {
+    isProtectedFlag: boolean;
+    timeout: ReturnType<typeof setTimeout> | null;
+    timeoutDuration: number;
+    constructor();
+    /**
+     * Protect the next click from triggering deselection
+     * Automatically expires after one check or timeout
+     */
+    protectNextClick(): void;
+    /**
+     * Check if the current click should be protected
+     * This consumes the protection (one-time use)
+     * @returns {boolean} true if click should be protected, false otherwise
+     */
+    shouldProtectClick(): boolean;
+    /**
+     * Manually clear protection (useful for cleanup)
+     */
+    clearProtection(): void;
+    /**
+     * Check if protection is currently active (without consuming it)
+     * @returns {boolean} true if protection is active
+     */
+    isProtected(): boolean;
+}
+export declare const clickProtection: ClickProtectionManager;
+export {};

package/dist/utils/cn.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Simple utility for conditionally joining classNames together
+ */
+export declare function cn(...inputs: (string | undefined | null | false)[]): string;

package/dist/utils/colorConversion.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Color Conversion Utilities for HeroUI v3 Migration
+ *
+ * Converts hex/rgba colors to oklch format required by HeroUI v3.
+ * Uses the culori library for accurate color space transformations.
+ *
+ * @see https://culori.js.org/
+ * @see docs/THEME_COLOR_MAPPING.md for color documentation
+ */
+/**
+ * Convert a hex color to oklch format
+ *
+ * @param hex - Hex color string (e.g., "#a4e636", "#fff", "a4e636")
+ * @returns oklch string (e.g., "oklch(0.85 0.18 125)")
+ *
+ * @example
+ * hexToOklch("#a4e636") // "oklch(0.85 0.18 125)"
+ * hexToOklch("#ffffff") // "oklch(1 0 0)"
+ * hexToOklch("#000000") // "oklch(0 0 0)"
+ */
+export declare function hexToOklch(hex: string): string;
+/**
+ * Convert an rgba color to oklch format
+ *
+ * @param r - Red component (0-255)
+ * @param g - Green component (0-255)
+ * @param b - Blue component (0-255)
+ * @param a - Alpha component (0-1), optional
+ * @returns oklch string with alpha channel if provided (e.g., "oklch(0.85 0.18 125 / 0.2)")
+ *
+ * @example
+ * rgbaToOklch(164, 230, 54) // "oklch(0.85 0.18 125)"
+ * rgbaToOklch(164, 230, 54, 0.2) // "oklch(0.85 0.18 125 / 0.2)"
+ * rgbaToOklch(255, 255, 255, 1) // "oklch(1 0 0)"
+ */
+export declare function rgbaToOklch(r: number, g: number, b: number, a?: number): string;
+/**
+ * Parse a CSS color string (hex or rgba) and convert to oklch
+ *
+ * @param cssColor - CSS color string (e.g., "#a4e636", "rgba(164, 230, 54, 0.2)")
+ * @returns oklch string
+ *
+ * @example
+ * cssToOklch("#a4e636") // "oklch(0.85 0.18 125)"
+ * cssToOklch("rgba(164, 230, 54, 0.2)") // "oklch(0.85 0.18 125 / 0.2)"
+ * cssToOklch("rgb(255, 255, 255)") // "oklch(1 0 0)"
+ */
+export declare function cssToOklch(cssColor: string): string;
+/**
+ * Batch convert all theme colors from hex/rgba to oklch
+ *
+ * @param themeColors - Object with CSS color values (hex/rgba strings)
+ * @returns Object with same keys but oklch values
+ *
+ * @example
+ * const lightTheme = {
+ *   "--color-bg-primary": "#ffffff",
+ *   "--color-accent-primary": "#a4e636",
+ *   "--color-accent-light": "rgba(164, 230, 54, 0.2)"
+ * };
+ *
+ * const oklchTheme = convertThemeToOklch(lightTheme);
+ * // {
+ * //   "--color-bg-primary": "oklch(1 0 0)",
+ * //   "--color-accent-primary": "oklch(0.85 0.18 125)",
+ * //   "--color-accent-light": "oklch(0.85 0.18 125 / 0.2)"
+ * // }
+ */
+export declare function convertThemeToOklch(themeColors: Record<string, string>): Record<string, string>;
+/**
+ * Generate a CSS variable declaration for oklch color
+ *
+ * @param varName - CSS variable name (with or without -- prefix)
+ * @param cssColor - CSS color string (hex/rgba)
+ * @returns CSS variable declaration string
+ *
+ * @example
+ * generateCssVar("color-accent-primary", "#a4e636")
+ * // "--color-accent-primary: oklch(0.85 0.18 125);"
+ */
+export declare function generateCssVar(varName: string, cssColor: string): string;
+/**
+ * Generate complete CSS theme file with oklch colors
+ *
+ * @param themeName - Name of the theme (e.g., "light", "dark", "ocean")
+ * @param themeColors - Object with CSS color values
+ * @returns Complete CSS theme file content
+ *
+ * @example
+ * const lightColors = {
+ *   "color-bg-primary": "#ffffff",
+ *   "color-accent-primary": "#a4e636"
+ * };
+ *
+ * const css = generateThemeCss("light", lightColors);
+ * // [data-theme="light"] {
+ * //   --color-bg-primary: oklch(1 0 0);
+ * //   --color-accent-primary: oklch(0.85 0.18 125);
+ * // }
+ */
+export declare function generateThemeCss(themeName: string, themeColors: Record<string, string>): string;

package/dist/utils/documentColors.d.ts

@@ -0,0 +1,108 @@
+import { BaseElement } from '../core/BaseElement.js';
+import { ArtboardElement } from '../core/ArtboardElement.js';
+/**
+ * Collect every vector colour in the design. Synchronous.
+ *
+ * @param elements - Top-level elements (groups recurse internally)
+ * @param artboards - Optional. When provided, `backgroundColor` from
+ *   each artboard is included (real exported background; the UI-only
+ *   `previewBackgroundColor` is intentionally skipped — it's the
+ *   shirt-colour preview, not part of the artwork).
+ */
+export declare function collectDocumentColors(elements: ReadonlyArray<BaseElement>, artboards?: ReadonlyArray<ArtboardElement>): Set<string>;
+type RGB = {
+    r: number;
+    g: number;
+    b: number;
+};
+/**
+ * Median-cut quantisation. Returns the average colour of each box.
+ *
+ * Why this beats a frequency histogram for our use case: a frequency
+ * histogram returns the most-populated buckets, which means a smooth
+ * gradient (sunset reds spread across many adjacent buckets) loses
+ * to a flat region (solid black sky) even when the gradient is the
+ * visually salient subject. Median cut splits by *spread* in colour
+ * space, so red, orange, and yellow each get their own bucket.
+ *
+ * @internal exported for tests
+ */
+export declare function medianCut(pixels: RGB[], targetBuckets: number): RGB[];
+/**
+ * Redmean ΔE — a cheap perceptual-distance approximation. Pure
+ * Euclidean RGB distance treats (50,0,0) vs (0,0,50) as identical,
+ * which is wrong because the eye is more sensitive to green than red
+ * or blue. Redmean weights each channel by the average of the two
+ * reds, which biases the metric toward perceived difference at low
+ * cost. See https://www.compuphase.com/cmetric.htm.
+ *
+ * Returned distance is roughly comparable to a CIE-76 ΔE: ~25 means
+ * "noticeably different," ~50+ means "obviously different."
+ *
+ * @internal exported for tests
+ */
+export declare function redmeanDistance(a: RGB, b: RGB): number;
+/**
+ * Drop palette entries that are visually indistinguishable from one
+ * we already kept. Walks in input order, so callers should pre-sort
+ * by importance (we sort by population — bigger boxes first — so
+ * the most-prominent shade in a "near-duplicate" cluster wins).
+ *
+ * @internal exported for tests
+ */
+export declare function dedupeByPerceptualDistance(palette: RGB[], threshold: number): RGB[];
+/**
+ * Pick a diverse palette from a population-sorted candidate list via
+ * furthest-point sampling. The first candidate is taken as the anchor
+ * (most populous). Each subsequent pick maximises the minimum redmean
+ * distance to every already-picked colour, so the row spans the image's
+ * actual colour variation instead of N shades of whatever hue dominates.
+ *
+ * Candidates closer than `threshold` to an already-picked colour are
+ * skipped — that's the dedupe step folded into the same pass. Stops
+ * when there are no further candidates above the threshold.
+ *
+ * @internal exported for tests
+ */
+export declare function furthestPointPalette(candidates: RGB[], paletteSize: number, threshold: number): RGB[];
+/**
+ * Extract up to `paletteSize` dominant colours from an image URL.
+ *
+ * Implementation:
+ *  1. Draw the image into a small offscreen canvas (48×48). Smaller
+ *     than the source, but enough resolution for dominant colours
+ *     and *much* faster than walking the full image.
+ *  2. Sample every pixel; skip fully-transparent and near-white
+ *     (background swamps the palette and isn't useful for matching).
+ *  3. Run median cut to produce ~2× the requested palette size
+ *     (gives dedupe headroom).
+ *  4. Sort by box population so visually-prominent shades come first
+ *     within near-duplicate clusters.
+ *  5. Drop near-duplicates by redmean-weighted ΔE — without this
+ *     step a photo with a big black region returns 3 indistinguishable
+ *     blacks instead of black + the actual subject colours.
+ *  6. Truncate to `paletteSize`.
+ *
+ * Cached per URL in module-scope (cache survives component unmount;
+ * wiped on hard reload).
+ *
+ * Requires `crossOrigin="anonymous"` on the source image. If the
+ * image is CORS-tainted, `getImageData` throws and we cache an empty
+ * array. Per CLAUDE.md "CORS Cache Poisoning" all canvas images
+ * already set this.
+ */
+export declare function extractImagePalette(imageUrl: string, paletteSize?: number): Promise<string[]>;
+/**
+ * Walk every ImageElement (recursing into groups), pull the unique
+ * URLs, extract a small palette per image, and return the deduped
+ * union. Order is "first image first, top-N per image" so the row
+ * has predictable colours. Returns [] if no images.
+ */
+export declare function collectImageColors(elements: ReadonlyArray<BaseElement>, paletteSize?: number): Promise<string[]>;
+/**
+ * Test-only: clear the in-memory palette caches so unit tests start
+ * from a known state.
+ * @internal
+ */
+export declare function _resetImagePaletteCache(): void;
+export {};

package/dist/utils/featureApplied.d.ts

@@ -0,0 +1,14 @@
+import { BaseElement } from '../core/BaseElement.js';
+export interface FeatureAppliedFlags {
+    rotation: boolean;
+    opacity: boolean;
+    stroke: boolean;
+    knockout: boolean;
+    distress: boolean;
+    imageMask: boolean;
+    /** Image: `transformData.borderRadius`. */
+    cornerRadius: boolean;
+    /** Shape: `transformData.fillOpacity`. */
+    shapeTransparency: boolean;
+}
+export declare function getFeatureApplied(element: BaseElement | null | undefined): FeatureAppliedFlags;

package/dist/utils/google-fonts-loader.d.ts

@@ -0,0 +1,67 @@
+/**
+ * google-fonts-loader — fetch a Google Font's @font-face CSS for the
+ * weights we care about (regular + bold) and return the concatenated CSS.
+ *
+ * The per-weight fetch shape exists to dodge a Google Fonts CSS2 quirk:
+ * a request for `wght@400;700` returns an *empty* HTTP-200 body when the
+ * font doesn't have all the requested weights — single-weight display
+ * fonts like Bangers (only 400) trip this and silently lose their CSS,
+ * leaving canvas/export rendering with the serif fallback. Browsers
+ * don't hit it because Chrome's User-Agent gets a different server code
+ * path; `fetch()` from a Web Worker uses a minimal UA and Google takes
+ * the strict path.
+ *
+ * Solution: ask for each weight individually. Available weights return
+ * their CSS, missing weights return empty (HTTP 200 + no body, or HTTP
+ * 400), and we concatenate whatever survived. The downstream parser is
+ * happy with one or many `@font-face` blocks.
+ *
+ * Used by: `workers/export-worker.ts` (the bundle inlines this helper
+ * so the worker can be a single self-contained file).
+ */
+/** Build the Google Fonts CSS2 URL for one weight. */
+export declare function buildGoogleFontUrl(family: string, weight: number): string;
+/**
+ * Fetch the @font-face CSS for `family` at every weight in `WEIGHTS_TO_REQUEST`,
+ * concatenating successful responses with newlines. Failures (network error,
+ * non-2xx, empty body) become empty strings — the result is only "" when
+ * *every* weight failed, which signals "this font genuinely isn't on Google
+ * Fonts" to the caller.
+ */
+export declare function fetchGoogleFontCss(family: string, fetchImpl?: typeof fetch): Promise<string>;
+/** Parsed @font-face block — what `parseFontFaces` extracts from CSS. */
+export interface ParsedFontFace {
+    /** URL of the WOFF2/TTF — extracted from `src: url(...)`. */
+    fontFileUrl: string;
+    /** FontFace descriptors derived from the CSS rule. */
+    descriptors: FontFaceDescriptors;
+}
+/**
+ * Parse the concatenated CSS returned by `fetchGoogleFontCss` into a list of
+ * @font-face descriptors. Handles the multi-block shape Google returns
+ * (one rule per `unicode-range` subset) and preserves all relevant
+ * descriptor fields the FontFace constructor accepts.
+ */
+export declare function parseFontFaces(css: string): ParsedFontFace[];
+/**
+ * Fetch a font file as bytes and construct a FontFace from the binary.
+ *
+ * Why not just `new FontFace(family, 'url(...)').load()`?
+ *
+ * iOS Safari's FontFace API uses an internal fetch path for `url(...)` srcs
+ * that doesn't reliably honor cross-origin font assets — even when the
+ * server (e.g. fonts.gstatic.com) returns `Access-Control-Allow-Origin: *`,
+ * Safari logs `Cannot load <woff2>` and silently fails the activation. The
+ * symptom in production: the live editor canvas eventually renders the
+ * correct face (the `<link>` path activates DOM-side), but the export
+ * worker — which only has the FontFace API to work with — silently falls
+ * back to serif. Fetching the bytes ourselves with `fetch()` (Safari's
+ * cross-origin fetch CORS handling is correct) and passing the
+ * `ArrayBuffer` to `new FontFace(family, buffer)` skips Safari's broken
+ * url-fetch path and the activation works reliably.
+ *
+ * Returns `null` if the binary fetch fails (CORS, 404, network) — caller
+ * should treat that as "this subset isn't available" and continue with the
+ * other subsets. A font with at least one loaded subset still renders.
+ */
+export declare function loadFontFaceFromUrl(family: string, parsed: ParsedFontFace, fetchImpl?: typeof fetch): Promise<FontFace | null>;

package/dist/utils/logger.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Centralized debug logger utility
+ * Replaces scattered console.log statements with a consistent, filterable logging system
+ */
+export declare enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3,
+    NONE = 4
+}
+declare class Logger {
+    private level;
+    private enabled;
+    /**
+     * Set the minimum log level to display
+     */
+    setLevel(level: LogLevel): void;
+    /**
+     * Enable or disable logging globally
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * Get current log level
+     */
+    getLevel(): LogLevel;
+    /**
+     * Check if logging is enabled
+     */
+    isEnabled(): boolean;
+    /**
+     * Log debug message (verbose, development only)
+     */
+    debug(_message: string, ..._args: unknown[]): void;
+    /**
+     * Log info message (general information)
+     */
+    info(message: string, ...args: unknown[]): void;
+    /**
+     * Log warning message (potential issues)
+     */
+    warn(message: string, ...args: unknown[]): void;
+    /**
+     * Log error message (critical issues)
+     */
+    error(message: string, ...args: unknown[]): void;
+    /**
+     * Create a scoped logger with a prefix for a specific module
+     */
+    scope(scopeName: string): ScopedLogger;
+}
+/**
+ * Scoped logger for specific modules/components
+ */
+declare class ScopedLogger {
+    private logger;
+    private scopeName;
+    constructor(logger: Logger, scopeName: string);
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+}
+export declare const logger: Logger;
+export declare const createLogger: (scopeName: string) => ScopedLogger;
+export {};

package/dist/utils/selectionPreservation.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Selection Preservation Utility
+ *
+ * Provides a declarative way to mark UI elements that should NOT
+ * trigger canvas deselection when clicked.
+ *
+ * Usage:
+ * 1. Add data-preserve-selection attribute to any UI container
+ * 2. The document-level handler in EditorContext checks for this attribute
+ *
+ * @example
+ * // Direct attribute
+ * <div data-preserve-selection>
+ *   <MyToolbar />
+ * </div>
+ *
+ * // Spread helper
+ * <div {...preserveSelectionProps}>
+ *   <MySettings />
+ * </div>
+ */
+/** Data attribute name for marking selection-preserving elements */
+export declare const PRESERVE_SELECTION_ATTR = "data-preserve-selection";
+/**
+ * Check if a click event should preserve the current selection.
+ * Walks up the DOM tree from the click target checking for the
+ * data-preserve-selection attribute.
+ *
+ * Performance: O(depth) where depth is typically 10-20 nodes.
+ * This is negligible compared to other click handling operations.
+ *
+ * @param target - The event target element
+ * @returns true if selection should be preserved, false otherwise
+ */
+export declare function shouldPreserveSelection(target: EventTarget | null): boolean;
+/**
+ * React props helper - spread this on containers that should preserve selection
+ * @example <div {...preserveSelectionProps}>...</div>
+ */
+export declare const preserveSelectionProps: {
+    readonly "data-preserve-selection": "";
+};

package/dist/utils/textCursorUtils.d.ts

@@ -0,0 +1,39 @@
+import { TextElement } from '../core/TextElement';
+/**
+ * Get word boundaries at a given character index.
+ * Returns the start and end indices of the word containing the given index.
+ * Words are separated by whitespace.
+ *
+ * @param text The text to search in
+ * @param index The character index to find the word at
+ * @returns Object with start and end indices of the word
+ */
+export declare function getWordBoundaryAt(text: string, index: number): {
+    start: number;
+    end: number;
+};
+/**
+ * Get line info for a cursor position - which line it's on and the X position within that line
+ */
+export declare function getCursorLineInfo(element: TextElement, cursorIndex: number): {
+    lineIndex: number;
+    lineCount: number;
+    xPositionInLine: number;
+    lineStartIndex: number;
+};
+/**
+ * Move cursor up or down by one line, trying to maintain the same X position
+ */
+export declare function moveCursorVertically(element: TextElement, cursorIndex: number, direction: 'up' | 'down'): number;
+/**
+ * Calculates the cursor character index based on a point relative to the text element's
+ * top-left corner (local coordinates).
+ *
+ * @param element The text element
+ * @param point Local coordinates {x, y} relative to the element's visual bounding box top-left
+ * @returns The character index closest to the point
+ */
+export declare function getCursorIndexFromPoint(element: TextElement, point: {
+    x: number;
+    y: number;
+}): number;

package/dist/utils/textUtils.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Text utility functions
+ */
+/**
+ * Strip glyph characters from text for display purposes
+ * Removes PUA (Private Use Area) characters used for alternate glyphs
+ *
+ * @param text - Text that may contain glyph characters
+ * @returns Text with glyph characters removed
+ */
+export declare function stripGlyphs(text: string): string;