kritzel-react 0.1.30 → 0.1.32

package/dist/types/kritzel-stencil/src/classes/tools/base-tool.class.d.ts

@@ -0,0 +1,20 @@
+import { KritzelTool } from '../../components';
+import { KritzelSerializable } from '../../interfaces/serializable.interface';
+import { KritzelCore } from '../core/core.class';
+export declare class KritzelBaseTool implements KritzelTool, KritzelSerializable {
+    __class__: string;
+    name: string;
+    protected readonly _core: KritzelCore;
+    constructor(core: KritzelCore);
+    onActivate(): void;
+    onDeactivate(): void;
+    handlePointerDown(_event: PointerEvent): void;
+    handlePointerMove(_event: PointerEvent): void;
+    handlePointerUp(_event: PointerEvent): void;
+    handleWheel(_event: WheelEvent): void;
+    serialize(): {
+        __class__: string;
+        name: string;
+    };
+    deserialize(object: any): KritzelSerializable;
+}

package/dist/types/kritzel-stencil/src/classes/tools/brush-tool.class.d.ts

@@ -0,0 +1,14 @@
+import { KritzelBaseTool } from './base-tool.class';
+import { KritzelCore } from '../core/core.class';
+import { ThemeAwareColor } from '../../constants/color-palette.constants';
+export declare class KritzelBrushTool extends KritzelBaseTool {
+    color: ThemeAwareColor;
+    size: number;
+    opacity: number;
+    palette: ThemeAwareColor[];
+    private _currentPathId;
+    constructor(core: KritzelCore);
+    handlePointerDown(event: PointerEvent): void;
+    handlePointerMove(event: PointerEvent): void;
+    handlePointerUp(event: PointerEvent): void;
+}

package/dist/types/kritzel-stencil/src/classes/tools/eraser-tool.class.d.ts

@@ -0,0 +1,9 @@
+import { KritzelBaseTool } from './base-tool.class';
+import { KritzelCore } from '../core/core.class';
+export declare class KritzelEraserTool extends KritzelBaseTool {
+    touchStartTimeout: any;
+    constructor(core: KritzelCore);
+    handlePointerDown(event: PointerEvent): void;
+    handlePointerMove(event: PointerEvent): void;
+    handlePointerUp(event: PointerEvent): void;
+}

package/dist/types/kritzel-stencil/src/classes/tools/image-tool.class.d.ts

@@ -0,0 +1,15 @@
+import { KritzelBaseTool } from './base-tool.class';
+import { KritzelCore } from '../core/core.class';
+export declare class KritzelImageTool extends KritzelBaseTool {
+    fileInput: HTMLInputElement | null;
+    maxCompressionSize: number;
+    constructor(core: KritzelCore);
+    onActivate(): void;
+    private openFilePicker;
+    private setupFileInput;
+    private handleFileSelect;
+    private readFile;
+    private createKritzelImage;
+    private addImageToStore;
+    private handleCancel;
+}

package/dist/types/kritzel-stencil/src/classes/tools/line-tool.class.d.ts

@@ -0,0 +1,19 @@
+import { KritzelBaseTool } from './base-tool.class';
+import { KritzelCore } from '../core/core.class';
+import { LineArrowConfig } from '../../interfaces/arrow-head.interface';
+import { ThemeAwareColor } from '../../constants/color-palette.constants';
+export declare class KritzelLineTool extends KritzelBaseTool {
+    color: ThemeAwareColor;
+    size: number;
+    opacity: number;
+    palette: ThemeAwareColor[];
+    /** Arrow head configuration for lines created with this tool */
+    arrows?: LineArrowConfig;
+    private _startX;
+    private _startY;
+    constructor(core: KritzelCore);
+    handlePointerDown(event: PointerEvent): void;
+    handlePointerMove(event: PointerEvent): void;
+    handlePointerUp(event: PointerEvent): void;
+    private selectLineAndSwitchTool;
+}

package/dist/types/kritzel-stencil/src/classes/tools/selection-tool.class.d.ts

@@ -0,0 +1,54 @@
+import { KritzelMoveHandler } from '../handlers/move.handler';
+import { KritzelResizeHandler } from '../handlers/resize.handler';
+import { KritzelRotationHandler } from '../handlers/rotation.handler';
+import { KritzelSelectionHandler } from '../handlers/selection.handler';
+import { KritzelBaseTool } from './base-tool.class';
+import { KritzelHoverHandler } from '../handlers/hover.handler';
+import { KritzelCore } from '../core/core.class';
+import { KritzelLineHandleHandler } from '../handlers/line-handle.handler';
+import { ToolConfigDefinition } from '../../interfaces/tool-config.interface';
+import { ThemeAwareColor } from '../../constants/color-palette.constants';
+import { LineArrowConfig } from '../../interfaces/arrow-head.interface';
+export declare class KritzelSelectionTool extends KritzelBaseTool {
+    selectionHandler: KritzelSelectionHandler;
+    moveHandler: KritzelMoveHandler;
+    hoverHandler: KritzelHoverHandler;
+    resizeHandler: KritzelResizeHandler;
+    rotationHandler: KritzelRotationHandler;
+    lineHandleHandler: KritzelLineHandleHandler;
+    palette: ThemeAwareColor[];
+    /** Returns true if there are objects in the selection group */
+    hasSelection(): boolean;
+    /** Returns the selected objects or empty array */
+    getSelectedObjects(): any[];
+    private flattenObjects;
+    get color(): ThemeAwareColor;
+    set color(value: ThemeAwareColor);
+    get opacity(): number;
+    set opacity(value: number);
+    get size(): number;
+    set size(value: number);
+    get fillColor(): ThemeAwareColor;
+    set fillColor(value: ThemeAwareColor);
+    get fontFamily(): string;
+    set fontFamily(value: string);
+    get arrows(): LineArrowConfig;
+    set arrows(value: LineArrowConfig);
+    /** Returns the tool config for selected objects, or null if no selection */
+    getToolConfig(): ToolConfigDefinition | null;
+    /**
+     * Refreshes the selection group's dimensions after object properties that affect size have changed.
+     * Uses requestAnimationFrame to ensure the DOM has been updated before measuring.
+     */
+    private refreshSelectionGroupDimensions;
+    constructor(core: KritzelCore);
+    handlePointerDown(event: PointerEvent): void;
+    handlePointerMove(event: PointerEvent): void;
+    handlePointerUp(event: PointerEvent): void;
+    private getSelectedObject;
+    private getHandleType;
+    private isHandleSelected;
+    private isRotationHandleSelected;
+    private isLineHandleSelected;
+    private getLineHandleType;
+}

package/dist/types/kritzel-stencil/src/classes/tools/shape-tool.class.d.ts

@@ -0,0 +1,39 @@
+import { KritzelBaseTool } from './base-tool.class';
+import { KritzelCore } from '../core/core.class';
+import { ShapeType } from '../../enums/shape-type.enum';
+import { ThemeAwareColor } from '../../constants/color-palette.constants';
+export declare class KritzelShapeTool extends KritzelBaseTool {
+    shapeType: ShapeType;
+    fillColor: ThemeAwareColor;
+    strokeColor: ThemeAwareColor;
+    strokeWidth: number;
+    opacity: number;
+    fontFamily: string;
+    fontSize: number;
+    fontColor: ThemeAwareColor;
+    palette: ThemeAwareColor[];
+    private startX;
+    private startY;
+    private isDrawing;
+    private currentShape;
+    constructor(core: KritzelCore);
+    handlePointerDown(event: PointerEvent): void;
+    handlePointerMove(event: PointerEvent): void;
+    handlePointerUp(event: PointerEvent): void;
+    /**
+     * Start drawing a shape. Following the same pattern as LineTool/BrushTool:
+     * - Store screen coordinates for startX, startY
+     * - Set translateX/Y to -viewportTranslateX/Y (viewport offset)
+     * - Set x, y to the actual screen position
+     * - Let updateDimensions() convert to world coordinates
+     */
+    private startDrawing;
+    /**
+     * Update shape size during drawing. Following the same pattern as LineTool:
+     * - Use screen coordinates directly
+     * - The shape's x, y, width, height are all in screen space
+     * - updateDimensions() handles conversion to world coordinates
+     */
+    private updateShapeSize;
+    private finishDrawing;
+}

package/dist/types/kritzel-stencil/src/classes/tools/text-tool.class.d.ts

@@ -0,0 +1,13 @@
+import { KritzelBaseTool } from './base-tool.class';
+import { KritzelCore } from '../core/core.class';
+import { ThemeAwareColor } from '../../constants/color-palette.constants';
+export declare class KritzelTextTool extends KritzelBaseTool {
+    fontFamily: string;
+    fontSize: number;
+    fontColor: ThemeAwareColor;
+    opacity: number;
+    palette: ThemeAwareColor[];
+    constructor(core: KritzelCore);
+    handlePointerDown(event: PointerEvent): void;
+    handlePointerUp(event: PointerEvent): void;
+}

package/dist/types/kritzel-stencil/src/components/core/kritzel-engine/kritzel-engine.d.ts

@@ -0,0 +1,111 @@
+import { EventEmitter } from '@stencil/core';
+import { KritzelTool } from '../../../interfaces/tool.interface';
+import { KritzelViewport } from '../../../classes/core/viewport.class';
+import { KritzelKeyHandler } from '../../../classes/handlers/key.handler';
+import { KritzelBaseTool } from '../../../classes/tools/base-tool.class';
+import { ContextMenuItem } from '../../../interfaces/context-menu-item.interface';
+import { KritzelBrushToolConfig, KritzelLineToolConfig, KritzelShapeToolConfig, KritzelTextToolConfig } from '../../../interfaces/toolbar-control.interface';
+import { KritzelContextMenuHandler } from '../../../classes/handlers/context-menu.handler';
+import { KritzelBaseObject } from '../../../classes/objects/base-object.class';
+import { KritzelWorkspace } from '../../../classes/core/workspace.class';
+import { KritzelEngineState } from '../../../interfaces/engine-state.interface';
+import { KritzelCore } from '../../../classes/core/core.class';
+import { KritzelSyncConfig } from '../../../interfaces/sync-config.interface';
+import { KritzelUndoState } from '../../../interfaces/undo-state.interface';
+import { ThemeName } from '../../../interfaces/theme.interface';
+import { KritzelShortcut } from '../../../interfaces/shortcut.interface';
+export declare class KritzelEngine {
+    host: HTMLElement;
+    workspace?: KritzelWorkspace;
+    syncConfig?: KritzelSyncConfig;
+    onWorkspaceChange(newWorkspace: KritzelWorkspace | null): void;
+    activeTool: KritzelTool;
+    globalContextMenuItems: ContextMenuItem[];
+    objectContextMenuItems: ContextMenuItem[];
+    scaleMax: number;
+    validateScaleMax(newValue: number): void;
+    scaleMin: number;
+    validateScaleMin(newValue: number): void;
+    cursorTarget?: HTMLElement;
+    onCursorTargetChange(newValue: HTMLElement | undefined): void;
+    /** When true, objects are drawn at a fixed visual size regardless of zoom level */
+    lockDrawingScale: boolean;
+    onLockDrawingScaleChange(newValue: boolean): void;
+    /** The current theme to apply to the editor */
+    theme: ThemeName;
+    onThemeChange(newValue: ThemeName): void;
+    isEngineReady: EventEmitter<KritzelEngineState>;
+    activeToolChange: EventEmitter<KritzelBaseTool>;
+    objectsSelectionChange: EventEmitter<void>;
+    workspacesChange: EventEmitter<KritzelWorkspace[]>;
+    longpress: EventEmitter<PointerEvent>;
+    objectsChange: EventEmitter<KritzelBaseObject[]>;
+    undoStateChange: EventEmitter<KritzelUndoState>;
+    objectsInViewportChange: EventEmitter<KritzelBaseObject<Element>[]>;
+    forceUpdate: number;
+    triggerSelectionChange(): Promise<void>;
+    handleWheel(ev: any): void;
+    handlePointerDown(ev: PointerEvent): void;
+    private throttledPointerMoveMulti;
+    handlePointerMove(ev: PointerEvent): void;
+    handlePointerUp(ev: PointerEvent): void;
+    handlePointerCancel(ev: PointerEvent): void;
+    handleLongPress(ev: CustomEvent<PointerEvent>): void;
+    handleContextMenu(ev: PointerEvent): void;
+    handleResize(): void;
+    handleKeyDown(ev: any): void;
+    handleKeyUp(ev: any): void;
+    preventDoubleTapZoomOnTouchDevices(ev: MouseEvent): void;
+    registerTool(toolName: string, toolClass: any, toolConfig?: KritzelTextToolConfig | KritzelBrushToolConfig | KritzelLineToolConfig | KritzelShapeToolConfig): Promise<KritzelBaseTool>;
+    changeActiveTool(tool: KritzelBaseTool): Promise<void>;
+    disable(): Promise<void>;
+    enable(): Promise<void>;
+    delete(): Promise<void>;
+    copy(): Promise<void>;
+    paste(x: number, y: number): Promise<void>;
+    bringForward(object?: KritzelBaseObject<any>): Promise<void>;
+    sendBackward(object?: KritzelBaseObject<any>): Promise<void>;
+    bringToFront(object?: KritzelBaseObject<any>): Promise<void>;
+    sendToBack(object?: KritzelBaseObject<any>): Promise<void>;
+    group(): Promise<void>;
+    ungroup(): Promise<void>;
+    undo(): Promise<void>;
+    redo(): Promise<void>;
+    hideContextMenu(): Promise<void>;
+    getObjectById<T extends KritzelBaseObject>(id: string): Promise<T | null>;
+    addObject<T extends KritzelBaseObject>(object: T): Promise<T | null>;
+    updateObject<T extends KritzelBaseObject>(object: T, updatedProperties: Partial<T>): Promise<T | null>;
+    removeObject<T extends KritzelBaseObject>(object: T): Promise<T | null>;
+    getSelectedObjects(): Promise<KritzelBaseObject<any>[]>;
+    getDisplayableShortcuts(): Promise<Omit<KritzelShortcut, 'action' | 'condition'>[]>;
+    selectObjects(objects: KritzelBaseObject[]): Promise<void>;
+    selectAllObjectsInViewport(): Promise<void>;
+    clearSelection(): Promise<void>;
+    centerObjectInViewport(object: KritzelBaseObject): Promise<KritzelBaseObject<HTMLElement | SVGElement>>;
+    backToContent(): Promise<boolean>;
+    getCopiedObjects(): Promise<KritzelBaseObject[]>;
+    getScreenshot(format?: 'png' | 'svg'): Promise<string>;
+    exportViewportAsPng(): Promise<void>;
+    exportViewportAsSvg(): Promise<void>;
+    createWorkspace(workspace: KritzelWorkspace): Promise<KritzelWorkspace | null>;
+    updateWorkspace(workspace: KritzelWorkspace): Promise<void>;
+    deleteWorkspace(workspace: KritzelWorkspace): Promise<void>;
+    getWorkspaces(): Promise<KritzelWorkspace[]>;
+    getActiveWorkspace(): Promise<KritzelWorkspace>;
+    core: KritzelCore;
+    viewport: KritzelViewport;
+    contextMenuHandler: KritzelContextMenuHandler;
+    keyHandler: KritzelKeyHandler;
+    contextMenuElement: HTMLKritzelContextMenuElement | null;
+    private _lastHadSelectionGroup;
+    get isSelecting(): boolean;
+    get isSelectionActive(): boolean;
+    constructor();
+    disconnectedCallback(): void;
+    componentWillLoad(): void;
+    componentDidLoad(): Promise<void>;
+    emitObjectsChange(): void;
+    private _registerStateChangeListeners;
+    private _handleActiveToolChange;
+    render(): import("react").JSX.Element;
+}

package/dist/types/kritzel-stencil/src/components/shared/kritzel-brush-style/kritzel-brush-style.d.ts

@@ -0,0 +1,11 @@
+import { EventEmitter } from '@stencil/core';
+import { DropdownOption } from '../kritzel-dropdown/kritzel-dropdown';
+export interface BrushStyleOption extends DropdownOption {
+}
+export declare class KritzelBrushStyle {
+    type: 'pen' | 'highlighter';
+    brushOptions: BrushStyleOption[];
+    typeChange: EventEmitter<'pen' | 'highlighter'>;
+    handleDropdownValueChange(event: CustomEvent<string>): void;
+    render(): import("react").JSX.Element;
+}

package/dist/types/kritzel-stencil/src/components/shared/kritzel-dropdown/kritzel-dropdown.d.ts

@@ -0,0 +1,46 @@
+import { EventEmitter } from '@stencil/core';
+export interface DropdownOption {
+    value: string;
+    label: string;
+    style?: Record<string, string>;
+}
+export declare class KritzelDropdown {
+    el: HTMLElement;
+    options: DropdownOption[];
+    optionsChanged(): void;
+    value: string;
+    externalValueChanged(newValue: string): void;
+    width?: string;
+    selectStyles?: Record<string, string>;
+    internalValue: string;
+    hasSuffixContent: boolean;
+    hasPrefixContent: boolean;
+    isOpen: boolean;
+    focusedIndex: number;
+    openDirection: 'down' | 'up';
+    valueChanged: EventEmitter<string>;
+    private suffixSlotElement?;
+    private prefixSlotElement?;
+    private triggerElement?;
+    private menuElement?;
+    private wrapperElement?;
+    componentWillLoad(): void;
+    disconnectedCallback(): void;
+    handleDocumentClick(event: MouseEvent): void;
+    handleDocumentKeydown(event: KeyboardEvent): void;
+    private updateInternalValue;
+    private toggleMenu;
+    private openMenu;
+    private calculateMenuDirection;
+    private closeMenu;
+    private selectOption;
+    private handleTriggerKeyDown;
+    private handleMenuKeyDown;
+    private scrollFocusedOptionIntoView;
+    private handleOptionMouseEnter;
+    private evaluateSuffixContent;
+    private evaluatePrefixContent;
+    private getSelectedLabel;
+    private getSelectedStyle;
+    render(): import("react").JSX.Element;
+}

package/dist/types/kritzel-stencil/src/components/shared/kritzel-font-family/kritzel-font-family.d.ts

@@ -0,0 +1,13 @@
+import { EventEmitter } from '@stencil/core';
+export interface FontOption {
+    value: string;
+    label: string;
+}
+export declare class KritzelFontFamily {
+    fontOptions: FontOption[];
+    selectedFontFamily: string;
+    fontFamilyChange: EventEmitter<string>;
+    componentWillLoad(): void;
+    private handleDropdownValueChange;
+    render(): import("react").JSX.Element;
+}

package/dist/types/kritzel-stencil/src/components/shared/kritzel-line-endings/kritzel-line-endings.d.ts

@@ -0,0 +1,21 @@
+import { EventEmitter } from '@stencil/core';
+import { ArrowHeadStyle, LineArrowConfig } from '../../../interfaces/arrow-head.interface';
+export type LineEndingType = 'none' | ArrowHeadStyle;
+export interface LineEndingsValue {
+    start: LineEndingType;
+    end: LineEndingType;
+}
+export declare class KritzelLineEndings {
+    /** Available ending styles */
+    styles: LineEndingType[];
+    /** Current line arrow configuration */
+    value: LineArrowConfig | undefined;
+    valueChange: EventEmitter<LineArrowConfig>;
+    private getStartEnding;
+    private getEndEnding;
+    private handleStartChange;
+    private handleEndChange;
+    private getEndingPath;
+    private renderEndingIcon;
+    render(): import("react").JSX.Element;
+}

package/dist/types/kritzel-stencil/src/components/shared/kritzel-shape-fill/kritzel-shape-fill.d.ts

@@ -0,0 +1,10 @@
+import { EventEmitter } from '@stencil/core';
+export type ShapeFillType = 'transparent' | 'filled';
+export declare class KritzelShapeFill {
+    /** Current fill type */
+    value: ShapeFillType;
+    valueChange: EventEmitter<ShapeFillType>;
+    private handleFillChange;
+    private renderFillIcon;
+    render(): import("react").JSX.Element;
+}

package/dist/types/kritzel-stencil/src/components/ui/kritzel-context-menu/kritzel-context-menu.d.ts

@@ -0,0 +1,21 @@
+import { EventEmitter } from '@stencil/core';
+import { ContextMenuItem } from '../../../interfaces/context-menu-item.interface';
+import { KritzelBaseObject } from '../../../classes/objects/base-object.class';
+export declare class KritzelContextMenu {
+    host: HTMLElement;
+    items: ContextMenuItem[];
+    onItemsChanged(): void;
+    objects: KritzelBaseObject[];
+    actionSelected: EventEmitter<ContextMenuItem>;
+    close: EventEmitter<void>;
+    private processedItems;
+    handleOutsideClick(event: MouseEvent): void;
+    componentWillLoad(): void;
+    componentDidLoad(): void;
+    componentDidUpdate(): void;
+    private adjustPositionToViewport;
+    private handleItemClick;
+    private updateMenuItems;
+    private evaluateProperty;
+    render(): import("react").JSX.Element;
+}

package/dist/types/kritzel-stencil/src/configs/default-brush-tool.config.d.ts

@@ -0,0 +1,2 @@
+import { KritzelBrushToolConfig } from '../interfaces/toolbar-control.interface';
+export declare const DEFAULT_BRUSH_CONFIG: KritzelBrushToolConfig;

package/dist/types/kritzel-stencil/src/configs/default-engine-config.d.ts

@@ -0,0 +1,2 @@
+import { KritzelEngineState } from "../interfaces/engine-state.interface";
+export declare const DEFAULT_ENGINE_CONFIG: KritzelEngineState;

package/dist/types/kritzel-stencil/src/configs/default-line-tool.config.d.ts

@@ -0,0 +1,2 @@
+import { KritzelLineToolConfig } from '../interfaces/toolbar-control.interface';
+export declare const DEFAULT_LINE_TOOL_CONFIG: KritzelLineToolConfig;

package/dist/types/kritzel-stencil/src/configs/default-sync.config.d.ts

@@ -0,0 +1,5 @@
+import { KritzelSyncConfig } from '../interfaces/sync-config.interface';
+/**
+ * Default sync configuration - IndexedDB + BroadcastChannel
+ */
+export declare const DEFAULT_SYNC_CONFIG: KritzelSyncConfig;

package/dist/types/kritzel-stencil/src/configs/default-text-tool.config.d.ts

@@ -0,0 +1,2 @@
+import { KritzelTextToolConfig } from "../interfaces/toolbar-control.interface";
+export declare const DEFAULT_TEXT_CONFIG: KritzelTextToolConfig;

package/dist/types/kritzel-stencil/src/constants/color-palette.constants.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Supported theme modes for color variations
+ */
+export type ThemeMode = 'light' | 'dark';
+/**
+ * Color definition with different values per theme
+ */
+export interface ThemeAwareColor {
+    /** Color value for light theme */
+    light: string;
+    /** Color value for dark theme */
+    dark: string;
+    /** Optional semantic label for the color */
+    label?: string;
+}
+/**
+ * Type for a color palette with theme-aware colors only
+ */
+export type ColorPalette = readonly ThemeAwareColor[];
+/**
+ * Helper function to resolve a color value for a specific theme
+ */
+export declare function resolveColor(color: ThemeAwareColor, theme: ThemeMode): string;
+/**
+ * Default color palette shared across all tool configurations.
+ * This ensures consistency in color options throughout the application.
+ * All colors support theme-specific variations.
+ */
+export declare const DEFAULT_COLOR_PALETTE: ColorPalette;

package/dist/types/kritzel-stencil/src/constants/engine.constants.d.ts

@@ -0,0 +1,2 @@
+export declare const ABSOLUTE_SCALE_MAX = 1000;
+export declare const ABSOLUTE_SCALE_MIN = 0.0001;

package/dist/types/kritzel-stencil/src/enums/event-button.enum.d.ts

@@ -0,0 +1,5 @@
+export declare enum KritzelMouseButton {
+    Left = 0,
+    Middle = 1,
+    Right = 2
+}

package/dist/types/kritzel-stencil/src/enums/handle-type.enum.d.ts

@@ -0,0 +1,6 @@
+export declare enum KritzelHandleType {
+    TopLeft = "top-left",
+    TopRight = "top-right",
+    BottomLeft = "bottom-left",
+    BottomRight = "bottom-right"
+}

package/dist/types/kritzel-stencil/src/enums/shape-type.enum.d.ts

@@ -0,0 +1,5 @@
+export declare enum ShapeType {
+    Rectangle = "rectangle",
+    Ellipse = "ellipse",
+    Triangle = "triangle"
+}

package/dist/types/kritzel-stencil/src/helpers/class.helper.d.ts

@@ -0,0 +1,3 @@
+export declare class KritzelClassHelper {
+    static isInstanceOf<T>(object: any, className: string): object is T;
+}

package/dist/types/kritzel-stencil/src/helpers/color.helper.d.ts

@@ -0,0 +1,33 @@
+import { ThemeAwareColor, ThemeMode } from '../constants/color-palette.constants';
+export declare class KritzelColorHelper {
+    /**
+     * Resolves a color value based on the current theme.
+     * Handles both simple string colors and theme-aware color objects.
+     * @param color - The color to resolve (string or ThemeAwareColor)
+     * @param theme - Optional theme to use. If not provided, uses current theme from ThemeManager
+     * @returns The resolved hex color string, or empty string if color is undefined
+     */
+    static resolveThemeColor(color: ThemeAwareColor | undefined, theme?: ThemeMode): string;
+    /**
+     * Applies opacity to a theme-aware color and returns an rgba string.
+     * @param color - The theme-aware color object
+     * @param opacity - The opacity value between 0 and 1
+     * @param theme - Optional theme to use. If not provided, uses current theme from ThemeManager
+     * @returns The color as an rgba string, or the resolved hex if opacity is 1
+     */
+    static applyOpacity(color: ThemeAwareColor, opacity: number, theme?: ThemeMode): string;
+    /**
+     * Determines the appropriate contrast color (black or white) based on the luminance of the given hex color.
+     * Uses the relative luminance formula: 0.299*R + 0.587*G + 0.114*B
+     * @param hexColor - The hex color string (with or without #)
+     * @returns '#000000' for light backgrounds, '#ffffff' for dark backgrounds
+     */
+    static getContrastColor(hexColor: string): string;
+    /**
+     * Determines the appropriate text color for both light and dark themes based on the fill color.
+     * Returns default theme-appropriate colors if the fill is transparent.
+     * @param fillColor - The theme-aware fill color
+     * @returns A theme-aware color object with appropriate text colors for both themes
+     */
+    static determineTextColor(fillColor: ThemeAwareColor): ThemeAwareColor;
+}

package/dist/types/kritzel-stencil/src/helpers/cursor.helper.d.ts

@@ -0,0 +1,22 @@
+export declare class KritzelCursorHelper {
+    private static _pointerCursor;
+    /**
+     * Returns the custom pointer cursor CSS value.
+     * This can be used instead of `cursor: pointer` for consistent styling.
+     */
+    static getPointerCursor(): string;
+    /**
+     * Returns a custom cursor CSS value with support for rotation.
+     * The icon is retrieved from the KritzelIconRegistry.
+     */
+    static getCursor(options: {
+        iconName: string;
+        rotation?: number;
+        color?: string;
+        size?: number;
+        hotspot?: {
+            x: number;
+            y: number;
+        };
+    }): string;
+}

package/dist/types/kritzel-stencil/src/helpers/devices.helper.d.ts

@@ -0,0 +1,8 @@
+export declare class KritzelDevicesHelper {
+    static isTouchDevice(): boolean;
+    static isAndroid(): boolean;
+    static isIOS(): boolean;
+    static detectOS(): 'iOS' | 'Android' | 'Other';
+    static isMobile(): boolean;
+    static isFirefox(): boolean;
+}

package/dist/types/kritzel-stencil/src/helpers/event.helper.d.ts

@@ -0,0 +1,6 @@
+export declare class KritzelEventHelper {
+    static isRightClick(ev: MouseEvent): boolean;
+    static isLeftClick(ev: MouseEvent): boolean;
+    static isPointerEventOnContextMenu(event: PointerEvent): boolean;
+    static onLongPress(event: PointerEvent, onSuccess: (event: PointerEvent) => void, onCancel?: () => void): () => void;
+}

package/dist/types/kritzel-stencil/src/helpers/geometry.helper.d.ts

@@ -0,0 +1,38 @@
+import { KritzelPoint } from "../interfaces/point.interface";
+import { KritzelPolygon } from "../interfaces/polygon.interface";
+export declare class KritzelGeometryHelper {
+    static doPolygonsIntersect(polygon1: KritzelPolygon, polygon2: KritzelPolygon): boolean;
+    static isPointInPolygon(point: KritzelPoint, polygon: KritzelPoint[]): boolean;
+    static intersectLines(p1a: KritzelPoint, p1b: KritzelPoint, p2a: KritzelPoint, p2b: KritzelPoint): boolean;
+    /**
+     * Finds the intersection point between a line segment and a line segment.
+     * Returns the intersection point or null if no intersection.
+     */
+    static getLineIntersectionPoint(p1a: KritzelPoint, p1b: KritzelPoint, p2a: KritzelPoint, p2b: KritzelPoint): KritzelPoint | null;
+    /**
+     * Finds the closest intersection point between a line segment (from lineStart to lineEnd)
+     * and a polygon. Returns the intersection point closest to lineStart, or null if no intersection.
+     */
+    static getLinePolygonIntersection(lineStart: KritzelPoint, lineEnd: KritzelPoint, polygon: KritzelPolygon): KritzelPoint | null;
+    /**
+     * Generates a polygon approximation of an ellipse.
+     * @param centerX - X coordinate of ellipse center
+     * @param centerY - Y coordinate of ellipse center
+     * @param rx - Horizontal radius
+     * @param ry - Vertical radius
+     * @param segments - Number of segments (more = smoother approximation)
+     * @param rotation - Optional rotation angle in radians
+     */
+    static getEllipsePolygonApproximation(centerX: number, centerY: number, rx: number, ry: number, segments?: number, rotation?: number): KritzelPoint[];
+    /**
+     * Finds the closest intersection point between a line segment and a polygon
+     * defined as an array of points. Returns the intersection closest to lineStart,
+     * or null if no intersection.
+     */
+    static getLinePointsArrayIntersection(lineStart: KritzelPoint, lineEnd: KritzelPoint, polygonPoints: KritzelPoint[]): KritzelPoint | null;
+    /**
+     * Checks if a point is inside a polygon defined as an array of points.
+     * This is a convenience wrapper that works with arbitrary polygon point arrays.
+     */
+    static isPointInPolygonPoints(point: KritzelPoint, polygonPoints: KritzelPoint[]): boolean;
+}

package/dist/types/kritzel-stencil/src/helpers/keyboard.helper.d.ts

@@ -0,0 +1,6 @@
+export declare class KritzelKeyboardHelper {
+    static forceHideKeyboard(): void;
+    static enableInteractiveWidget(): void;
+    static disableInteractiveWidget(): void;
+    static onKeyboardVisibleChanged(callback: (isOpen: boolean) => void): () => void;
+}

package/dist/types/kritzel-stencil/src/helpers/math.helper.d.ts

@@ -0,0 +1,3 @@
+export declare class KritzelMathHelper {
+    static average(a: number, b: number): number;
+}