@flowscape-ui/core-sdk 1.0.0

package/dist/index.d.cts

@@ -0,0 +1,1430 @@
+import Konva from 'konva';
+import * as konva_lib_types from 'konva/lib/types';
+
+interface BaseNodeOptions {
+    id?: string;
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+}
+declare abstract class BaseNode<T extends Konva.Node = Konva.Node> {
+    protected konvaNode: T;
+    readonly id: string;
+    constructor(node: T, options?: BaseNodeOptions);
+    getNode(): T;
+    setPosition({ x, y }: {
+        x: number;
+        y: number;
+    }): void;
+    getPosition(): konva_lib_types.Vector2d;
+    remove(): void;
+}
+
+interface ShapeNodeOptions extends BaseNodeOptions {
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    cornerRadius?: number | number[];
+}
+declare class ShapeNode extends BaseNode<Konva.Rect> {
+    constructor(options: ShapeNodeOptions);
+    setFill(color: string): this;
+    setStroke(color: string): this;
+    setStrokeWidth(width: number): this;
+    setCornerRadius(radius: number | number[]): this;
+    setSize({ width, height }: {
+        width: number;
+        height: number;
+    }): this;
+    getFill(): string | undefined;
+    getStroke(): string | undefined;
+    getStrokeWidth(): number;
+    getCornerRadius(): number;
+}
+
+type Listener<TArgs extends unknown[]> = (...args: TArgs) => void;
+declare class EventBus<TEvents extends {
+    [K in keyof TEvents]: unknown[];
+} = Record<string, unknown[]>> {
+    private _listeners;
+    constructor();
+    get listeners(): Map<string, Listener<TEvents[keyof TEvents & string]>[]>;
+    on<K extends keyof TEvents & string>(event: K, callback: Listener<TEvents[K]>): void;
+    off<K extends keyof TEvents & string>(event: K, callback: Listener<TEvents[K]>): void;
+    once<K extends keyof TEvents & string>(event: K, callback: Listener<TEvents[K]>): void;
+    emit<K extends keyof TEvents & string>(event: K, ...args: TEvents[K]): void;
+}
+
+/**
+ * Типизированные события CoreEngine
+ * Все события строго типизированы для лучшего DX
+ */
+interface CoreEvents {
+    /** Нода была создана и добавлена в мир */
+    'node:created': [node: BaseNode];
+    /** Нода была удалена из мира */
+    'node:removed': [node: BaseNode];
+    /** Нода была выделена */
+    'node:selected': [node: BaseNode];
+    /** Выделение ноды было снято */
+    'node:deselected': [node: BaseNode];
+    /** Нода была изменена (position, size, rotation, etc.) */
+    'node:transformed': [
+        node: BaseNode,
+        changes: {
+            x?: number;
+            y?: number;
+            width?: number;
+            height?: number;
+            rotation?: number;
+            scaleX?: number;
+            scaleY?: number;
+        }
+    ];
+    /** Z-index ноды был изменён */
+    'node:zIndexChanged': [node: BaseNode, oldIndex: number, newIndex: number];
+    /** Группа была создана */
+    'group:created': [group: BaseNode, nodes: BaseNode[]];
+    /** Группа была разгруппирована */
+    'group:ungrouped': [group: BaseNode, nodes: BaseNode[]];
+    /** Множественное выделение создано */
+    'selection:multi:created': [nodes: BaseNode[]];
+    /** Множественное выделение уничтожено */
+    'selection:multi:destroyed': [];
+    /** Выделение полностью снято */
+    'selection:cleared': [];
+    /** Ноды были скопированы в буфер обмена */
+    'clipboard:copy': [nodes: BaseNode[]];
+    /** Ноды были вырезаны в буфер обмена */
+    'clipboard:cut': [nodes: BaseNode[]];
+    /** Ноды были вставлены из буфера обмена */
+    'clipboard:paste': [nodes: BaseNode[]];
+    /** Зум был изменён программно */
+    'camera:setZoom': [{
+        scale: number;
+    }];
+    /** Зум был изменён пользователем (колесо мыши) */
+    'camera:zoom': [{
+        scale: number;
+        position: {
+            x: number;
+            y: number;
+        };
+    }];
+    /** Камера была сброшена */
+    'camera:reset': [];
+    /** Шаг зума был изменён */
+    'camera:zoomStep': [{
+        zoomStep: number;
+    }];
+    /** Шаг панорамирования был изменён */
+    'camera:panStep': [{
+        panStep: number;
+    }];
+    /** Камера была перемещена (панорамирование) */
+    'camera:pan': [{
+        dx: number;
+        dy: number;
+        position: {
+            x: number;
+            y: number;
+        };
+    }];
+    /** Плагин был добавлен */
+    'plugin:added': [pluginName: string];
+    /** Плагин был удалён */
+    'plugin:removed': [pluginName: string];
+    /** Stage был изменён (resize) */
+    'stage:resized': [{
+        width: number;
+        height: number;
+    }];
+}
+
+interface TextNodeOptions extends BaseNodeOptions {
+    text?: string;
+    fontSize?: number;
+    fontFamily?: string;
+    fontStyle?: string;
+    fill?: string;
+    align?: 'left' | 'center' | 'right';
+    padding?: number;
+}
+declare class TextNode extends BaseNode<Konva.Text> {
+    constructor(options?: TextNodeOptions);
+    getText(): string;
+    getFontSize(): number;
+    getFontFamily(): string;
+    getFontStyle(): string;
+    getFill(): string | undefined;
+    getAlign(): 'left' | 'center' | 'right';
+    getPadding(): number;
+    getSize(): {
+        width: number;
+        height: number;
+    };
+    setText(text: string): this;
+    setFontSize(size: number): this;
+    setFontFamily(family: string): this;
+    setFontStyle(style: string): this;
+    setFill(color: string): this;
+    setAlign(align: 'left' | 'center' | 'right'): this;
+    setPadding(padding: number): this;
+    setSize({ width, height }: {
+        width: number;
+        height: number;
+    }): this;
+}
+
+type ImageSource = HTMLImageElement;
+interface ImageNodeOptions extends BaseNodeOptions {
+    image?: ImageSource;
+    src?: string;
+    width?: number;
+    height?: number;
+}
+declare class ImageNode extends BaseNode<Konva.Image> {
+    constructor(options?: ImageNodeOptions);
+    getSize(): {
+        width: number;
+        height: number;
+    };
+    /**
+     * Async loads image from URL and sets it to Konva.Image.
+     * Returns this for chaining.
+     */
+    setSrc(url: string, crossOrigin?: '' | 'anonymous' | 'use-credentials' | undefined): Promise<this>;
+    /**
+     * Set already loaded image source (HTMLImageElement)
+     */
+    setImage(image: ImageSource): this;
+    setSize({ width, height }: {
+        width: number;
+        height: number;
+    }): this;
+    private _loadHTMLImage;
+}
+
+interface CircleNodeOptions extends BaseNodeOptions {
+    radius?: number;
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+}
+declare class CircleNode extends BaseNode<Konva.Circle> {
+    constructor(options?: CircleNodeOptions);
+    getRadius(): number;
+    getFill(): string | undefined;
+    getStroke(): string | undefined;
+    getStrokeWidth(): number;
+    setRadius(radius: number): this;
+    setFill(color: string): this;
+    setStroke(color: string): this;
+    setStrokeWidth(width: number): this;
+}
+
+interface EllipseNodeOptions extends BaseNodeOptions {
+    radiusX?: number;
+    radiusY?: number;
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+}
+declare class EllipseNode extends BaseNode<Konva.Ellipse> {
+    constructor(options?: EllipseNodeOptions);
+    getRadiusX(): number;
+    getRadiusY(): number;
+    getFill(): string | undefined;
+    getStroke(): string | undefined;
+    getStrokeWidth(): number;
+    setRadiusX(value: number): this;
+    setRadiusY(value: number): this;
+    setFill(color: string): this;
+    setStroke(color: string): this;
+    setStrokeWidth(width: number): this;
+}
+
+interface ArcNodeOptions extends BaseNodeOptions {
+    innerRadius?: number;
+    outerRadius?: number;
+    angle?: number;
+    rotation?: number;
+    clockwise?: boolean;
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+}
+declare class ArcNode extends BaseNode<Konva.Arc> {
+    constructor(options?: ArcNodeOptions);
+    getInnerRadius(): number;
+    getOuterRadius(): number;
+    getAngle(): number;
+    isClockwise(): boolean;
+    setInnerRadius(v: number): this;
+    setOuterRadius(v: number): this;
+    setAngle(v: number): this;
+    setRotationDeg(v: number): this;
+    setClockwise(v: boolean): this;
+    setFill(color: string): this;
+    setStroke(color: string): this;
+    setStrokeWidth(width: number): this;
+}
+
+interface ArrowNodeOptions extends BaseNodeOptions {
+    points?: number[];
+    tension?: number;
+    pointerLength?: number;
+    pointerWidth?: number;
+    pointerAtBeginning?: boolean;
+    pointerAtEnding?: boolean;
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+}
+declare class ArrowNode extends BaseNode<Konva.Arrow> {
+    constructor(options?: ArrowNodeOptions);
+    getPoints(): number[];
+    getTension(): number;
+    getPointerLength(): number;
+    getPointerWidth(): number;
+    getPointerAtBeginning(): boolean;
+    getPointerAtEnding(): boolean;
+    setPoints(v: number[]): this;
+    setTension(v: number): this;
+    setPointerLength(v: number): this;
+    setPointerWidth(v: number): this;
+    setPointerAtBeginning(v: boolean): this;
+    setPointerAtEnding(v: boolean): this;
+    setFill(color: string): this;
+    setStroke(color: string): this;
+    setStrokeWidth(width: number): this;
+}
+
+interface RegularPolygonNodeOptions extends BaseNodeOptions {
+    sides?: number;
+    radius?: number;
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+}
+declare class RegularPolygonNode extends BaseNode<Konva.RegularPolygon> {
+    constructor(options?: RegularPolygonNodeOptions);
+    getSides(): number;
+    getRadius(): number;
+    getFill(): string | undefined;
+    getStroke(): string | undefined;
+    getStrokeWidth(): number;
+    setSides(v: number): this;
+    setRadius(v: number): this;
+    setFill(color: string): this;
+    setStroke(color: string): this;
+    setStrokeWidth(width: number): this;
+}
+
+interface StarNodeOptions extends BaseNodeOptions {
+    numPoints?: number;
+    innerRadius?: number;
+    outerRadius?: number;
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+}
+declare class StarNode extends BaseNode<Konva.Star> {
+    constructor(options?: StarNodeOptions);
+    getNumPoints(): number;
+    getInnerRadius(): number;
+    getOuterRadius(): number;
+    getFill(): string | undefined;
+    getStroke(): string | undefined;
+    getStrokeWidth(): number;
+    setNumPoints(v: number): this;
+    setInnerRadius(v: number): this;
+    setOuterRadius(v: number): this;
+    setFill(color: string): this;
+    setStroke(color: string): this;
+    setStrokeWidth(width: number): this;
+}
+
+interface RingNodeOptions extends BaseNodeOptions {
+    innerRadius?: number;
+    outerRadius?: number;
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+}
+declare class RingNode extends BaseNode<Konva.Ring> {
+    constructor(options?: RingNodeOptions);
+    getInnerRadius(): number;
+    getOuterRadius(): number;
+    getFill(): string | undefined;
+    getStroke(): string | undefined;
+    getStrokeWidth(): number;
+    setInnerRadius(v: number): this;
+    setOuterRadius(v: number): this;
+    setFill(color: string): this;
+    setStroke(color: string): this;
+    setStrokeWidth(width: number): this;
+}
+
+interface GroupNodeOptions extends BaseNodeOptions {
+    draggable?: boolean;
+    listening?: boolean;
+    clip?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
+declare class GroupNode extends BaseNode<Konva.Group> {
+    constructor(options?: GroupNodeOptions);
+    addChild(child: Konva.Node | BaseNode): this;
+    removeChild(child: Konva.Node | BaseNode): this;
+    removeAllChildren(): this;
+    getChildren(): Konva.Node[];
+    findByName(name: string): Konva.Node[];
+    setDraggable(v: boolean): this;
+    isDraggable(): boolean;
+    setListening(v: boolean): this;
+    isListening(): boolean;
+    setClip(rect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }): this;
+}
+
+declare class NodeManager {
+    private _layer;
+    private _world;
+    private _nodes;
+    private _stage;
+    private _eventBus;
+    private _batchDrawScheduled;
+    private _listCache;
+    private _listCacheInvalidated;
+    constructor(stage: Konva.Stage, eventBus: EventBus<CoreEvents>);
+    get layer(): Konva.Layer;
+    get world(): Konva.Group;
+    get stage(): Konva.Stage;
+    get eventBus(): EventBus<CoreEvents>;
+    addShape(options: ShapeNodeOptions): ShapeNode;
+    addText(options: TextNodeOptions): TextNode;
+    addImage(options: ImageNodeOptions): ImageNode;
+    addCircle(options: CircleNodeOptions): CircleNode;
+    addEllipse(options: EllipseNodeOptions): EllipseNode;
+    addArc(options: ArcNodeOptions): ArcNode;
+    addStar(options: StarNodeOptions): StarNode;
+    addArrow(options: ArrowNodeOptions): ArrowNode;
+    addRing(options: RingNodeOptions): RingNode;
+    addRegularPolygon(options: RegularPolygonNodeOptions): RegularPolygonNode;
+    addGroup(options: GroupNodeOptions): GroupNode;
+    remove(node: BaseNode): void;
+    findById(id: string): BaseNode | undefined;
+    list(): BaseNode[];
+    /**
+     * Deferred redraw (throttling)
+     * CRITICAL OPTIMIZATION: group multiple node additions
+     */
+    private _scheduleBatchDraw;
+}
+
+interface CameraManagerOptions {
+    stage: Konva.Stage;
+    eventBus: EventBus<CoreEvents>;
+    target?: Konva.Node;
+    initialScale?: number;
+    minScale?: number;
+    maxScale?: number;
+    draggable?: boolean;
+    zoomStep?: number;
+    panStep?: number;
+}
+declare class CameraManager {
+    private _stage;
+    private _eventBus;
+    private _target;
+    private _scale;
+    private _minScale;
+    private _maxScale;
+    private _zoomStep;
+    private _panStep;
+    private _wheelScheduled;
+    private _pendingWheelEvent;
+    constructor(options: CameraManagerOptions);
+    private _initWheelZoom;
+    private _handleWheel;
+    get zoomStep(): number;
+    get panStep(): number;
+    setZoom(zoom: number): void;
+    zoomIn(step?: number): void;
+    zoomOut(step?: number): void;
+    reset(): void;
+    setDraggable(enabled: boolean): void;
+    setZoomStep(step: number): void;
+    setPanStep(step: number): void;
+}
+
+interface LODLevel {
+    minScale: number;
+    maxScale: number;
+    simplify: boolean;
+    disableStroke?: boolean;
+    disableShadow?: boolean;
+    disablePerfectDraw?: boolean;
+}
+interface LODOptions {
+    enabled?: boolean;
+    levels?: LODLevel[];
+}
+/**
+ * LODManager - manager for level of detail
+ *
+ * This is an ADDITIONAL optimization on top of Konva framework.
+ * Konva does not provide automatic LOD, so this implementation is necessary.
+ *
+ * When far away (small scale), it simplifies node rendering:
+ * - Disables stroke via strokeEnabled(false)
+ * - Disables shadow via shadowEnabled(false)
+ * - Disables perfect draw via perfectDrawEnabled(false)
+ *
+ * All methods use built-in Konva API, recommended in the official documentation:
+ * https://konvajs.org/docs/performance/All_Performance_Tips.html
+ *
+ * Performance boost: 20-30% when many nodes are rendered at small scales.
+ */
+declare class LODManager {
+    private _enabled;
+    private _levels;
+    private _currentScale;
+    private _appliedNodes;
+    constructor(options?: LODOptions);
+    /**
+     * Level of detail for current scale
+     */
+    private _getLODLevel;
+    /**
+     * Apply LOD to node based on current scale
+     */
+    applyLOD(node: BaseNode, scale: number): void;
+    /**
+     * Restore original settings for node
+     */
+    private _restoreNode;
+    /**
+     * Apply LOD to all nodes
+     */
+    applyToAll(nodes: BaseNode[], scale: number): void;
+    /**
+     * Restore all nodes to full detail
+     */
+    restoreAll(nodes: BaseNode[]): void;
+    /**
+     * Enable LOD
+     */
+    enable(): void;
+    /**
+     * Disable LOD and restore all nodes
+     */
+    disable(nodes: BaseNode[]): void;
+    /**
+     * Check if LOD is enabled
+     */
+    get enabled(): boolean;
+    /**
+     * Get current scale
+     */
+    get currentScale(): number;
+    /**
+     * Get LOD stats
+     */
+    getStats(): {
+        enabled: boolean;
+        currentScale: number;
+        appliedNodes: number;
+        currentLevel: LODLevel | null;
+    };
+    /**
+     * Set custom LOD levels
+     */
+    setLevels(levels: LODLevel[]): void;
+}
+
+interface VirtualizationStats {
+    total: number;
+    visible: number;
+    hidden: number;
+    cullingRate: number;
+}
+interface VirtualizationOptions {
+    enabled?: boolean;
+    bufferZone?: number;
+    throttleMs?: number;
+    lod?: LODOptions;
+}
+/**
+ * VirtualizationManager - manages node visibility for performance optimization
+ *
+ * IMPORTANT: This is an ADDITIONAL optimization on top of Konva framework.
+ * Konva does not provide automatic viewport virtualization, so this implementation is necessary.
+ *
+ * Main idea: render only nodes that are within the viewport (visible area).
+ * This provides a significant performance boost when dealing with many nodes.
+ *
+ * Optimizations (uses built-in Konva APIs):
+ * 1. visible: false - node is not rendered (Konva recommendation)
+ * 2. listening: false - node does not handle events (Konva recommendation)
+ * 3. Buffer zone - render slightly more than viewport for smoothness
+ * 4. Throttling - limits update frequency
+ * 5. getClientRect() - Konva automatically caches results internally
+ *
+ * Konva documentation: https://konvajs.org/docs/performance/All_Performance_Tips.html
+ */
+declare class VirtualizationManager {
+    private _stage;
+    private _world;
+    private _nodeManager;
+    private _enabled;
+    private _bufferZone;
+    private _throttle;
+    private _viewport;
+    private _visibleNodes;
+    private _hiddenNodes;
+    private _updateScheduled;
+    private _lod;
+    constructor(_stage: Konva.Stage, _world: Konva.Group, _nodeManager: NodeManager, options?: VirtualizationOptions);
+    /**
+     * Updates viewport based on current position and scale of world
+     */
+    private _updateViewport;
+    /**
+     * Gets node bounding box in world coordinates (relative to world)
+     *
+     * OPTIMIZATION: Konva automatically caches getClientRect() results internally,
+     * so additional TTL-cache is not needed. Konva invalidates its cache on transformations,
+     * which is more reliable than our TTL-approach.
+     */
+    private _getNodeBBox;
+    /**
+     * Checks if node is within viewport
+     */
+    private _isNodeVisible;
+    /**
+     * Updates visibility of all nodes
+     */
+    updateVisibility(): void;
+    /**
+     * Sets up event listeners
+     */
+    private _setupListeners;
+    /**
+     * Schedules update for the next frame
+     */
+    private _scheduleUpdate;
+    /**
+     * Enables virtualization
+     */
+    enable(): void;
+    /**
+     * Disables virtualization (shows all nodes)
+     */
+    disable(): void;
+    /**
+     * Returns virtualization statistics
+     */
+    getStats(): VirtualizationStats;
+    /**
+     * Sets buffer zone size
+     */
+    setBufferZone(pixels: number): void;
+    /**
+     * Sets throttle for updates
+     */
+    setThrottle(ms: number): void;
+    /**
+     * Checks if virtualization is enabled
+     */
+    get enabled(): boolean;
+    /**
+     * Returns current viewport
+     */
+    get viewport(): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /**
+     * Forcefully updates visibility (ignores throttle)
+     */
+    forceUpdate(): void;
+    /**
+     * Returns LOD Manager (if enabled)
+     */
+    get lod(): LODManager | null;
+    /**
+     * Destroys manager and releases resources
+     */
+    destroy(): void;
+}
+
+declare abstract class Plugin {
+    protected abstract onAttach(core: CoreEngine): void;
+    protected abstract onDetach(core: CoreEngine): void;
+    attach(core: CoreEngine): void;
+    detach(core: CoreEngine): void;
+}
+
+declare class Plugins {
+    private _core;
+    private _items;
+    constructor(core: CoreEngine, initial?: Plugin[]);
+    addPlugins(plugins: Plugin[]): Plugin[];
+    removePlugins(plugins: Plugin[]): Plugin[];
+    removeAllPlugins(): Plugin[];
+    list(): Plugin[];
+    get(name: string): Plugin | undefined;
+}
+
+interface CoreEngineOptions {
+    container: HTMLDivElement;
+    width?: number;
+    height?: number;
+    autoResize?: boolean;
+    backgroundColor?: string;
+    draggable?: boolean;
+    plugins?: Plugin[];
+    minScale?: number;
+    maxScale?: number;
+    virtualization?: {
+        enabled?: boolean;
+        bufferZone?: number;
+        throttleMs?: number;
+    };
+}
+declare class CoreEngine {
+    private _stage;
+    private _eventBus;
+    private _initialWidth;
+    private _initialHeight;
+    private _autoResize;
+    private _backgroundColor;
+    private _draggable;
+    private _minScale;
+    private _maxScale;
+    private _gridLayer;
+    readonly container: HTMLDivElement;
+    readonly nodes: NodeManager;
+    readonly camera: CameraManager;
+    readonly virtualization: VirtualizationManager;
+    readonly plugins: Plugins;
+    constructor(options: CoreEngineOptions);
+    get eventBus(): EventBus<CoreEvents>;
+    get stage(): Konva.Stage;
+    get gridLayer(): Konva.Layer;
+    get draggable(): boolean;
+    get autoResize(): boolean;
+    get backgroundColor(): string;
+    get initialWidth(): number;
+    get initialHeight(): number;
+    get minScale(): number;
+    get maxScale(): number;
+    setSize({ width, height }: {
+        width: number;
+        height: number;
+    }): void;
+    setBackgroundColor(color: string): void;
+    setDraggable(draggable: boolean): void;
+}
+
+interface LogoOptions {
+    src: string;
+    width: number;
+    height: number;
+    opacity?: number;
+}
+declare class LogoPlugin extends Plugin {
+    private _core?;
+    private _layer?;
+    private _image?;
+    private _src;
+    private _width;
+    private _height;
+    private _opacity;
+    constructor(options: LogoOptions);
+    protected onAttach(core: CoreEngine): void;
+    protected onDetach(core: CoreEngine): void;
+    setOpacity(opacity: number): void;
+    setSize({ width, height }: {
+        width: number;
+        height: number;
+    }): void;
+    setSource(src: string): void;
+    private _setImage;
+    private _loadImageFromString;
+    private _layout;
+}
+
+interface CameraHotkeysOptions {
+    target?: Window | Document | HTMLElement | EventTarget;
+    zoomStep?: number;
+    panStep?: number;
+    ignoreEditableTargets?: boolean;
+    enableArrows?: boolean;
+    enablePanning?: boolean;
+    allowMiddleButtonPan?: boolean;
+    allowRightButtonPan?: boolean;
+    disableContextMenu?: boolean;
+}
+declare class CameraHotkeysPlugin extends Plugin {
+    private _core?;
+    private _options;
+    private _attached;
+    private _panning;
+    private _last;
+    private _prevCursor;
+    private _prevStageDraggable?;
+    constructor(options?: CameraHotkeysOptions);
+    setOptions(patch: Partial<CameraHotkeysOptions>): void;
+    protected onAttach(core: CoreEngine): void;
+    protected onDetach(core: CoreEngine): void;
+    private _onWheelDOM;
+    private _onMouseDownKonva;
+    private _onMouseMoveKonva;
+    private _onMouseUpKonva;
+    private _onMouseLeaveKonva;
+    private _onContextMenuDOM;
+    private _handleKeyDown;
+    private _isEditableTarget;
+    private _isTouchpadWheel;
+    private _pan;
+}
+
+interface MultiGroupControllerDeps {
+    ensureTempMulti: (nodes: BaseNode[]) => void;
+    destroyTempMulti: () => void;
+    commitTempMultiToGroup: () => void;
+    isActive: () => boolean;
+    forceUpdate: () => void;
+    onWorldChanged?: () => void;
+    isInsideTempByTarget?: (target: Konva.Node) => boolean;
+}
+/**
+ * MultiGroupController — thin controller encapsulating work with temporary multi-group.
+ * Actual logic lives in passed dependencies (SelectionPlugin),
+ * thanks to which we don't duplicate code for frames/overlays and behavior.
+ */
+declare class MultiGroupController {
+    private deps;
+    constructor(deps: MultiGroupControllerDeps);
+    ensure(nodes: BaseNode[]): void;
+    destroy(): void;
+    commitToPermanentGroup(): void;
+    isActive(): boolean;
+    forceUpdateOverlays(): void;
+    onWorldChanged(): void;
+    isInsideTempByTarget(target: Konva.Node): boolean;
+}
+
+interface SelectionPluginOptions {
+    dragEnabled?: boolean;
+    enableTransformer?: boolean;
+    deselectOnEmptyClick?: boolean;
+    selectablePredicate?: (node: Konva.Node) => boolean;
+    autoPanEnabled?: boolean;
+    autoPanEdgePx?: number;
+    autoPanMaxSpeedPx?: number;
+}
+/**
+ * Universal selection and dragging plugin for nodes compatible with BaseNode.
+ *
+ * Default behavior:
+ * - Click on node in NodeManager layer selects the node
+ * - Selected node becomes draggable (dragEnabled)
+ * - Click on empty area deselects (deselectOnEmptyClick)
+ * - Optionally enable Konva.Transformer (enableTransformer)
+ */
+declare class SelectionPlugin extends Plugin {
+    private _core?;
+    private _options;
+    private _selected;
+    private _prevDraggable;
+    private _transformer;
+    private _transformerWasVisibleBeforeDrag;
+    private _cornerHandlesWereVisibleBeforeDrag;
+    private _sizeLabelWasVisibleBeforeDrag;
+    private _rotateHandlesWereVisibleBeforeDrag;
+    private _cornerHandlesGroup;
+    private _cornerHandles;
+    private _cornerHandlesSuppressed;
+    private _transformOppositeCorner;
+    private _sizeLabel;
+    private _radiusLabel;
+    private _rotateHandlesGroup;
+    private _rotateHandles;
+    private _rotateDragState;
+    private _rotateCenterAbsStart;
+    private _prevStageDraggableBeforeRotate;
+    private _worldSyncRafId;
+    private _onCameraZoomEvent;
+    private _hoverTr;
+    private _isPointerDown;
+    private _autoPanRafId;
+    private _autoPanActive;
+    private _autoPanEdgePx;
+    private _autoPanMaxSpeedPx;
+    private _draggingNode;
+    private _ratioKeyPressed;
+    private _onGlobalKeyDown;
+    private _onGlobalKeyUp;
+    private _tempMultiSet;
+    private _tempMultiGroup;
+    private _tempMultiTr;
+    private _tempOverlay;
+    private _tempRotateHandlesGroup;
+    private _tempRotateHandles;
+    private _tempPlacement;
+    getMultiGroupController(): MultiGroupController;
+    private _tempMultiSizeLabel;
+    private _tempMultiHitRect;
+    private _multiCtrl;
+    private _startAutoPanLoop;
+    private _stopAutoPanLoop;
+    /**
+     * Deferred redraw (throttling)
+     * Groups multiple batchDraw calls into one
+     */
+    private _scheduleBatchDraw;
+    private _parentGroupDuringChildEdit;
+    private _parentGroupPrevDraggable;
+    private _dragMoveScheduled;
+    private _batchDrawScheduled;
+    private _hoverThrottle;
+    private _uiUpdateDebounce;
+    constructor(options?: SelectionPluginOptions);
+    setOptions(patch: Partial<SelectionPluginOptions>): void;
+    protected onAttach(core: CoreEngine): void;
+    protected onDetach(core: CoreEngine): void;
+    private _onMouseDown;
+    private _select;
+    private _clearSelection;
+    private _ensureTempMulti;
+    private _destroyTempMulti;
+    private _updateTempRotateHandlesPosition;
+    private _updateTempMultiSizeLabel;
+    private _updateTempMultiHitRect;
+    private _commitTempMultiToGroup;
+    private _tryUngroupSelectedGroup;
+    private _ensureHoverTr;
+    private _destroyHoverTr;
+    private _onHoverMoveThrottled;
+    private _onHoverMove;
+    private _onHoverDown;
+    private _onHoverUp;
+    private _onHoverLeave;
+    private _refreshTransformer;
+    private _restyleSideAnchors;
+    private _setupRotateHandles;
+    private _destroyRotateHandles;
+    private _getNodeCenterAbs;
+    private _updateRotateHandlesPosition;
+    private _setupSizeLabel;
+    private _scheduleUIUpdate;
+    private _updateSizeLabel;
+    private _destroySizeLabel;
+    private _isCornerRadiusSupported;
+    private _getCornerRadiusArray;
+    private _setCornerRadiusArray;
+    private _setupCornerRadiusHandles;
+    private _destroyCornerRadiusHandles;
+    private _bakeRectScale;
+    private _updateCornerRadiusHandlesPosition;
+    private _updateCornerRadiusHandlesVisibility;
+    private _ensureRadiusLabel;
+    private _updateRadiusLabelAt;
+    private _showRadiusLabelForCorner;
+    private _hideRadiusLabel;
+    private _destroyRadiusLabel;
+    private _findBaseNodeByTarget;
+    private _onNodeRemoved;
+}
+
+interface GridPluginOptions {
+    stepX?: number;
+    stepY?: number;
+    color?: string;
+    lineWidth?: number;
+    visible?: boolean;
+    minScaleToShow?: number | null;
+    enableSnap?: boolean;
+}
+/**
+ * GridPlugin — draws a grid and implements snap to grid on drag/resize.
+ * Architecture is identical to other plugins: onAttach/onDetach, own layer with Konva.Shape.
+ *
+ * Important points of the current architecture:
+ * - Panning/scale is performed by Stage transformations.
+ * - Nodes are placed on the NodeManager layer (core.nodes.layer), also Transformers are added to it.
+ */
+declare class GridPlugin extends Plugin {
+    private _core?;
+    private _layer;
+    private _shape;
+    private _stepX;
+    private _stepY;
+    private _color;
+    private _lineWidth;
+    private _visible;
+    private _minScaleToShow;
+    private _enableSnap;
+    private _dragMoveHandler;
+    private _nodesAddHandler;
+    private _nodesRemoveHandler;
+    private _redrawScheduled;
+    private _transformersCache;
+    private _cacheInvalidated;
+    constructor(options?: GridPluginOptions);
+    protected onAttach(core: CoreEngine): void;
+    /**
+     * Deferred redraw (throttling)
+     */
+    private _scheduleRedraw;
+    protected onDetach(core: CoreEngine): void;
+    setVisible(visible: boolean): void;
+    get stepX(): number;
+    get stepY(): number;
+    get minScaleToShow(): number | null;
+    setStep(stepX: number, stepY: number): void;
+    setMinScaleToShow(value: number | null): void;
+    setSnap(enabled: boolean): void;
+}
+
+interface RulerPluginOptions {
+    thicknessPx?: number;
+    fontFamily?: string;
+    fontSizePx?: number;
+    color?: string;
+    bgColor?: string;
+    borderColor?: string;
+    enabled?: boolean;
+}
+declare class RulerPlugin extends Plugin {
+    private _core?;
+    private _options;
+    private _layer;
+    private _hGroup?;
+    private _vGroup?;
+    private _hBg?;
+    private _vBg?;
+    private _hTicksShape?;
+    private _vTicksShape?;
+    private _hBorder?;
+    private _vBorder?;
+    private _redrawScheduled;
+    private _lastRedrawTime;
+    private _redrawThrottleMs;
+    private _panThrottleMs;
+    private _cachedActiveGuide;
+    private _cacheInvalidated;
+    private _stepsCache;
+    constructor(options?: RulerPluginOptions);
+    /**
+     * Calculate optimal step for ruler ticks
+     * Uses nice numbers: 1, 2, 5, 10, 20, 50, 100 and so on
+     */
+    private _calculateNiceStep;
+    /**
+     * Format number for display on ruler
+     * Always returns an integer without decimal places
+     */
+    private _formatNumber;
+    /**
+     * Calculate and cache parameters for ticks for current scale
+     */
+    private _getStepsConfig;
+    protected onAttach(core: CoreEngine): void;
+    protected onDetach(core: CoreEngine): void;
+    /**
+     * Get active guide from RulerGuidesPlugin (with caching)
+     */
+    private _getActiveGuideInfo;
+    /**
+     * Invalidate active guide cache
+     */
+    private _invalidateGuideCache;
+    /**
+     * Universal ruler drawing (horizontal or vertical)
+     * @param ctx - canvas context
+     * @param axis - ruler axis ('h' for horizontal, 'v' for vertical)
+     * @param activeGuide - cached active guide info
+     */
+    private _drawRuler;
+    /**
+     * Draw horizontal ruler
+     * @param activeGuide - cached active guide info
+     */
+    private _drawHorizontalRuler;
+    /**
+     * Draw vertical ruler
+     * @param activeGuide - cached active guide info
+     */
+    private _drawVerticalRuler;
+    /**
+     * Full ruler redraw
+     */
+    private _redraw;
+    /**
+     * Deferred redraw with improved throttling
+     * Groups fast zoom/pan events for optimization
+     * @param isPanning - true for panning (more aggressive throttling)
+     */
+    private _scheduleRedraw;
+    show(): void;
+    hide(): void;
+    /**
+     * Toggle ruler visibility
+     */
+    toggle(): void;
+    /**
+     * Check if ruler is visible
+     */
+    isVisible(): boolean;
+}
+
+interface RulerGuidesPluginOptions {
+    guideColor?: string;
+    activeColor?: string;
+    rulerThicknessPx?: number;
+    snapToGrid?: boolean;
+    gridStep?: number;
+}
+declare class RulerGuidesPlugin extends Plugin {
+    private _core?;
+    private _options;
+    private _guidesLayer;
+    private _guides;
+    private _activeGuide;
+    private _draggingGuide;
+    private _rulerLayerCache;
+    private _updateScheduled;
+    private _dragMoveScheduled;
+    private _batchDrawScheduled;
+    constructor(options?: RulerGuidesPluginOptions);
+    protected onAttach(core: CoreEngine): void;
+    protected onDetach(core: CoreEngine): void;
+    /**
+     * Schedules update of guide positions (without throttling for smoothness)
+     */
+    private _scheduleUpdate;
+    /**
+     * Updates positions of all guides when world transform changes
+     */
+    private _updateGuidesPositions;
+    /**
+     * Snaps coordinate to grid
+     */
+    private _snapToGrid;
+    /**
+     * Schedules batchDraw for grouping updates
+     */
+    private _scheduleBatchDraw;
+    /**
+     * Starts creating a guide line from ruler
+     */
+    private _startCreateGuide;
+    private _setActiveGuide;
+    /**
+     * Get active guide
+     */
+    getActiveGuide(): Konva.Line | null;
+    /**
+     * Get active guide info
+     * @returns { type: 'h' | 'v', coord: number } | null
+     */
+    getActiveGuideInfo(): {
+        type: 'h' | 'v';
+        coord: number;
+    } | null;
+    /**
+     * Remove active guide
+     */
+    removeActiveGuide(): void;
+    /**
+     * Get all guides
+     */
+    getGuides(): Konva.Line[];
+    /**
+     * Remove all guides
+     */
+    clearGuides(): void;
+}
+
+interface RulerHighlightPluginOptions {
+    highlightColor?: string;
+    highlightOpacity?: number;
+    rulerThicknessPx?: number;
+}
+/**
+ * RulerHighlightPlugin
+ * Highlights the areas of the coordinate system that are occupied by selected objects
+ * Works only if RulerPlugin and SelectionPlugin are present
+ */
+declare class RulerHighlightPlugin extends Plugin {
+    private _core?;
+    private _options;
+    private _highlightLayer;
+    private _hGroup;
+    private _vGroup;
+    private _hHighlights;
+    private _vHighlights;
+    private _updateDebounce;
+    private _transformersCache;
+    private _cacheInvalidated;
+    constructor(options?: RulerHighlightPluginOptions);
+    protected onAttach(core: CoreEngine): void;
+    protected onDetach(core: CoreEngine): void;
+    /**
+     * Schedules an update (debouncing)
+     */
+    private _scheduleUpdate;
+    /**
+     * Invalidates the cache of transformers
+     */
+    private _invalidateCache;
+    /**
+     * Updates highlights based on selected objects
+     */
+    private _updateHighlights;
+    /**
+     * Recursively collects all individual objects (unwraps groups)
+     */
+    private _collectNodes;
+    /**
+     * Merges overlapping and adjacent segments
+     */
+    private _mergeSegments;
+    /**
+     * Get list of selected Konva nodes (with group unwrapping)
+     * Optimization: cache transformers
+     */
+    private _getSelectedKonvaNodes;
+    /**
+     * Public method to force update highlights
+     * Useful to call when selection changes from outside
+     */
+    update(): void;
+}
+
+interface RulerManagerPluginOptions {
+    enabled?: boolean;
+}
+/**
+ * RulerManagerPlugin
+ * Manages visibility of ruler and guides on Shift+R
+ */
+declare class RulerManagerPlugin extends Plugin {
+    private _core?;
+    private _options;
+    private _visible;
+    constructor(options?: RulerManagerPluginOptions);
+    protected onAttach(core: CoreEngine): void;
+    protected onDetach(_core: CoreEngine): void;
+    /**
+     * Bind keyboard events
+     */
+    private _bindKeyboardEvents;
+    /**
+     * Unbind keyboard events
+     */
+    private _unbindKeyboardEvents;
+    /**
+     * Keyboard event handler
+     */
+    private _handleKeyDown;
+    /**
+     * Toggle visibility of ruler and guides
+     */
+    toggle(): void;
+    /**
+     * Show ruler and guides
+     */
+    show(): void;
+    /**
+     * Hide ruler and guides
+     */
+    hide(): void;
+    /**
+     * Check if ruler is visible
+     */
+    isVisible(): boolean;
+    /**
+     * Remove active guide line
+     * @returns true if guide was removed, false if no active guide
+     */
+    deleteActiveGuide(): boolean;
+}
+
+interface AreaSelectionPluginOptions {
+    rectStroke?: string;
+    rectFill?: string;
+    rectStrokeWidth?: number;
+    rectOpacity?: number;
+    enableKeyboardShortcuts?: boolean;
+}
+/**
+ * AreaSelectionPlugin
+ * - Drag LKM over empty space draws selection rectangle (marquee) in screen coordinates
+ * - All nodes whose client rectangles intersect the rectangle are temporarily grouped
+ * - Click outside — temporary group is removed, nodes return to their original positions
+ * - Ctrl+G — lock in permanent group (GroupNode through NodeManager)
+ * - Ctrl+Shift+G — unlock selected permanent group
+ */
+declare class AreaSelectionPlugin extends Plugin {
+    private _core?;
+    private _layer;
+    private _rect;
+    private _start;
+    private _transformer;
+    private _selecting;
+    private _options;
+    constructor(options?: AreaSelectionPluginOptions);
+    protected onAttach(core: CoreEngine): void;
+    protected onDetach(core: CoreEngine): void;
+    private _finalizeArea;
+    private _clearSelection;
+    private _getSelectionPlugin;
+    private _rectsIntersect;
+    private _findOwningGroupBaseNode;
+    private _isAncestor;
+    private _isPermanentGroupSelected;
+    private _currentGroupNode;
+    private _pointerInsidePermanentGroupBBox;
+}
+
+interface NodeHotkeysOptions {
+    target?: Window | Document | HTMLElement | EventTarget;
+    ignoreEditableTargets?: boolean;
+}
+declare class NodeHotkeysPlugin extends Plugin {
+    private _core?;
+    private _options;
+    private _clipboard;
+    private _selectionPlugin?;
+    constructor(options?: NodeHotkeysOptions);
+    protected onAttach(core: CoreEngine): void;
+    protected onDetach(_core: CoreEngine): void;
+    private _onKeyDown;
+    private _isEditableTarget;
+    private _handleCopy;
+    private _handleCut;
+    private _handlePaste;
+    private _handleDelete;
+    private _getSelectedNodes;
+    private _deleteNodes;
+    private _serializeNode;
+    private _serializeKonvaNode;
+    private _getNodeTypeFromKonva;
+    private _deserializeNode;
+    private _getPastePosition;
+    private _isPointerOnScreen;
+    private _getScreenCenter;
+    private _getClipboardCenter;
+    private _computeSelectionWorldCenter;
+    private _handleMoveUp;
+    private _handleMoveDown;
+    /**
+     * Checks if the node is inside a real group (not the group itself)
+     */
+    private _isNodeInsidePermanentGroup;
+    /**
+     * Checks if the node is inside a real group
+     * - For group itself — do nothing (moveUp/moveDown already applied to the group)
+     * - For node inside group — FORBIDDEN to change z-index
+     */
+    private _syncGroupZIndex;
+}
+
+/**
+ * ThrottleHelper - utility for throttling (limiting the frequency of calls)
+ *
+ * Used to limit the frequency of operation execution to a certain number of times per second.
+ * For example, to limit UI updates to 60 FPS (16ms) or 30 FPS (32ms).
+ *
+ * @example
+ * ```typescript
+ * private _throttle = new ThrottleHelper(16); // 60 FPS
+ *
+ * onMouseMove() {
+ *   if (!this._throttle.shouldExecute()) return;
+ *   // Execute expensive operation
+ * }
+ * ```
+ */
+declare class ThrottleHelper {
+    private _lastTime;
+    private _throttle;
+    /**
+     * @param throttleMs - minimum interval between calls in milliseconds
+     */
+    constructor(throttleMs?: number);
+    /**
+     * Checks if the operation can be executed
+     * @returns true if enough time has passed since the last call
+     */
+    shouldExecute(): boolean;
+    /**
+     * Resets the timer (the next call will be executed immediately)
+     */
+    reset(): void;
+    /**
+     * Changes the throttling interval
+     */
+    setThrottle(throttleMs: number): void;
+    /**
+     * Returns the current throttling interval
+     */
+    getThrottle(): number;
+}
+
+/**
+ * DebounceHelper - utility for debouncing (delayed execution)
+ *
+ * Used to group multiple calls into one through requestAnimationFrame.
+ * Useful for optimizing UI updates - instead of updating on every event,
+ * we update once in the next frame.
+ *
+ * @example
+ * ```typescript
+ * private _debounce = new DebounceHelper();
+ *
+ * onTransform() {
+ *   this._debounce.schedule(() => {
+ *     this._updateUI();
+ *   });
+ * }
+ * ```
+ */
+declare class DebounceHelper {
+    private _scheduled;
+    /**
+     * Schedules execution of callback in the next frame
+     * If already scheduled - ignores repeated calls
+     *
+     * @param callback - function to execute
+     */
+    schedule(callback: () => void): void;
+    /**
+     * Checks if execution is scheduled
+     */
+    isScheduled(): boolean;
+    /**
+     * Cancels scheduled execution
+     * Note: does not cancel already scheduled requestAnimationFrame,
+     * but prevents callback execution
+     */
+    cancel(): void;
+}
+
+export { ArcNode, AreaSelectionPlugin, ArrowNode, CameraHotkeysPlugin, CameraManager, CircleNode, CoreEngine, DebounceHelper, EllipseNode, EventBus, GridPlugin, GroupNode, ImageNode, LogoPlugin, NodeHotkeysPlugin, NodeManager, Plugins, RegularPolygonNode, RingNode, RulerGuidesPlugin, RulerHighlightPlugin, RulerManagerPlugin, RulerPlugin, SelectionPlugin, ShapeNode, StarNode, TextNode, ThrottleHelper };