dytools-canvas-engine 1.0.0 → 1.0.1

package/dist/index.d.cts

@@ -0,0 +1,733 @@
+/**
+ * Core event used throughout pipelines
+ */
+interface CanvasEvent {
+    type: string;
+    targets?: InteractiveObject[];
+    data?: Record<string, any>;
+    stopPropagation?: boolean;
+    tool?: ToolPipelineNode;
+}
+/**
+ * Rectangular interactive zone with resize handles and move region.
+ */
+declare class Zone implements InteractiveObject {
+    private _id;
+    private _rect;
+    private _name;
+    private _showName;
+    private _nameAnchor;
+    private _zIndex;
+    private _visible;
+    private _color;
+    private _selectable;
+    private _movable;
+    private _resizable;
+    get id(): string;
+    set id(value: string);
+    get rect(): Rectangle;
+    get name(): string | null;
+    set name(value: string | null);
+    get showName(): boolean;
+    set showName(value: boolean);
+    get nameAnchor(): "TopRight" | "TopLeft" | "BottomLeft" | "BottomRight" | "Center";
+    set nameAnchor(value: "TopRight" | "TopLeft" | "BottomLeft" | "BottomRight" | "Center");
+    get zIndex(): number;
+    set zIndex(value: number);
+    get visible(): boolean;
+    set visible(value: boolean | undefined);
+    get color(): string;
+    set color(value: string);
+    get selectable(): boolean;
+    set selectable(value: boolean);
+    get movable(): boolean;
+    set movable(value: boolean);
+    get resizable(): boolean;
+    set resizable(value: boolean);
+    private static readonly HANDLE_SIZE;
+    constructor(id: string, x: number, y: number, width: number, height: number, color?: string, isSelectable?: boolean, isMovable?: boolean, isResizable?: boolean, zIndex?: number);
+    constructor(id: string, rect: Rectangle, color?: string, isSelectable?: boolean, isMovable?: boolean, isResizable?: boolean, zIndex?: number);
+    /** Tight bounds of the zone body */
+    getBounds(): Rectangle;
+    /** Bounds including resize handles */
+    getOuterBounds(): Rectangle;
+    /**
+     * Reports which interactions this zone supports at the given point.
+     * If atPoint is null, returns all possible interactions.
+     */
+    getEventInteractions(atPoint: Point | null): EventInteraction[];
+    /**
+     * Returns eight candidate handle positions for resizing, adjusting
+     * their offset (inside, middle, or outside) based on object dimensions.
+     */
+    getResizeHandles(): Array<{
+        rect: Rectangle;
+        handleIndex: number;
+    }>;
+    /** No custom event handling; defaults to flags and tool logic */
+    handleEvent?(evt: CanvasEvent, emitExternal: (type: keyof EngineEventPayloads, payload: EngineEventPayloads[keyof EngineEventPayloads]) => void): void;
+    /** Render the zone with optional handles and selection styling */
+    render(ctx: CanvasRenderingContext2D, flags: Set<string>): void;
+    /**
+     * Return a rgba() string for any valid CSS color with a custom alpha.
+     * Uses the canvas context to normalize named colors, hex, hsl(), etc.
+     */
+    private withAlpha;
+}
+/**
+ * Rectangular interactive zone with resize handles and move region.
+ */
+declare class CircleObject implements InteractiveObject {
+    private _id;
+    private _center;
+    private _radius;
+    private _name;
+    private _showName;
+    private _zIndex;
+    private _visible;
+    private _color;
+    private _selectable;
+    private _movable;
+    private _resizable;
+    get id(): string;
+    set id(value: string);
+    get center(): Point;
+    get name(): string | null;
+    set name(value: string | null);
+    get showName(): boolean;
+    set showName(value: boolean);
+    get zIndex(): number;
+    set zIndex(value: number);
+    get visible(): boolean;
+    set visible(value: boolean | undefined);
+    get color(): string;
+    set color(value: string);
+    get selectable(): boolean;
+    set selectable(value: boolean);
+    get movable(): boolean;
+    set movable(value: boolean);
+    get resizable(): boolean;
+    set resizable(value: boolean);
+    private static readonly HANDLE_SIZE;
+    constructor(id: string, x: number, y: number, radius: number, color?: string, isSelectable?: boolean, isMovable?: boolean, isResizable?: boolean, zIndex?: number);
+    constructor(id: string, center: Point, radius: number, color?: string, isSelectable?: boolean, isMovable?: boolean, isResizable?: boolean, zIndex?: number);
+    /** Tight bounds of the zone body */
+    getBounds(): Rectangle;
+    /** Bounds including resize handles */
+    getOuterBounds(): Rectangle;
+    /**
+     * Reports which interactions this zone supports at the given point.
+     * If atPoint is null, returns all possible interactions.
+     */
+    getEventInteractions(atPoint: Point | null): EventInteraction[];
+    /**
+     * Returns eight candidate handle positions for resizing, adjusting
+     * their offset (inside, middle, or outside) based on object dimensions.
+     */
+    getResizeHandles(): Array<{
+        rect: Rectangle;
+        handleIndex: number;
+    }>;
+    /** No custom event handling; defaults to flags and tool logic */
+    handleEvent?(evt: CanvasEvent, emitExternal: (type: keyof EngineEventPayloads, payload: EngineEventPayloads[keyof EngineEventPayloads]) => void): void;
+    /** Render the zone with optional handles and selection styling */
+    render(ctx: CanvasRenderingContext2D, flags: Set<string>): void;
+    /**
+     * Return a rgba() string for any valid CSS color with a custom alpha.
+     * Uses the canvas context to normalize named colors, hex, hsl(), etc.
+     */
+    private withAlpha;
+}
+/**
+ * PolygonObject: an InteractiveObject representing a polygon with arbitrary points.
+ */
+declare class PolygonObject implements InteractiveObject {
+    id: string;
+    zIndex: number;
+    visible: boolean;
+    color: string;
+    selectable: boolean;
+    movable: boolean;
+    private _points;
+    /**
+     * @param id unique identifier
+     * @param points array of Point objects
+     * @param color stroke color (default "#000000")
+     * @param isSelectable whether selectable (default false)
+     * @param isMovable whether movable (default false)
+     * @param zIndex z-order (default 0)
+     */
+    constructor(id: string, points: Point[], color?: string, isSelectable?: boolean, isMovable?: boolean, zIndex?: number);
+    get points(): Point[];
+    /** Tight bounds of the polygon */
+    getBounds(): Rectangle;
+    /** For polygons, outer bounds = bounds (no handles) */
+    getOuterBounds(): Rectangle;
+    /**
+     * Reports which interactions this polygon supports at the given point.
+     * If atPoint is null, returns all possible interactions.
+     */
+    getEventInteractions(atPoint: Point | null): EventInteraction[];
+    /**
+     * Handles property and move events. (No resize support)
+     */
+    handleEvent?(evt: CanvasEvent, emitExternal: (type: keyof EngineEventPayloads, payload: EngineEventPayloads[keyof EngineEventPayloads]) => void): void;
+    /**
+     * Render the polygon with selection and hover styling.
+     */
+    render(ctx: CanvasRenderingContext2D, flags: Set<string>): void;
+    /**
+     * Return an rgba() string for any valid CSS color with a custom alpha.
+     */
+    private withAlpha;
+}
+/**
+ * EventSource that listens to DOM pointer and wheel events on a canvas
+ * and window resize events, emitting them into the engine.
+ */
+declare class DomEventSource implements EventSource {
+    private listeners;
+    private canvas;
+    constructor(canvas: HTMLCanvasElement);
+    attach(emit: (evt: CanvasEvent) => void, engine: CanvasEngine): void;
+    detach(): void;
+}
+interface EventInteraction {
+    /** The semantic event prefix this region supports, e.g. “move”, “resize”, “select”
+     * but will also support resizeStart and resizeEnd if "resize" is included */
+    eventTypePrefix: string;
+    /**
+     * Which data properties a tool can count on being present on the event.
+     * E.g. “point” (world coords), “handleIndex” for resize, “delta” for drag, etc.
+     */
+    handleIndex?: number;
+}
+/**
+ * Basic interactive object contract
+ */
+interface InteractiveObject {
+    id: string;
+    zIndex: number;
+    visible?: boolean;
+    selectable?: boolean;
+    /** The tight bounds of the object’s geometry (for hit-tests, layout) */
+    getBounds(): Rectangle;
+    /** The full interaction bounds (handles, halos, shadows, etc.) */
+    getOuterBounds(): Rectangle;
+    /** Optional hit-test for pointer events */
+    getEventInteractions(atPoint: Point | null): EventInteraction[];
+    /** Optional event handler for custom events */
+    handleEvent?(evt: CanvasEvent, emitExternal: (type: keyof EngineEventPayloads, payload: EngineEventPayloads[keyof EngineEventPayloads]) => void): void;
+    /** Render the object, given selection/hover flags */
+    render(ctx: CanvasRenderingContext2D, flags: Set<string>): void;
+}
+/**
+ * Converts raw inputs into semantic pipeline events
+ */
+interface EventSource {
+    attach(emit: (evt: CanvasEvent) => void, engine: CanvasEngine): void;
+    detach?(): void;
+}
+/**
+ * Converts semantic events into higher-level gestures
+ */
+interface GestureRecognizer {
+    process(evt: CanvasEvent, emit: (evt: CanvasEvent) => void): void;
+}
+/**
+ * Consumes semantic events and drives object interactions
+ */
+interface ToolPipelineNode {
+    priority?: number;
+    processToolEvent(evt: CanvasEvent, emit: (evt: CanvasEvent) => void, emitExternal: (type: keyof EngineEventPayloads, payload: EngineEventPayloads[keyof EngineEventPayloads]) => void, engine: CanvasEngine, lock: ToolLock): void;
+}
+declare const EngineEventType: {
+    readonly ObjectPositionChanged: "object:positionchanged";
+    readonly ObjectResized: "object:resized";
+    readonly ObjectMoved: "object:moved";
+    readonly ObjectColorChanged: "object:colorchanged";
+    readonly ObjectZIndexChanged: "object:zindexchanged";
+    readonly ObjectSelectableChanged: "object:selectablechanged";
+    readonly ObjectMovableChanged: "object:movablechanged";
+    readonly ObjectResizableChanged: "object:resizablechanged";
+    readonly ObjectVisibleChanged: "object:visiblechanged";
+    readonly ObjectChanged: "object:changed";
+    readonly ObjectSelected: "object:selected";
+    readonly ObjectDeselected: "object:deselected";
+    readonly ObjectFlagsAdded: "object:flagsadded";
+    readonly ObjectFlagsRemoved: "object:flagsremoved";
+    readonly ObjectAdded: "object:added";
+    readonly ObjectRemoved: "object:removed";
+    readonly ViewportChanged: "viewport:changed";
+    readonly DrawingCompleted: "drawing:completed";
+    readonly EngineStarted: "engine:started";
+    readonly EngineError: "engine:error";
+    readonly EngineBackgroundChanged: "engine:backgroundchanged";
+    readonly EngineRenderStarted: "engine:renderstarted";
+    readonly EngineRenderCompleted: "engine:rendercompleted";
+};
+type EngineEventType = typeof EngineEventType[keyof typeof EngineEventType];
+interface EngineEventPayloads {
+    [EngineEventType.ObjectPositionChanged]: {
+        object: InteractiveObject;
+        oldPosition: Rectangle;
+        newPosition: Rectangle;
+    };
+    [EngineEventType.ObjectResized]: {
+        object: InteractiveObject;
+        oldSize: Size;
+        newSize: Size;
+    };
+    [EngineEventType.ObjectMoved]: {
+        object: InteractiveObject;
+        oldPoint: Point;
+        newPoint: Point;
+    };
+    [EngineEventType.ObjectColorChanged]: {
+        object: InteractiveObject;
+        oldColor: string;
+        newColor: string;
+    };
+    [EngineEventType.ObjectZIndexChanged]: {
+        object: InteractiveObject;
+        oldZIndex: number;
+        newZIndex: number;
+    };
+    [EngineEventType.ObjectSelectableChanged]: {
+        object: InteractiveObject;
+        oldSelectable: boolean;
+        newSelectable: boolean;
+    };
+    [EngineEventType.ObjectMovableChanged]: {
+        object: InteractiveObject;
+        oldMovable: boolean;
+        newMovable: boolean;
+    };
+    [EngineEventType.ObjectResizableChanged]: {
+        object: InteractiveObject;
+        oldResizable: boolean;
+        newResizable: boolean;
+    };
+    [EngineEventType.ObjectVisibleChanged]: {
+        object: InteractiveObject;
+        oldVisible: boolean;
+        newVisible: boolean;
+    };
+    [EngineEventType.ObjectChanged]: {
+        object: InteractiveObject;
+        property: string;
+        oldValue: unknown;
+        newValue: unknown;
+    };
+    [EngineEventType.ObjectSelected]: {
+        object: InteractiveObject;
+    };
+    [EngineEventType.ObjectDeselected]: {
+        object: InteractiveObject;
+    };
+    [EngineEventType.ObjectFlagsAdded]: {
+        object: InteractiveObject;
+        addedFlags: string[];
+        currentFlags: string[];
+    };
+    [EngineEventType.ObjectFlagsRemoved]: {
+        object: InteractiveObject;
+        removedFlags: string[];
+        currentFlags: string[];
+    };
+    [EngineEventType.ObjectAdded]: {
+        object: InteractiveObject;
+    };
+    [EngineEventType.ObjectRemoved]: {
+        object: InteractiveObject;
+    };
+    [EngineEventType.DrawingCompleted]: {
+        rect: Rectangle;
+        maxZ: number;
+    };
+    [EngineEventType.ViewportChanged]: {
+        oldPan: Vector;
+        newPan: Vector;
+        oldZoom: number;
+        newZoom: number;
+    };
+    [EngineEventType.EngineStarted]: {};
+    [EngineEventType.EngineError]: {
+        error: Error;
+        message: string;
+    };
+    [EngineEventType.EngineRenderStarted]: {};
+    [EngineEventType.EngineRenderCompleted]: {};
+    [EngineEventType.EngineBackgroundChanged]: {
+        newImage: HTMLImageElement;
+        newWidth: number;
+        newHeight: number;
+        oldWidth: number;
+        oldHeight: number;
+    };
+}
+/**
+ * Renders overlays, handles, or decorations each frame
+ */
+interface RenderPipelineNode {
+    renderBeforeAll?(ctx: CanvasRenderingContext2D, engine: CanvasEngine): void;
+    renderBeforeObject?(ctx: CanvasRenderingContext2D, engine: CanvasEngine, obj: InteractiveObject): void;
+    renderAfterObject?(ctx: CanvasRenderingContext2D, engine: CanvasEngine, obj: InteractiveObject): void;
+    renderAfterAll?(ctx: CanvasRenderingContext2D, engine: CanvasEngine): void;
+}
+interface InteractionEntry {
+    object: InteractiveObject;
+    interaction: EventInteraction;
+}
+interface CanvasEngineOptions {
+    initialZoom?: number;
+    initialPan?: {
+        x: number;
+        y: number;
+    };
+    defaultMode?: string;
+    addTimerEventSource?: boolean;
+    proxyObjectsForEvents?: boolean;
+}
+interface ModeConfig {
+    tools: string[];
+    renderers?: RenderPipelineNode[];
+    /**
+     * Optional per-event hook where a mode can inspect every CanvasEvent
+     * and imperatively switch modes by calling switchMode(name).
+     */
+    handleEvent?: (evt: CanvasEvent, engine: CanvasEngine) => void;
+}
+/**
+ * Main orchestrator: pipelines, objects, and flags
+ */
+declare class CanvasEngine {
+    private readonly container;
+    private readonly canvas;
+    private readonly ctx;
+    private readonly defaultBackgroundImage;
+    private document;
+    private emitter;
+    private toolLockManager;
+    private eventSources;
+    private recognizers;
+    private tools;
+    private manualRenderers;
+    private modeRenderers;
+    private eventQueue;
+    private processingQueue;
+    private renderScheduled;
+    private flags;
+    private objects;
+    private needsRender;
+    private toolRegistry;
+    private modes;
+    private currentMode;
+    private options;
+    private readonly defaultOptions;
+    get pan(): Vector;
+    get zoom(): number;
+    _pan: Vector;
+    _zoom: number;
+    /** Convert screen coordinates to world coordinates */
+    screenToWorld(screen: Point): Point;
+    /** Convert world coordinates to screen coordinates */
+    worldToScreen(point: Point): Point;
+    constructor(selector: string, opts?: CanvasEngineOptions);
+    /** The engine is also a tool to allow certain events to be handled **/
+    processToolEvent(evt: CanvasEvent, emit: (evt: CanvasEvent) => void, emitExternal: (type: keyof EngineEventPayloads, payload: EngineEventPayloads[keyof EngineEventPayloads]) => void, engine: CanvasEngine, lock: ToolLock): void;
+    /** INTERNAL SETUP **/
+    private createOptions;
+    private setupDefaultEventSources;
+    private setupDefaultRecognizers;
+    private setupDefaultTools;
+    private setupDefaultModes;
+    private setupRenderNodes;
+    /** EXTERNAL EVENTS */
+    on: <K extends keyof EngineEventPayloads>(type: K, callback: (payload: EngineEventPayloads[K]) => void, options?: {
+        once?: boolean;
+    }) => void;
+    off: <K extends keyof EngineEventPayloads>(type: K, callback: (payload: EngineEventPayloads[K]) => void) => void;
+    private emitExternal;
+    private wrapInteractiveObject;
+    /** TOOL REGISTRY **/
+    /**
+     * Register a tool under a key.
+     * If `singleton=true`, the same instance is reused everywhere;
+     * otherwise `.factory()` is called each time you switch modes.
+     */
+    registerTool(key: string, factory: () => ToolPipelineNode, singleton?: boolean): void;
+    /** Grab an instance for a given key */
+    private resolveTool;
+    /** MODE MANAGEMENT **/
+    defineMode(name: string, config: ModeConfig): void;
+    get mode(): string;
+    switchMode(name: string): void;
+    get renderers(): RenderPipelineNode[];
+    /** Background / DocumentObject / canvas-background **/
+    get width(): number;
+    get height(): number;
+    get documentBlob(): Blob;
+    setBackgroundImage(imageOrUrl: string | File | Blob): Promise<void>;
+    private loadImageFromUrl;
+    private loadImage;
+    /** OBJECT MANAGEMENT **/
+    getObject(id: string): InteractiveObject | undefined;
+    addObject(obj: InteractiveObject): void;
+    removeObject(objOrId: string | InteractiveObject): void;
+    /**
+     * API helper: enqueue move to absolute position.
+     */
+    moveObjectToPoint(object: InteractiveObject, x: number, y: number): void;
+    moveObjectToPoint(id: string, x: number, y: number): void;
+    moveObjectToPoint(object: InteractiveObject, point: Point): void;
+    moveObjectToPoint(id: string, point: Point): void;
+    /**
+     * API helper: enqueue move by vector.
+     */
+    moveObjectByVector(object: InteractiveObject, dx: number, dy: number): void;
+    moveObjectByVector(id: string, dx: number, dy: number): void;
+    moveObjectByVector(object: InteractiveObject, vector: Vector): void;
+    moveObjectByVector(id: string, vector: Vector): void;
+    /**
+     * API helper: enqueue resize to absolute size.
+     */
+    resizeObjectToSize(object: InteractiveObject, width: number, height: number): void;
+    resizeObjectToSize(id: string, width: number, height: number): void;
+    resizeObjectToSize(object: InteractiveObject, size: Size): void;
+    resizeObjectToSize(id: string, size: Size): void;
+    /**
+     * API helper: enqueue resize by delta.
+     */
+    resizeObjectByVector(object: InteractiveObject, dw: number, dh: number): void;
+    resizeObjectByVector(id: string, dw: number, dh: number): void;
+    resizeObjectByVector(object: InteractiveObject, vector: Vector): void;
+    resizeObjectByVector(id: string, vector: Vector): void;
+    /**
+     * API helper: enqueue color change.
+     */
+    setObjectColor(objOrId: string | InteractiveObject, color: string): void;
+    /**
+     * API helper: enqueue Z-index change.
+     */
+    setObjectZIndex(objOrId: string | InteractiveObject, zIndex: number): void;
+    /**
+     * API helper: enqueue selectability change.
+     */
+    updateObjectSelectability(objOrId: string | InteractiveObject, isSelectable: boolean): void;
+    /**
+     * API helper: enqueue movability change.
+     */
+    updateObjectMovability(objOrId: string | InteractiveObject, isMovable: boolean): void;
+    /**
+     * API helper: enqueue resizability change.
+     */
+    updateObjectResizeability(objOrId: string | InteractiveObject, isResizable: boolean): void;
+    /**
+     * API helper: enqueue visibility change.
+     */
+    updateObjectVisibility(objOrId: string | InteractiveObject, visible: boolean): void;
+    /** FLAG MANAGEMENT **/
+    setFlag(objOrId: string | InteractiveObject, flag: string): void;
+    clearFlag(objOrId: string | InteractiveObject, flag: string): void;
+    hasFlag(objOrId: string | InteractiveObject, flag: string): boolean;
+    clearAllFlags(flag: string): void;
+    getObjectsWithFlag(flag: string): InteractiveObject[];
+    /** ZOOM AND PAN API */
+    setZoom(zoom: number, center?: Point): void;
+    setPan(x: number, y: number): void;
+    setPan(pan: Vector): void;
+    /** SELECTION HELPERS **/
+    setSelectedObjects(objOrIds: (string | InteractiveObject)[]): void;
+    getSelectedObjects(): InteractiveObject[];
+    /**
+     * Returns all interactive objects in this engine.
+     */
+    getAllObjects(): InteractiveObject[];
+    /**
+     * Returns a map from event-prefix → topmost object that supports it at (x,y).
+     */
+    getTopMostInteractionPerEventType(point: Point): Map<string, InteractionEntry>;
+    /** QUEUE HELPERS **/
+    /** Called by any EventSource to enqueue a raw event */
+    private enqueue;
+    /** Kick off the queue-processor if it isn’t already running */
+    private ensureEventLoop;
+    /** Drains the queue, running recognizers → tools → objects */
+    private processQueue;
+    /** PIPELINE REGISTRATION **/
+    addEventSource(src: EventSource): void;
+    removeEventSource(src: EventSource): void;
+    addRecognizer(node: GestureRecognizer): void;
+    addRenderNode(node: RenderPipelineNode): void;
+    /**
+     * Convenience: auto-register by interface
+     */
+    register(node: unknown): void;
+    /** RENDERING **/
+    redraw(): void;
+    private requestRender;
+    private doRender;
+    dispose(): void;
+}
+declare class ToolLockManager {
+    private currentTool;
+    get isLocked(): boolean;
+    getToolLock(tool: ToolPipelineNode): ToolLock;
+}
+interface ToolLock {
+    acquire(): boolean;
+    release(): void;
+    hasLock(): boolean;
+}
+declare class MoveTool implements ToolPipelineNode {
+    private objectsBeingMoved;
+    private lastDelta;
+    processToolEvent(evt: CanvasEvent, emit: (e: CanvasEvent) => void, emitExternal: (type: keyof EngineEventPayloads, payload: EngineEventPayloads[keyof EngineEventPayloads]) => void, engine: CanvasEngine, lock: ToolLock): void;
+}
+/**
+ * Tool that handles click-based selection of interactive objects.
+ */
+declare class SelectTool implements ToolPipelineNode {
+    /** Higher priority to process clicks before other tools */
+    priority: number;
+    processToolEvent(evt: CanvasEvent, emit: (evt: CanvasEvent) => void, emitExternal: (type: keyof EngineEventPayloads, payload: EngineEventPayloads[keyof EngineEventPayloads]) => void, engine: CanvasEngine, lock: ToolLock): void;
+}
+/**
+ * Tool that marks all objects under the pointer as hovered on each move.
+ */
+declare class HoverTool implements ToolPipelineNode {
+    /** Lower priority so selection and other tools run first */
+    priority: number;
+    processToolEvent(evt: CanvasEvent, emit: (evt: CanvasEvent) => void, emitExternal: (type: keyof EngineEventPayloads, payload: EngineEventPayloads[keyof EngineEventPayloads]) => void, engine: CanvasEngine, lock: ToolLock): void;
+}
+declare class ResizeTool implements ToolPipelineNode {
+    private activeHandleIndex;
+    private objectsBeingResized;
+    private lastDelta;
+    processToolEvent(evt: CanvasEvent, emit: (e: CanvasEvent) => void, emitExternal: (type: keyof EngineEventPayloads, payload: EngineEventPayloads[keyof EngineEventPayloads]) => void, engine: CanvasEngine, lock: ToolLock): void;
+}
+/**
+ * Tool to draw new rectangular zones via drag gestures.
+ */
+declare class DrawingTool implements ToolPipelineNode, RenderPipelineNode {
+    private drawing;
+    private startPt;
+    private currentPt;
+    private defaultColor;
+    constructor(defaultColor?: string);
+    processToolEvent(evt: CanvasEvent, emit: (evt: CanvasEvent) => void, emitExternal: (type: keyof EngineEventPayloads, payload: EngineEventPayloads[keyof EngineEventPayloads]) => void, engine: CanvasEngine, lock: ToolLock): void;
+    renderAfterAll(ctx: CanvasRenderingContext2D, engine: CanvasEngine): void;
+}
+/**
+ * Ray-casting algorithm to test if a point is inside a polygon.
+ */
+/**
+ * Tool to draw a freeform lasso and select all objects fully inside the polygon.
+ */
+declare class LassoTool implements ToolPipelineNode, RenderPipelineNode {
+    private lassoing;
+    private points;
+    processToolEvent(evt: CanvasEvent, emit: (evt: CanvasEvent) => void, emitExternal: (type: keyof EngineEventPayloads, payload: EngineEventPayloads[keyof EngineEventPayloads]) => void, engine: CanvasEngine, lock: ToolLock): void;
+    renderAfterAll(ctx: CanvasRenderingContext2D, engine: CanvasEngine): void;
+}
+/**
+ * Translates high‐level API calls into the standard semantic events
+ * so they flow through the same move/resize/remove pipelines.
+ */
+declare class ApiTool implements ToolPipelineNode {
+    processToolEvent(evt: CanvasEvent, emit: (evt: CanvasEvent) => void, emitExternal: (type: keyof EngineEventPayloads, payload: EngineEventPayloads[keyof EngineEventPayloads]) => void, engine: CanvasEngine, lock: ToolLock): void;
+}
+/**
+ * Recognizes drag gestures: pointerdown, pointermove, pointerup,
+ * emitting dragstart, drag, and dragEnd events with world and screen data.
+ */
+declare class DragGestureRecognizer implements GestureRecognizer {
+    private activePointerIds;
+    private isDragging;
+    private buttonStart;
+    private origin;
+    private moveThreshold;
+    constructor(moveThreshold?: number);
+    process(evt: CanvasEvent, emit: (evt: CanvasEvent) => void): void;
+    private handleStart;
+    private handleMove;
+    private handleEnd;
+    private getTouches;
+    private findActiveTouch;
+}
+declare class ClickGestureRecognizer implements GestureRecognizer {
+    private activePointerIds;
+    private origin;
+    private moveThreshold;
+    constructor(moveThreshold?: number);
+    process(evt: CanvasEvent, emit: (evt: CanvasEvent) => void): void;
+    private handleStart;
+    private handleMove;
+    private handleEnd;
+    private getTouches;
+    private findActiveTouch;
+}
+declare class Point {
+    x: number;
+    y: number;
+    constructor(x: number, y: number);
+    equals(other: Point): boolean;
+    static equals(a: Point, b: Point): boolean;
+    getDeltaFromPoint(other: Point): Vector;
+    getDeltaToPoint(other: Point): Vector;
+    add(vector: Vector): Point;
+    asVector(): Vector;
+    subtract(vector: Vector): Point;
+    isInside(rect: Rectangle): boolean;
+    clone(): Point;
+    isInPolygon(poly: Polygon): boolean;
+}
+declare class Size {
+    width: number;
+    height: number;
+    constructor(width: number, height: number);
+    equals(other: Size): boolean;
+    static equals(a: Size, b: Size): boolean;
+    clone(): Size;
+}
+declare class Rectangle {
+    origin: Point;
+    size: Size;
+    constructor(x: number, y: number, width: number, height: number);
+    constructor(origin: Point, size: Size);
+    equals(other: Rectangle): boolean;
+    static equals(a: Rectangle, b: Rectangle): boolean;
+    contains(point: Point): boolean;
+    clone(): Rectangle;
+    center(): Point;
+    normalized(): Rectangle;
+    isNormalized(): boolean;
+    normalize(): void;
+    expand(rect: Rectangle): Rectangle;
+    move(vector: Vector): Rectangle;
+    toPolygon(): Polygon;
+}
+declare class Vector {
+    x: number;
+    y: number;
+    constructor(x: number, y: number);
+    equals(other: Vector): boolean;
+    static equals(a: Vector, b: Vector): boolean;
+    add(other: Vector): Vector;
+    subtract(other: Vector): Vector;
+    scale(factor: number): Vector;
+    length(): number;
+    normalize(): Vector;
+    clone(): Vector;
+}
+declare class Polygon {
+    points: Point[];
+    constructor(points: Point[]);
+    equals(other: Polygon): boolean;
+    static equals(a: Polygon, b: Polygon): boolean;
+    containsPoint(pt: Point): boolean;
+    containsRect(rect: Rectangle): boolean;
+}
+
+export { ApiTool, CanvasEngine, type CanvasEvent, CircleObject, ClickGestureRecognizer, DomEventSource, DragGestureRecognizer, DrawingTool, type EngineEventPayloads, EngineEventType, type EventSource, type GestureRecognizer, HoverTool, type InteractiveObject, LassoTool, MoveTool, Point, Polygon, PolygonObject, Rectangle, type RenderPipelineNode, ResizeTool, SelectTool, Size, ToolLockManager, type ToolPipelineNode, Vector, Zone };