js-draw 1.17.0 → 1.19.1

package/dist/mjs/toolbar/widgets/components/makeSnappedList.mjs

@@ -0,0 +1,98 @@
+import  stopPropagationOfScrollingWheelEvents  from '../../../util/stopPropagationOfScrollingWheelEvents.mjs';
+import  { MutableReactiveValue, ReactiveValue }  from '../../../util/ReactiveValue.mjs';
+/**
+ * Creates a list that snaps to each item and reports the selected item.
+ */
+const makeSnappedList = (itemsValue) => {
+    const container = document.createElement('div');
+    container.classList.add('toolbar-snapped-scroll-list');
+    const visibleIndex = MutableReactiveValue.fromInitialValue(0);
+    let observer = null;
+    const createObserver = () => {
+        observer = new IntersectionObserver((entries) => {
+            for (const entry of entries) {
+                if (entry.isIntersecting && entry.intersectionRatio > 0.7) {
+                    const indexString = entry.target.getAttribute('data-item-index');
+                    if (indexString === null)
+                        throw new Error('Could not find attribute data-item-index');
+                    const index = Number(indexString);
+                    visibleIndex.set(index);
+                    break;
+                }
+            }
+        }, {
+            // Element to use as the boudning box with which to intersect.
+            // See https://developer.mozilla.org/en-US/docs/Web/API/Intersection_Observer_API
+            root: container,
+            // Fraction of an element that must be visible to trigger the callback:
+            threshold: 0.9,
+        });
+    };
+    const destroyObserver = () => {
+        if (observer) {
+            observer.disconnect();
+            visibleIndex.set(0);
+            observer = null;
+        }
+    };
+    const wrappedItems = ReactiveValue.map(itemsValue, items => {
+        return items.map((item, index) => {
+            const wrapper = document.createElement('div');
+            if (item.element.parentElement)
+                item.element.remove();
+            wrapper.appendChild(item.element);
+            wrapper.classList.add('item');
+            wrapper.setAttribute('data-item-index', `${index}`);
+            return {
+                element: wrapper,
+                data: item.data,
+            };
+        });
+    });
+    const lastItems = [];
+    wrappedItems.onUpdateAndNow(items => {
+        visibleIndex.set(-1);
+        for (const item of lastItems) {
+            observer?.unobserve(item.element);
+        }
+        container.replaceChildren();
+        // An observer is only necessary if there are multiple items to scroll through.
+        if (items.length > 1) {
+            createObserver();
+        }
+        else {
+            destroyObserver();
+        }
+        // Different styling is applied when empty
+        if (items.length === 0) {
+            container.classList.add('-empty');
+        }
+        else {
+            container.classList.remove('-empty');
+        }
+        for (const item of items) {
+            container.appendChild(item.element);
+        }
+        visibleIndex.set(0);
+        if (observer) {
+            for (const item of items) {
+                observer.observe(item.element);
+            }
+        }
+    });
+    const visibleItem = ReactiveValue.map(visibleIndex, index => {
+        const values = itemsValue.get();
+        if (0 <= index && index < values.length) {
+            return values[index].data;
+        }
+        return null;
+    });
+    // makeSnappedList is generally shown within the toolbar. This allows users to
+    // scroll it with a touchpad.
+    stopPropagationOfScrollingWheelEvents(container);
+    return {
+        container,
+        visibleItem,
+    };
+};
+export default makeSnappedList;

package/dist/mjs/toolbar/widgets/keybindings.mjs

@@ -3,7 +3,7 @@ import  KeyboardShortcutManager  from '../../shortcuts/KeyboardShortcutManager.m
 export const resizeImageToSelectionKeyboardShortcut = 'jsdraw.toolbar.SelectionTool.resizeImageToSelection';
 KeyboardShortcutManager.registerDefaultKeyboardShortcut(resizeImageToSelectionKeyboardShortcut, ['ctrlOrMeta+r'], 'Resize image to selection');
 // Pen tool
-export const selectStrokeTypeKeyboardShortcutIds = [1, 2, 3, 4, 5, 6, 7].map(id => `jsdraw.toolbar.PenTool.select-pen-${id}`);
+export const selectStrokeTypeKeyboardShortcutIds = [1, 2, 3, 4, 5, 6, 7, 8, 9].map(id => `jsdraw.toolbar.PenTool.select-pen-${id}`);
 for (let i = 0; i < selectStrokeTypeKeyboardShortcutIds.length; i++) {
     const id = selectStrokeTypeKeyboardShortcutIds[i];
     KeyboardShortcutManager.registerDefaultKeyboardShortcut(id, [`CtrlOrMeta+Digit${(i + 1)}`], 'Select pen style ' + (i + 1));

package/dist/mjs/tools/Eraser.d.ts

@@ -1,31 +1,56 @@
-import { KeyPressEvent, PointerEvt } from '../inputEvents';
+import { GestureCancelEvt, KeyPressEvent, PointerEvt } from '../inputEvents';
 import BaseTool from './BaseTool';
 import Editor from '../Editor';
 import { MutableReactiveValue } from '../util/ReactiveValue';
+export declare enum EraserMode {
+    PartialStroke = "partial-stroke",
+    FullStroke = "full-stroke"
+}
+export interface InitialEraserOptions {
+    thickness?: number;
+    mode?: EraserMode;
+}
 export default class Eraser extends BaseTool {
     private editor;
     private lastPoint;
     private isFirstEraseEvt;
-    private toRemove;
     private thickness;
     private thicknessValue;
-    private partialCommands;
-    constructor(editor: Editor, description: string);
+    private modeValue;
+    private toRemove;
+    private toAdd;
+    private eraseCommands;
+    private addCommands;
+    constructor(editor: Editor, description: string, options?: InitialEraserOptions);
+    /**
+     * @returns a tool that briefly enables the eraser when a physical eraser is used.
+     * This tool should be added to the tool list after the primary tools.
+     */
+    makeEraserSwitcherTool(): BaseTool;
     private clearPreview;
     private getSizeOnCanvas;
     private drawPreviewAt;
+    /**
+     * @returns the eraser rectangle in canvas coordinates.
+     *
+     * For now, all erasers are rectangles or points.
+     */
     private getEraserRect;
+    /** Erases in a line from the last point to the current. */
     private eraseTo;
     onPointerDown(event: PointerEvt): boolean;
     onPointerMove(event: PointerEvt): void;
     onPointerUp(event: PointerEvt): void;
-    onGestureCancel(): void;
+    onGestureCancel(_event: GestureCancelEvt): void;
     onKeyPress(event: KeyPressEvent): boolean;
+    /** Returns the side-length of the tip of this eraser. */
     getThickness(): number;
+    /** Sets the side-length of this' tip. */
+    setThickness(thickness: number): void;
     /**
      * Returns a {@link MutableReactiveValue} that can be used to watch
      * this tool's thickness.
      */
     getThicknessValue(): MutableReactiveValue<number>;
-    setThickness(thickness: number): void;
+    getModeValue(): MutableReactiveValue<EraserMode>;
 }

package/dist/mjs/tools/Eraser.mjs

@@ -1,19 +1,74 @@
 import  { EditorEventType }  from '../types.mjs';
 import  BaseTool  from './BaseTool.mjs';
-import { Vec2, LineSegment2, Color4, Rect2 } from '@js-draw/math';
+import { Vec2, LineSegment2, Color4, Rect2, Path } from '@js-draw/math';
 import  Erase  from '../commands/Erase.mjs';
 import  { PointerDevice }  from '../Pointer.mjs';
 import  { decreaseSizeKeyboardShortcutId, increaseSizeKeyboardShortcutId }  from './keybindings.mjs';
 import  { ReactiveValue }  from '../util/ReactiveValue.mjs';
+import  EditorImage  from '../image/EditorImage.mjs';
+import  uniteCommands  from '../commands/uniteCommands.mjs';
+import  { pathToRenderable }  from '../rendering/RenderablePathSpec.mjs';
+export var EraserMode;
+(function (EraserMode) {
+    EraserMode["PartialStroke"] = "partial-stroke";
+    EraserMode["FullStroke"] = "full-stroke";
+})(EraserMode || (EraserMode = {}));
+/** Handles switching from other primary tools to the eraser and back */
+class EraserSwitcher extends BaseTool {
+    constructor(editor, eraser) {
+        super(editor.notifier, editor.localization.changeTool);
+        this.editor = editor;
+        this.eraser = eraser;
+    }
+    onPointerDown(event) {
+        if (event.allPointers.length === 1 && event.current.device === PointerDevice.Eraser) {
+            const toolController = this.editor.toolController;
+            const enabledPrimaryTools = toolController.getPrimaryTools().filter(tool => tool.isEnabled());
+            if (enabledPrimaryTools.length) {
+                this.previousEnabledTool = enabledPrimaryTools[0];
+            }
+            else {
+                this.previousEnabledTool = null;
+            }
+            this.previousEraserEnabledState = this.eraser.isEnabled();
+            this.eraser.setEnabled(true);
+            if (this.eraser.onPointerDown(event)) {
+                return true;
+            }
+            else {
+                this.restoreOriginalTool();
+            }
+        }
+        return false;
+    }
+    onPointerMove(event) {
+        this.eraser.onPointerMove(event);
+    }
+    restoreOriginalTool() {
+        this.eraser.setEnabled(this.previousEraserEnabledState);
+        if (this.previousEnabledTool) {
+            this.previousEnabledTool.setEnabled(true);
+        }
+    }
+    onPointerUp(event) {
+        this.eraser.onPointerUp(event);
+        this.restoreOriginalTool();
+    }
+    onGestureCancel(event) {
+        this.eraser.onGestureCancel(event);
+        this.restoreOriginalTool();
+    }
+}
 export default class Eraser extends BaseTool {
-    constructor(editor, description) {
+    constructor(editor, description, options) {
         super(editor.notifier, description);
         this.editor = editor;
         this.lastPoint = null;
         this.isFirstEraseEvt = true;
-        this.thickness = 10;
         // Commands that each remove one element
-        this.partialCommands = [];
+        this.eraseCommands = [];
+        this.addCommands = [];
+        this.thickness = options?.thickness ?? 10;
         this.thicknessValue = ReactiveValue.fromInitialValue(this.thickness);
         this.thicknessValue.onUpdate(value => {
             this.thickness = value;
@@ -22,6 +77,20 @@ export default class Eraser extends BaseTool {
                 tool: this,
             });
         });
+        this.modeValue = ReactiveValue.fromInitialValue(options?.mode ?? EraserMode.FullStroke);
+        this.modeValue.onUpdate(_value => {
+            this.editor.notifier.dispatch(EditorEventType.ToolUpdated, {
+                kind: EditorEventType.ToolUpdated,
+                tool: this,
+            });
+        });
+    }
+    /**
+     * @returns a tool that briefly enables the eraser when a physical eraser is used.
+     * This tool should be added to the tool list after the primary tools.
+     */
+    makeEraserSwitcherTool() {
+        return new EraserSwitcher(this.editor, this);
     }
     clearPreview() {
         this.editor.clearWetInk();
@@ -34,16 +103,24 @@ export default class Eraser extends BaseTool {
         const size = this.getSizeOnCanvas();
         const renderer = this.editor.display.getWetInkRenderer();
         const rect = this.getEraserRect(point);
+        const rect2 = this.getEraserRect(this.lastPoint ?? point);
         const fill = {
-            fill: Color4.gray,
+            fill: Color4.transparent,
+            stroke: { width: size / 10, color: Color4.gray },
         };
-        renderer.drawRect(rect, size / 4, fill);
+        renderer.drawPath(pathToRenderable(Path.fromConvexHullOf([...rect.corners, ...rect2.corners]), fill));
     }
+    /**
+     * @returns the eraser rectangle in canvas coordinates.
+     *
+     * For now, all erasers are rectangles or points.
+     */
     getEraserRect(centerPoint) {
         const size = this.getSizeOnCanvas();
         const halfSize = Vec2.of(size / 2, size / 2);
         return Rect2.fromCorners(centerPoint.minus(halfSize), centerPoint.plus(halfSize));
     }
+    /** Erases in a line from the last point to the current. */
     eraseTo(currentPoint) {
         if (!this.isFirstEraseEvt && currentPoint.distanceTo(this.lastPoint) === 0) {
             return;
@@ -60,13 +137,55 @@ export default class Eraser extends BaseTool {
         });
         // Only erase components that could be selected (and thus interacted with)
         // by the user.
-        const toErase = intersectingElems.filter(elem => elem.isSelectable());
-        // Remove any intersecting elements.
-        this.toRemove.push(...toErase);
-        // Create new Erase commands for the now-to-be-erased elements and apply them.
-        const newPartialCommands = toErase.map(elem => new Erase([elem]));
-        newPartialCommands.forEach(cmd => cmd.apply(this.editor));
-        this.partialCommands.push(...newPartialCommands);
+        const eraseableElems = intersectingElems.filter(elem => elem.isSelectable());
+        if (this.modeValue.get() === EraserMode.FullStroke) {
+            // Remove any intersecting elements.
+            this.toRemove.push(...eraseableElems);
+            // Create new Erase commands for the now-to-be-erased elements and apply them.
+            const newPartialCommands = eraseableElems.map(elem => new Erase([elem]));
+            newPartialCommands.forEach(cmd => cmd.apply(this.editor));
+            this.eraseCommands.push(...newPartialCommands);
+        }
+        else {
+            const toErase = [];
+            const toAdd = [];
+            for (const targetElem of eraseableElems) {
+                toErase.push(targetElem);
+                // Completely delete items that can't be divided.
+                if (!targetElem.withRegionErased) {
+                    continue;
+                }
+                // Completely delete items that are completely or almost completely
+                // contained within the eraser.
+                const grownRect = eraserRect.grownBy(eraserRect.maxDimension / 3);
+                if (grownRect.containsRect(targetElem.getExactBBox())) {
+                    continue;
+                }
+                // Join the current and previous rectangles so that points between events are also
+                // erased.
+                const erasePath = Path.fromConvexHullOf([
+                    ...eraserRect.corners, ...this.getEraserRect(this.lastPoint ?? currentPoint).corners
+                ].map(p => this.editor.viewport.roundPoint(p)));
+                toAdd.push(...targetElem.withRegionErased(erasePath, this.editor.viewport));
+            }
+            const eraseCommand = new Erase(toErase);
+            const newAddCommands = toAdd.map(elem => EditorImage.addElement(elem));
+            eraseCommand.apply(this.editor);
+            newAddCommands.forEach(command => command.apply(this.editor));
+            const finalToErase = [];
+            for (const item of toErase) {
+                if (this.toAdd.includes(item)) {
+                    this.toAdd = this.toAdd.filter(i => i !== item);
+                }
+                else {
+                    finalToErase.push(item);
+                }
+            }
+            this.toRemove.push(...finalToErase);
+            this.toAdd.push(...toAdd);
+            this.eraseCommands.push(new Erase(finalToErase));
+            this.addCommands.push(...newAddCommands);
+        }
         this.drawPreviewAt(currentPoint);
         this.lastPoint = currentPoint;
     }
@@ -74,6 +193,7 @@ export default class Eraser extends BaseTool {
         if (event.allPointers.length === 1 || event.current.device === PointerDevice.Eraser) {
             this.lastPoint = event.current.canvasPos;
             this.toRemove = [];
+            this.toAdd = [];
             this.isFirstEraseEvt = true;
             this.drawPreviewAt(event.current.canvasPos);
             return true;
@@ -86,18 +206,32 @@ export default class Eraser extends BaseTool {
     }
     onPointerUp(event) {
         this.eraseTo(event.current.canvasPos);
-        if (this.toRemove.length > 0) {
+        const commands = [];
+        if (this.addCommands.length > 0) {
+            this.addCommands.forEach(cmd => cmd.unapply(this.editor));
+            commands.push(...this.toAdd.map(a => EditorImage.addElement(a)));
+            this.addCommands = [];
+        }
+        if (this.eraseCommands.length > 0) {
             // Undo commands for each individual component and unite into a single command.
-            this.partialCommands.forEach(cmd => cmd.unapply(this.editor));
-            this.partialCommands = [];
+            this.eraseCommands.forEach(cmd => cmd.unapply(this.editor));
+            this.eraseCommands = [];
             const command = new Erase(this.toRemove);
-            this.editor.dispatch(command); // dispatch: Makes undo-able.
+            commands.push(command);
+        }
+        if (commands.length === 1) {
+            this.editor.dispatch(commands[0]); // dispatch: Makes undo-able.
+        }
+        else {
+            this.editor.dispatch(uniteCommands(commands));
         }
         this.clearPreview();
     }
-    onGestureCancel() {
-        this.partialCommands.forEach(cmd => cmd.unapply(this.editor));
-        this.partialCommands = [];
+    onGestureCancel(_event) {
+        this.addCommands.forEach(cmd => cmd.unapply(this.editor));
+        this.eraseCommands.forEach(cmd => cmd.unapply(this.editor));
+        this.eraseCommands = [];
+        this.addCommands = [];
         this.clearPreview();
     }
     onKeyPress(event) {
@@ -116,9 +250,14 @@ export default class Eraser extends BaseTool {
         }
         return false;
     }
+    /** Returns the side-length of the tip of this eraser. */
     getThickness() {
         return this.thickness;
     }
+    /** Sets the side-length of this' tip. */
+    setThickness(thickness) {
+        this.thicknessValue.set(thickness);
+    }
     /**
      * Returns a {@link MutableReactiveValue} that can be used to watch
      * this tool's thickness.
@@ -126,7 +265,7 @@ export default class Eraser extends BaseTool {
     getThicknessValue() {
         return this.thicknessValue;
     }
-    setThickness(thickness) {
-        this.thicknessValue.set(thickness);
+    getModeValue() {
+        return this.modeValue;
     }
 }

package/dist/mjs/tools/PasteHandler.mjs

@@ -44,7 +44,6 @@ export default class PasteHandler extends BaseTool {
             return event.data.substring(event.data.search(/<svg/i), svgEnd);
         })();
         if (svgData) {
-            console.log('svgpaste', svgData);
             void this.doSVGPaste(svgData);
             return true;
         }

package/dist/mjs/tools/SelectionTool/Selection.d.ts

@@ -10,7 +10,7 @@ import AbstractComponent from '../../components/AbstractComponent';
 import Command from '../../commands/Command';
 export default class Selection {
     private editor;
-    private handles;
+    private childwidgets;
     private originalRegion;
     private selectionTightBoundingBox;
     private transformers;
@@ -52,7 +52,7 @@ export default class Selection {
     private removedFromImage;
     private addRemoveSelectionFromImage;
     private removeDeletedElemsFromSelection;
-    private targetHandle;
+    private activeHandle;
     private backgroundDragging;
     onDragStart(pointer: Pointer): boolean;
     onDragUpdate(pointer: Pointer): void;

package/dist/mjs/tools/SelectionTool/Selection.mjs

@@ -29,7 +29,7 @@ class Selection {
         this.hasParent = true;
         // Maps IDs to whether we removed the component from the image
         this.removedFromImage = {};
-        this.targetHandle = null;
+        this.activeHandle = null;
         this.backgroundDragging = false;
         this.selectionDuplicatedAnimationTimeout = null;
         this.originalRegion = new Rect2(startPoint.x, startPoint.y, 0, 0);
@@ -71,14 +71,14 @@ class Selection {
             side: Vec2.of(0.5, 0),
             icon: this.editor.icons.makeRotateIcon(),
         }, this, this.editor.viewport, (startPoint) => this.transformers.rotate.onDragStart(startPoint), (currentPoint) => this.transformers.rotate.onDragUpdate(currentPoint), () => this.transformers.rotate.onDragEnd());
-        this.handles = [
+        this.childwidgets = [
             resizeBothHandle,
             ...resizeHorizontalHandles,
             resizeVerticalHandle,
             rotationHandle,
         ];
-        for (const handle of this.handles) {
-            handle.addTo(this.backgroundElem);
+        for (const widget of this.childwidgets) {
+            widget.addTo(this.backgroundElem);
         }
         this.updateUI();
     }
@@ -293,8 +293,8 @@ class Selection {
         else {
             this.innerContainer.classList.remove('-empty');
         }
-        for (const handle of this.handles) {
-            handle.updatePosition();
+        for (const widget of this.childwidgets) {
+            widget.updatePosition(this.getScreenRegion());
         }
     }
     // Add/remove the contents of this seleciton from the editor.
@@ -348,16 +348,16 @@ class Selection {
     onDragStart(pointer) {
         // Clear the HTML selection (prevent HTML drag and drop being triggered by this drag)
         document.getSelection()?.removeAllRanges();
-        this.targetHandle = null;
+        this.activeHandle = null;
         let result = false;
         this.backgroundDragging = false;
         if (this.region.containsPoint(pointer.canvasPos)) {
             this.backgroundDragging = true;
             result = true;
         }
-        for (const handle of this.handles) {
-            if (handle.containsPoint(pointer.canvasPos)) {
-                this.targetHandle = handle;
+        for (const widget of this.childwidgets) {
+            if (widget.containsPoint(pointer.canvasPos)) {
+                this.activeHandle = widget;
                 this.backgroundDragging = false;
                 result = true;
             }
@@ -366,8 +366,8 @@ class Selection {
             this.removeDeletedElemsFromSelection();
             this.addRemoveSelectionFromImage(false);
         }
-        if (this.targetHandle) {
-            this.targetHandle.handleDragStart(pointer);
+        if (this.activeHandle) {
+            this.activeHandle.handleDragStart(pointer);
         }
         if (this.backgroundDragging) {
             this.transformers.drag.onDragStart(pointer.canvasPos);
@@ -378,25 +378,25 @@ class Selection {
         if (this.backgroundDragging) {
             this.transformers.drag.onDragUpdate(pointer.canvasPos);
         }
-        if (this.targetHandle) {
-            this.targetHandle.handleDragUpdate(pointer);
+        if (this.activeHandle) {
+            this.activeHandle.handleDragUpdate(pointer);
         }
     }
     onDragEnd() {
         if (this.backgroundDragging) {
             this.transformers.drag.onDragEnd();
         }
-        else if (this.targetHandle) {
-            this.targetHandle.handleDragEnd();
+        else if (this.activeHandle) {
+            this.activeHandle.handleDragEnd();
         }
         this.addRemoveSelectionFromImage(true);
         this.backgroundDragging = false;
-        this.targetHandle = null;
+        this.activeHandle = null;
         this.updateUI();
     }
     onDragCancel() {
         this.backgroundDragging = false;
-        this.targetHandle = null;
+        this.activeHandle = null;
         this.setTransform(Mat33.identity);
         this.addRemoveSelectionFromImage(true);
         this.updateUI();
@@ -424,7 +424,7 @@ class Selection {
         return false;
     }
     deleteSelectedObjects() {
-        if (this.backgroundDragging || this.targetHandle) {
+        if (this.backgroundDragging || this.activeHandle) {
             this.onDragEnd();
         }
         return new Erase(this.selectedElems);
@@ -441,7 +441,7 @@ class Selection {
         }, animationDuration);
     }
     async duplicateSelectedObjects() {
-        const wasTransforming = this.backgroundDragging || this.targetHandle;
+        const wasTransforming = this.backgroundDragging || this.activeHandle;
         let tmpApplyCommand = null;
         if (!wasTransforming) {
             this.runSelectionDuplicatedAnimation();

package/dist/mjs/tools/SelectionTool/SelectionHandle.d.ts

@@ -2,6 +2,7 @@ import { Point2, Vec2 } from '@js-draw/math';
 import Selection from './Selection';
 import Pointer from '../../Pointer';
 import Viewport from '../../Viewport';
+import { SelectionBoxChild } from './types';
 export declare enum HandleAction {
     ResizeXY = "resize-xy",
     Rotate = "rotate",
@@ -17,7 +18,7 @@ export declare const handleSize = 30;
 export type DragStartCallback = (startPoint: Point2) => void;
 export type DragUpdateCallback = (canvasPoint: Point2) => void;
 export type DragEndCallback = () => Promise<void> | void;
-export default class SelectionHandle {
+export default class SelectionHandle implements SelectionBoxChild {
     readonly presentation: HandlePresentation;
     private readonly parent;
     private readonly viewport;
@@ -34,6 +35,11 @@ export default class SelectionHandle {
      * element visible on the screen.
      */
     addTo(container: HTMLElement): void;
+    /**
+     * Removes this element from its container. Should only be called
+     * after {@link addTo}.
+     */
+    remove(): void;
     /**
      * Returns this handle's bounding box relative to the top left of the
      * selection box.
@@ -48,7 +54,7 @@ export default class SelectionHandle {
     /** @returns true iff `point` (in editor **canvas** coordinates) is in this. */
     containsPoint(point: Point2): boolean;
     private dragLastPos;
-    handleDragStart(pointer: Pointer): void;
+    handleDragStart(pointer: Pointer): boolean;
     handleDragUpdate(pointer: Pointer): void;
     handleDragEnd(): void | Promise<void>;
     setSnapToGrid(snap: boolean): void;

package/dist/mjs/tools/SelectionTool/SelectionHandle.mjs

@@ -61,6 +61,11 @@ export default class SelectionHandle {
     addTo(container) {
         container.appendChild(this.element);
     }
+    /**
+     * Removes this element from its container. Should only be called
+     * after {@link addTo}.
+     */
+    remove() { this.element.remove(); }
     /**
      * Returns this handle's bounding box relative to the top left of the
      * selection box.
@@ -109,6 +114,7 @@ export default class SelectionHandle {
     handleDragStart(pointer) {
         this.onDragStart(pointer.canvasPos);
         this.dragLastPos = pointer.canvasPos;
+        return true;
     }
     handleDragUpdate(pointer) {
         if (!this.dragLastPos) {

package/dist/mjs/tools/SelectionTool/SelectionTool.mjs

@@ -398,7 +398,7 @@ class SelectionTool extends BaseTool {
                     resolve(blob);
                 }
                 else {
-                    reject('Failed to convert canvas to blob.');
+                    reject(new Error('Failed to convert canvas to blob.'));
                 }
             }, 'image/png');
         }));

package/dist/mjs/tools/SelectionTool/types.d.ts

@@ -1,3 +1,5 @@
+import type { Rect2, Point2 } from '@js-draw/math';
+import Pointer from '../../Pointer';
 export declare enum ResizeMode {
     Both = 0,
     HorizontalOnly = 1,
@@ -7,3 +9,20 @@ export declare enum TransformMode {
     Snap = 0,
     NoSnap = 1
 }
+/**
+ * Represents a child of the selection that should move with the selection
+ * and handle events.
+ *
+ * Although selection children should be `HTMLElement`s, the selection may be
+ * hidden behind an invisible element. As such, these elements should handle
+ * drag start/update/end events.
+ */
+export interface SelectionBoxChild {
+    updatePosition(selectionScreenBBox: Rect2): void;
+    containsPoint(point: Point2): boolean;
+    addTo(container: HTMLElement): void;
+    remove(): void;
+    handleDragStart(pointer: Pointer): boolean;
+    handleDragUpdate(pointer: Pointer): void;
+    handleDragEnd(): void;
+}