@grafloria/element 0.3.20 → 0.3.22

package/src/libs/renderer/src/interaction/whiteboard-tools.d.ts

@@ -1,171 +0,0 @@
-import { StrokeModel, type DiagramEngine, type DiagramModel } from '@grafloria/engine';
-import type { ViewportController } from '../viewport/viewport-controller';
-import type { CanvasTool, ToolPointerEvent, ToolHitContext } from '../ext/tools';
-import { InkOverlay } from './ink-overlay';
-/**
- * The slice of a mounted diagram the whiteboard tools need. `DiagramInstance` satisfies it
- * structurally, but a test can hand over a fake with four members instead of forty.
- */
-export interface WhiteboardHost {
-    getModel(): DiagramModel;
-    readonly viewport: ViewportController;
-    readonly container: HTMLElement;
-    /** Queue a repaint after a commit. */
-    render(): void;
-    /**
-     * Run a multi-op commit as ONE undo step. A collab/undo-aware host passes
-     * `replica.transact`; the default runs it inline (a plain instance has no undo stack, and
-     * one add / N removes are still atomic to the model either way).
-     */
-    batch?: (fn: () => void) => void;
-    /**
-     * wave13/stroke-edit: the command manager, when the host has one. `DiagramInstance`
-     * already exposes exactly this signature, so an embed keeps handing the instance over
-     * unchanged. The EDIT tool commits its translate through `engine.commandManager` so the
-     * gesture is Ctrl-Z-able; without an engine it falls back to a plain `setPoints` commit
-     * (still correct, still ONE op for collab — just not on an undo stack that doesn't exist).
-     */
-    getEngine?(): DiagramEngine | null;
-}
-/**
- * The point-agnostic MODE tools: draw, rectangle, eraser. Above the built-in
- * ladder (0), below the ink-specific tier — see the arbitration header.
- */
-export declare const WHITEBOARD_MODE_TOOL_PRIORITY = 1;
-/**
- * The point-specific INK tools (stroke edit): only ever claims a press that
- * actually lands on ink, so it must not lose that press to a mode tool that
- * claims everything. See the arbitration header.
- */
-export declare const WHITEBOARD_INK_TOOL_PRIORITY = 2;
-/** Common base: an overlay, an active flag, and the ROOT lookup. */
-declare abstract class WhiteboardTool {
-    protected readonly host: WhiteboardHost;
-    abstract readonly id: string;
-    /**
-     * Every whiteboard tool STATES its tier — see the arbitration header above.
-     * (wave14 defect 2: a shared default here let registration order decide.)
-     */
-    abstract readonly priority: number;
-    /** When false, the tool declines every gesture — this is how a host switches tools. */
-    protected active: boolean;
-    private overlayInstance;
-    constructor(host: WhiteboardHost);
-    setActive(active: boolean): void;
-    isActive(): boolean;
-    hitTest(): boolean;
-    /** Lazily mount the scratch layer on the diagram root the first time it is needed. */
-    protected overlay(): InkOverlay;
-    protected model(): DiagramModel;
-    protected commit(fn: () => void): void;
-    dispose(): void;
-    onCancel(): void;
-}
-export interface DrawToolOptions {
-    color?: string;
-    width?: number;
-    /** Highlighter ink is translucent. */
-    opacity?: number;
-    /** Douglas-Peucker tolerance at commit. Omit to use the model's tuned default. */
-    simplifyEpsilon?: number;
-    /** An author label for the committed ink — makes it a NAMED annotation in the a11y tree. */
-    label?: string;
-    active?: boolean;
-}
-export declare class DrawTool extends WhiteboardTool implements CanvasTool {
-    private readonly opts;
-    readonly id = "whiteboard-draw";
-    readonly priority = 1;
-    private raw;
-    constructor(host: WhiteboardHost, opts?: DrawToolOptions);
-    private style;
-    private preview;
-    onPointerDown(ev: ToolPointerEvent, _hit?: ToolHitContext): void;
-    onPointerMove(ev: ToolPointerEvent, _hit?: ToolHitContext): void;
-    onPointerUp(ev: ToolPointerEvent, _hit?: ToolHitContext): void;
-}
-export interface RectangleToolOptions {
-    fill?: string;
-    stroke?: string;
-    strokeWidth?: number;
-    /** Below this size (world px) the drag is treated as a mis-click and no node is made. */
-    minSize?: number;
-    label?: string;
-    active?: boolean;
-}
-export declare class RectangleTool extends WhiteboardTool implements CanvasTool {
-    private readonly opts;
-    readonly id = "whiteboard-rectangle";
-    readonly priority = 1;
-    private start;
-    constructor(host: WhiteboardHost, opts?: RectangleToolOptions);
-    private preview;
-    onPointerDown(ev: ToolPointerEvent, _hit?: ToolHitContext): void;
-    onPointerMove(ev: ToolPointerEvent, _hit?: ToolHitContext): void;
-    onPointerUp(ev: ToolPointerEvent, _hit?: ToolHitContext): void;
-}
-export interface EraserToolOptions {
-    /** Extra hit radius in world units around the eraser path. Default 8. */
-    radius?: number;
-    active?: boolean;
-}
-export declare class EraserTool extends WhiteboardTool implements CanvasTool {
-    private readonly opts;
-    readonly id = "whiteboard-eraser";
-    readonly priority = 1;
-    private last;
-    private doomed;
-    private trail;
-    constructor(host: WhiteboardHost, opts?: EraserToolOptions);
-    private radius;
-    private sweep;
-    private previewStyle;
-    onPointerDown(ev: ToolPointerEvent, _hit?: ToolHitContext): void;
-    onPointerMove(ev: ToolPointerEvent, _hit?: ToolHitContext): void;
-    onPointerUp(_ev?: ToolPointerEvent, _hit?: ToolHitContext): void;
-    onCancel(): void;
-}
-export interface StrokeEditToolOptions {
-    /** Extra hit radius in world units around the ink. Default 6 — finger-friendly. */
-    tolerance?: number;
-    /** Highlight colour for the selected stroke's ghost. */
-    highlightColor?: string;
-    active?: boolean;
-}
-export declare class StrokeEditTool extends WhiteboardTool implements CanvasTool {
-    private readonly opts;
-    readonly id = "whiteboard-stroke-edit";
-    /**
-     * INK tier: outranks the mode tools, and is SAFE to because {@link hitTest}
-     * only ever claims a press that lands on ink — see the arbitration header.
-     */
-    readonly priority = 2;
-    private selected;
-    /** Gesture-start geometry — the FROM of the FROM→TO command. */
-    private startPoints;
-    private origin;
-    private delta;
-    constructor(host: WhiteboardHost, opts?: StrokeEditToolOptions);
-    private tolerance;
-    /** The stroke under `(x, y)` — the TOPMOST one, since later ink paints over earlier. */
-    private strokeAt;
-    /** What the tool considers selected — for hosts, tests, and a future style panel. */
-    getSelectedStroke(): StrokeModel | null;
-    /**
-     * CLAIM the gesture only when ink is under the pointer. This is what lets the tool
-     * coexist with the whole built-in ladder instead of monopolising the canvas.
-     */
-    hitTest(ev?: ToolPointerEvent): boolean;
-    private highlight;
-    onPointerDown(ev: ToolPointerEvent, _hit?: ToolHitContext): void;
-    onPointerMove(ev: ToolPointerEvent, _hit?: ToolHitContext): void;
-    onPointerUp(ev: ToolPointerEvent, _hit?: ToolHitContext): void;
-    /** Escape / pointercancel: drop the gesture AND the selection. Nothing was committed. */
-    onCancel(): void;
-    setActive(active: boolean): void;
-}
-export declare function createDrawTool(host: WhiteboardHost, options?: DrawToolOptions): DrawTool;
-export declare function createRectangleTool(host: WhiteboardHost, options?: RectangleToolOptions): RectangleTool;
-export declare function createEraserTool(host: WhiteboardHost, options?: EraserToolOptions): EraserTool;
-export declare function createStrokeEditTool(host: WhiteboardHost, options?: StrokeEditToolOptions): StrokeEditTool;
-export {};

package/src/libs/renderer/src/interaction/whiteboard-tools.js

@@ -1,476 +0,0 @@
-"use strict";
-// wave10/whiteboard — THE TOOLS THAT MAKE INK REACHABLE.
-//
-// A StrokeModel that no gesture ever creates is machinery wired to nothing — the exact
-// failure this project has shipped in every prior wave. These three tools are the wire:
-// pointer input → the tool registry (Wave 6) → the ToolManager arbitration in the
-// DomEventBinder / TouchGestureController → the model. They add NO new input path; they plug
-// into the one that already arbitrates gestures.
-//
-//   DRAW      freehand ink → ONE StrokeModel, simplified, committed at pointerup
-//   RECTANGLE a dragged box → a NODE (a rectangle IS a box: connectable, resizable, laid out)
-//   ERASER    wipe over ink → the swept strokes removed, as ONE undo step
-//   EDIT      select ink under the pointer, drag to translate it — ONE undoable command
-//             (wave13/stroke-edit: the gap where ink could be made and destroyed but not touched)
-//
-// The live feedback (the line as it grows, the rubber-band box, the eraser trail) is drawn on
-// a SEPARATE overlay layer (ink-overlay.ts), NOT through the VNode tree, so a stroke in
-// progress cannot dirty a 10k-node frame. Only the committed result — one add, or a batch of
-// removes — touches the model and the frame gate.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StrokeEditTool = exports.EraserTool = exports.RectangleTool = exports.DrawTool = exports.WHITEBOARD_INK_TOOL_PRIORITY = exports.WHITEBOARD_MODE_TOOL_PRIORITY = void 0;
-exports.createDrawTool = createDrawTool;
-exports.createRectangleTool = createRectangleTool;
-exports.createEraserTool = createEraserTool;
-exports.createStrokeEditTool = createStrokeEditTool;
-const engine_1 = require("@grafloria/engine");
-const ink_overlay_1 = require("./ink-overlay");
-const layers_1 = require("../instance/layers");
-// ===========================================================================
-// ARBITRATION — explicit tool priorities (wave14, defect 2)
-// ===========================================================================
-//
-// All four tools used to share `priority = 1`, which resolved a double claim by
-// REGISTRATION ORDER — invisible, and wrong the day wave13 made the assumption
-// "hosts activate one tool at a time" half-false: StrokeEditTool is documented
-// to stay PERMANENTLY active alongside the others. Two tiers, stated plainly:
-//
-//   MODE tier (draw / rectangle / eraser): hitTest is POINT-AGNOSTIC — while
-//   active they claim every press. Activating one is a mode switch; hosts keep
-//   at most one active at a time (two active mode tools is a host bug no
-//   priority can repair — the tie then falls back to registration order).
-//
-//   INK tier (stroke edit): hitTest is POINT-SPECIFIC — it claims ONLY when ink
-//   is actually under the pointer (the safety property that lets it stay
-//   permanently active without eating the canvas). A specific claim outranks a
-//   broad one, so it sits strictly ABOVE the mode tier.
-//
-// CONSEQUENCE, chosen consciously: with a mode tool AND the edit tool both
-// active, a press ON INK edits (non-destructive) rather than drawing over or
-// erasing (destructive). A host that wants its eraser to consume ink while the
-// gesture is ambiguous must `setActive(false)` the edit tool for that mode —
-// the two genuinely conflict over the same press, and no ordering serves both.
-/**
- * The point-agnostic MODE tools: draw, rectangle, eraser. Above the built-in
- * ladder (0), below the ink-specific tier — see the arbitration header.
- */
-exports.WHITEBOARD_MODE_TOOL_PRIORITY = 1;
-/**
- * The point-specific INK tools (stroke edit): only ever claims a press that
- * actually lands on ink, so it must not lose that press to a mode tool that
- * claims everything. See the arbitration header.
- */
-exports.WHITEBOARD_INK_TOOL_PRIORITY = 2;
-/** Common base: an overlay, an active flag, and the ROOT lookup. */
-class WhiteboardTool {
-    constructor(host) {
-        this.host = host;
-        /** When false, the tool declines every gesture — this is how a host switches tools. */
-        this.active = true;
-        this.overlayInstance = null;
-    }
-    setActive(active) {
-        this.active = active;
-        if (!active)
-            this.overlay().clear();
-    }
-    isActive() {
-        return this.active;
-    }
-    hitTest() {
-        return this.active;
-    }
-    /** Lazily mount the scratch layer on the diagram root the first time it is needed. */
-    overlay() {
-        var _a;
-        if (!this.overlayInstance) {
-            const root = (_a = this.host.container.querySelector(`.${layers_1.ROOT_CLASS}`)) !== null && _a !== void 0 ? _a : this.host.container;
-            this.overlayInstance = new ink_overlay_1.InkOverlay({ root, viewport: this.host.viewport });
-        }
-        return this.overlayInstance;
-    }
-    model() {
-        return this.host.getModel();
-    }
-    commit(fn) {
-        var _a;
-        ((_a = this.host.batch) !== null && _a !== void 0 ? _a : ((f) => f()))(fn);
-    }
-    dispose() {
-        var _a;
-        (_a = this.overlayInstance) === null || _a === void 0 ? void 0 : _a.dispose();
-        this.overlayInstance = null;
-    }
-    onCancel() {
-        this.overlay().clear();
-    }
-}
-class DrawTool extends WhiteboardTool {
-    constructor(host, opts = {}) {
-        super(host);
-        this.opts = opts;
-        this.id = 'whiteboard-draw';
-        this.priority = exports.WHITEBOARD_MODE_TOOL_PRIORITY;
-        this.raw = [];
-        if (opts.active === false)
-            this.active = false;
-    }
-    style() {
-        var _a, _b;
-        const s = { color: (_a = this.opts.color) !== null && _a !== void 0 ? _a : '#1f2933', width: (_b = this.opts.width) !== null && _b !== void 0 ? _b : 3 };
-        if (this.opts.opacity !== undefined)
-            s.opacity = this.opts.opacity;
-        return s;
-    }
-    preview() {
-        var _a, _b;
-        return { color: (_a = this.opts.color) !== null && _a !== void 0 ? _a : '#1f2933', width: (_b = this.opts.width) !== null && _b !== void 0 ? _b : 3, opacity: this.opts.opacity };
-    }
-    onPointerDown(ev, _hit) {
-        this.raw = [sample(ev)];
-        this.overlay().drawPolyline(this.raw, this.preview());
-    }
-    onPointerMove(ev, _hit) {
-        if (this.raw.length === 0)
-            return;
-        this.raw.push(sample(ev));
-        // ONE attribute write. No VNode, no frame, no epoch.
-        this.overlay().drawPolyline(this.raw, this.preview());
-    }
-    onPointerUp(ev, _hit) {
-        var _a, _b;
-        if (this.raw.length === 0)
-            return;
-        this.raw.push(sample(ev));
-        // A pointerdown+up with no travel is a dot; anything else is a line. Either way the raw
-        // trace — hundreds of samples on a real drag — is SIMPLIFIED at commit through the
-        // engine's PathSimplifier (fromRawPoints). A 500-point stroke persisted as 500 points is
-        // a bug the model's own docstring names; this is where that is prevented.
-        const raw = this.raw;
-        this.raw = [];
-        this.overlay().clear();
-        const stroke = engine_1.StrokeModel.fromRawPoints(raw, this.style(), {
-            epsilon: this.opts.simplifyEpsilon,
-            label: this.opts.label,
-        });
-        // A degenerate stroke (all samples identical, simplified to <1 real point) is not ink.
-        if (stroke.pointCount === 0)
-            return;
-        // Through the COMMAND STACK when the host has an engine — a drawn stroke
-        // must be one ⌘Z away, like every other gesture (live audit: it wasn't).
-        const engine = (_b = (_a = this.host).getEngine) === null || _b === void 0 ? void 0 : _b.call(_a);
-        if (engine) {
-            void engine.commandManager.execute(new engine_1.AddStrokeCommand(stroke));
-        }
-        else {
-            this.commit(() => this.model().addStroke(stroke));
-        }
-        this.host.render();
-    }
-}
-exports.DrawTool = DrawTool;
-class RectangleTool extends WhiteboardTool {
-    constructor(host, opts = {}) {
-        super(host);
-        this.opts = opts;
-        this.id = 'whiteboard-rectangle';
-        this.priority = exports.WHITEBOARD_MODE_TOOL_PRIORITY;
-        this.start = null;
-        if (opts.active === false)
-            this.active = false;
-    }
-    preview() {
-        var _a, _b;
-        return { color: (_a = this.opts.stroke) !== null && _a !== void 0 ? _a : '#2563eb', width: (_b = this.opts.strokeWidth) !== null && _b !== void 0 ? _b : 2, dashed: true, opacity: 0.08 };
-    }
-    onPointerDown(ev, _hit) {
-        this.start = { x: ev.world.x, y: ev.world.y };
-    }
-    onPointerMove(ev, _hit) {
-        if (!this.start)
-            return;
-        const r = normRect(this.start, ev.world);
-        this.overlay().drawRect(r.x, r.y, r.width, r.height, this.preview());
-    }
-    onPointerUp(ev, _hit) {
-        var _a;
-        if (!this.start)
-            return;
-        const r = normRect(this.start, ev.world);
-        this.start = null;
-        this.overlay().clear();
-        const min = (_a = this.opts.minSize) !== null && _a !== void 0 ? _a : 4;
-        if (r.width < min || r.height < min)
-            return; // a click, not a rectangle
-        const node = new engine_1.NodeModel({
-            type: 'basic',
-            position: { x: r.x, y: r.y },
-            size: { width: r.width, height: r.height },
-        });
-        // The Wave-5 shape machinery, used for what it is actually for: a named silhouette. The
-        // renderer's cascade reads `style.shape`, so this is a real rectangle, not a metadata
-        // note nothing looks at.
-        const style = { shape: 'rectangle' };
-        if (this.opts.fill)
-            style['fill'] = this.opts.fill;
-        if (this.opts.stroke)
-            style['stroke'] = this.opts.stroke;
-        if (this.opts.strokeWidth !== undefined)
-            style['strokeWidth'] = this.opts.strokeWidth;
-        node.setStyle(style);
-        if (this.opts.label !== undefined)
-            node.setMetadata('label', this.opts.label);
-        this.commit(() => this.model().addNode(node));
-        this.host.render();
-    }
-}
-exports.RectangleTool = RectangleTool;
-class EraserTool extends WhiteboardTool {
-    constructor(host, opts = {}) {
-        super(host);
-        this.opts = opts;
-        this.id = 'whiteboard-eraser';
-        this.priority = exports.WHITEBOARD_MODE_TOOL_PRIORITY;
-        this.last = null;
-        this.doomed = new Set();
-        this.trail = [];
-        if (opts.active === false)
-            this.active = false;
-    }
-    radius() {
-        var _a;
-        return (_a = this.opts.radius) !== null && _a !== void 0 ? _a : 8;
-    }
-    sweep(from, to) {
-        // Segment-vs-segment, NOT point-vs-segment: a fast flick lands samples 80px apart, and a
-        // point test would jump clean over a stroke the eraser visibly swept through. The model's
-        // getStrokesAlongSegment asks the right question — "what did the pointer travel through".
-        for (const s of this.model().getStrokesAlongSegment(from, to, this.radius())) {
-            this.doomed.add(s.id);
-        }
-    }
-    previewStyle() {
-        return { color: 'rgba(120,120,120,0.35)', width: this.radius() * 2 };
-    }
-    onPointerDown(ev, _hit) {
-        this.last = { x: ev.world.x, y: ev.world.y };
-        this.doomed = new Set();
-        this.trail = [this.last];
-        this.sweep(this.last, this.last); // a tap erases the stroke under it
-        this.overlay().drawPolyline(this.trail, this.previewStyle());
-    }
-    onPointerMove(ev, _hit) {
-        if (!this.last)
-            return;
-        const pt = { x: ev.world.x, y: ev.world.y };
-        this.sweep(this.last, pt);
-        this.last = pt;
-        this.trail.push(pt);
-        this.overlay().drawPolyline(this.trail, this.previewStyle());
-    }
-    onPointerUp(_ev, _hit) {
-        var _a, _b;
-        if (!this.last)
-            return;
-        const ids = [...this.doomed];
-        this.last = null;
-        this.doomed = new Set();
-        this.trail = [];
-        this.overlay().clear();
-        if (ids.length === 0)
-            return;
-        // ONE undo step for the whole sweep — see the header. Through the command
-        // stack when an engine exists (live audit: an erased stroke was gone for
-        // good; ⌘Z restored nothing).
-        const engine = (_b = (_a = this.host).getEngine) === null || _b === void 0 ? void 0 : _b.call(_a);
-        if (engine) {
-            void engine.commandManager.execute(new engine_1.RemoveStrokesCommand(ids));
-        }
-        else {
-            this.commit(() => {
-                for (const id of ids)
-                    this.model().removeStroke(id);
-            });
-        }
-        this.host.render();
-    }
-    onCancel() {
-        this.last = null;
-        this.doomed = new Set();
-        this.trail = [];
-        super.onCancel();
-    }
-}
-exports.EraserTool = EraserTool;
-class StrokeEditTool extends WhiteboardTool {
-    constructor(host, opts = {}) {
-        super(host);
-        this.opts = opts;
-        this.id = 'whiteboard-stroke-edit';
-        /**
-         * INK tier: outranks the mode tools, and is SAFE to because {@link hitTest}
-         * only ever claims a press that lands on ink — see the arbitration header.
-         */
-        this.priority = exports.WHITEBOARD_INK_TOOL_PRIORITY;
-        this.selected = null;
-        /** Gesture-start geometry — the FROM of the FROM→TO command. */
-        this.startPoints = null;
-        this.origin = null;
-        this.delta = { x: 0, y: 0 };
-        if (opts.active === false)
-            this.active = false;
-    }
-    tolerance() {
-        var _a;
-        return (_a = this.opts.tolerance) !== null && _a !== void 0 ? _a : 6;
-    }
-    /** The stroke under `(x, y)` — the TOPMOST one, since later ink paints over earlier. */
-    strokeAt(p) {
-        let top = null;
-        for (const s of this.model().getStrokes()) {
-            if (s.hitTest(p.x, p.y, this.tolerance()))
-                top = s;
-        }
-        return top;
-    }
-    /** What the tool considers selected — for hosts, tests, and a future style panel. */
-    getSelectedStroke() {
-        return this.selected;
-    }
-    /**
-     * CLAIM the gesture only when ink is under the pointer. This is what lets the tool
-     * coexist with the whole built-in ladder instead of monopolising the canvas.
-     */
-    hitTest(ev) {
-        if (!this.active)
-            return false;
-        if (!ev)
-            return false;
-        return this.strokeAt(ev.world) !== null;
-    }
-    highlight(points, width, dragging) {
-        var _a;
-        this.overlay().drawPolyline(points, {
-            color: (_a = this.opts.highlightColor) !== null && _a !== void 0 ? _a : '#2563eb',
-            width: width + 4,
-            opacity: dragging ? 0.55 : 0.35,
-        });
-    }
-    onPointerDown(ev, _hit) {
-        const stroke = this.strokeAt(ev.world);
-        this.selected = stroke;
-        if (!stroke) {
-            this.overlay().clear();
-            return;
-        }
-        this.startPoints = stroke.getPoints().map((p) => (Object.assign({}, p)));
-        this.origin = { x: ev.world.x, y: ev.world.y };
-        this.delta = { x: 0, y: 0 };
-        this.highlight(this.startPoints, stroke.getStyle().width, false);
-    }
-    onPointerMove(ev, _hit) {
-        if (!this.selected || !this.origin || !this.startPoints)
-            return;
-        this.delta = { x: ev.world.x - this.origin.x, y: ev.world.y - this.origin.y };
-        // Live feedback is the translated ghost on the overlay — ONE attribute write per move.
-        // The model (and therefore the frame gate, the epoch, and the wire) sees NOTHING yet.
-        // The ghost is a REPLICA of the ink (own colour, own width, near-opaque), not a thin
-        // blue outline: with the outline form, the ink looked frozen mid-drag and "teleported"
-        // on release (live audit) — the preview must read as the stroke itself moving.
-        const ghost = this.startPoints.map((p) => ({ x: p.x + this.delta.x, y: p.y + this.delta.y }));
-        const style = this.selected.getStyle();
-        this.overlay().clear();
-        this.overlay().drawPolyline(ghost, {
-            color: style.color,
-            width: style.width,
-            opacity: 0.9,
-        });
-    }
-    onPointerUp(ev, _hit) {
-        var _a, _b;
-        if (!this.selected || !this.origin || !this.startPoints)
-            return;
-        const stroke = this.selected;
-        const from = this.startPoints;
-        const dx = ev.world.x - this.origin.x;
-        const dy = ev.world.y - this.origin.y;
-        this.origin = null;
-        this.startPoints = null;
-        this.delta = { x: 0, y: 0 };
-        // A press-and-release with no travel is a TAP: it selects, it moves nothing, and it
-        // must not put an empty step on the undo stack. (Sub-quantum travel — under the model's
-        // 2dp coordinate quantization — is the same non-event.)
-        if (Math.abs(dx) < 0.01 && Math.abs(dy) < 0.01) {
-            this.highlight(from, stroke.getStyle().width, false);
-            return;
-        }
-        const to = from.map((p) => (Object.assign(Object.assign({}, p), { x: p.x + dx, y: p.y + dy })));
-        // ONE undoable command, ONE setPoints, at pointerup — the gesture-commit pattern
-        // (commitNodeMove / SetLinkPointsCommand). The FROM snapshot is the gesture start.
-        const engine = (_b = (_a = this.host).getEngine) === null || _b === void 0 ? void 0 : _b.call(_a);
-        if (engine) {
-            void engine.commandManager.execute(new engine_1.SetStrokePointsCommand(stroke.id, to, from));
-        }
-        else {
-            this.commit(() => stroke.setPoints(to));
-        }
-        // The stroke stays selected where it now lies — a second drag picks it straight up.
-        this.highlight(to, stroke.getStyle().width, false);
-        this.host.render();
-    }
-    /** Escape / pointercancel: drop the gesture AND the selection. Nothing was committed. */
-    onCancel() {
-        this.selected = null;
-        this.startPoints = null;
-        this.origin = null;
-        this.delta = { x: 0, y: 0 };
-        super.onCancel();
-    }
-    setActive(active) {
-        if (!active) {
-            this.selected = null;
-            this.startPoints = null;
-            this.origin = null;
-        }
-        super.setActive(active);
-    }
-}
-exports.StrokeEditTool = StrokeEditTool;
-// ===========================================================================
-// Factories — the public seam
-// ===========================================================================
-function createDrawTool(host, options) {
-    return new DrawTool(host, options);
-}
-function createRectangleTool(host, options) {
-    return new RectangleTool(host, options);
-}
-function createEraserTool(host, options) {
-    return new EraserTool(host, options);
-}
-function createStrokeEditTool(host, options) {
-    return new StrokeEditTool(host, options);
-}
-// ---------------------------------------------------------------------------
-/** A pointer sample in world space, carrying pen pressure when the device reports it. */
-function sample(ev) {
-    const p = { x: ev.world.x, y: ev.world.y };
-    const src = ev.source;
-    // Pressure is kept ONLY for a pen — a mouse reports a constant 0.5 (noise), and touch
-    // "force" is wildly inconsistent across hardware. StrokeModel drops constant pressure
-    // anyway, but not recording it keeps the wire clean at the source.
-    if (src && src.pointerType === 'pen' && typeof src.pressure === 'number' && src.pressure > 0) {
-        p.pressure = src.pressure;
-    }
-    return p;
-}
-/** A normalized rectangle from two corners (drag in any direction). */
-function normRect(a, b) {
-    return {
-        x: Math.min(a.x, b.x),
-        y: Math.min(a.y, b.y),
-        width: Math.abs(b.x - a.x),
-        height: Math.abs(b.y - a.y),
-    };
-}
-//# sourceMappingURL=whiteboard-tools.js.map