js-draw 1.26.0 → 1.27.1

package/dist/mjs/toolbar/widgets/SelectionToolWidget.mjs

@@ -1,13 +1,16 @@
 import { Color4 } from '@js-draw/math';
 import  { isRestylableComponent }  from '../../components/RestylableComponent.mjs';
 import  uniteCommands  from '../../commands/uniteCommands.mjs';
+import  { SelectionMode }  from '../../tools/SelectionTool/SelectionTool.mjs';
 import  { EditorEventType }  from '../../types.mjs';
 import  makeColorInput  from './components/makeColorInput.mjs';
-import  ActionButtonWidget  from './ActionButtonWidget.mjs';
 import  BaseToolWidget  from './BaseToolWidget.mjs';
 import  { resizeImageToSelectionKeyboardShortcut }  from './keybindings.mjs';
 import  makeSeparator  from './components/makeSeparator.mjs';
 import  { toolbarCSSPrefix }  from '../constants.mjs';
+import  BaseWidget  from './BaseWidget.mjs';
+import  makeButtonGrid  from './components/makeButtonGrid.mjs';
+import  { MutableReactiveValue }  from '../../util/ReactiveValue.mjs';
 const makeFormatMenu = (editor, selectionTool, localizationTable) => {
     const container = document.createElement('div');
     container.classList.add('selection-format-menu', `${toolbarCSSPrefix}spacedList`, `${toolbarCSSPrefix}indentedList`);
@@ -63,48 +66,63 @@ const makeFormatMenu = (editor, selectionTool, localizationTable) => {
         },
     };
 };
+class LassoSelectToggle extends BaseWidget {
+    constructor(editor, tool, localizationTable) {
+        super(editor, 'selection-mode-toggle', localizationTable);
+        this.tool = tool;
+        editor.notifier.on(EditorEventType.ToolUpdated, (toolEvt) => {
+            if (toolEvt.kind === EditorEventType.ToolUpdated && toolEvt.tool === tool) {
+                this.setSelected(tool.modeValue.get() === SelectionMode.Lasso);
+            }
+        });
+        this.setSelected(false);
+    }
+    shouldAutoDisableInReadOnlyEditor() {
+        return false;
+    }
+    setModeFlag(enabled) {
+        this.tool.modeValue.set(enabled ? SelectionMode.Lasso : SelectionMode.Rectangle);
+    }
+    handleClick() {
+        this.setModeFlag(!this.isSelected());
+    }
+    getTitle() {
+        return this.localizationTable.selectionTool__lassoSelect;
+    }
+    createIcon() {
+        return this.editor.icons.makeSelectionIcon(SelectionMode.Lasso);
+    }
+    fillDropdown(_dropdown) {
+        return false;
+    }
+    getHelpText() {
+        return this.localizationTable.selectionTool__lassoSelect__help;
+    }
+}
 export default class SelectionToolWidget extends BaseToolWidget {
     constructor(editor, tool, localization) {
         super(editor, tool, 'selection-tool-widget', localization);
         this.tool = tool;
         this.updateFormatMenu = () => { };
-        const resizeButton = new ActionButtonWidget(editor, 'resize-btn', () => editor.icons.makeResizeImageToSelectionIcon(), this.localizationTable.resizeImageToSelection, () => {
-            this.resizeImageToSelection();
-        }, localization);
-        resizeButton.setHelpText(this.localizationTable.selectionDropdown__resizeToHelpText);
-        const deleteButton = new ActionButtonWidget(editor, 'delete-btn', () => editor.icons.makeDeleteSelectionIcon(), this.localizationTable.deleteSelection, () => {
-            const selection = this.tool.getSelection();
-            this.editor.dispatch(selection.deleteSelectedObjects());
-            this.tool.clearSelection();
-        }, localization);
-        deleteButton.setHelpText(this.localizationTable.selectionDropdown__deleteHelpText);
-        const duplicateButton = new ActionButtonWidget(editor, 'duplicate-btn', () => editor.icons.makeDuplicateSelectionIcon(), this.localizationTable.duplicateSelection, async () => {
+        this.addSubWidget(new LassoSelectToggle(editor, tool, this.localizationTable));
+        const hasSelection = () => {
             const selection = this.tool.getSelection();
-            this.editor.dispatch(await selection.duplicateSelectedObjects());
-            this.setDropdownVisible(false);
-        }, localization);
-        duplicateButton.setHelpText(this.localizationTable.selectionDropdown__duplicateHelpText);
-        this.addSubWidget(resizeButton);
-        this.addSubWidget(deleteButton);
-        this.addSubWidget(duplicateButton);
-        const updateDisabled = (disabled) => {
-            resizeButton.setDisabled(disabled);
-            deleteButton.setDisabled(disabled);
-            duplicateButton.setDisabled(disabled);
+            return !!selection && selection.getSelectedItemCount() > 0;
         };
-        updateDisabled(true);
+        this.hasSelectionValue = MutableReactiveValue.fromInitialValue(hasSelection());
         // Enable/disable actions based on whether items are selected
         this.editor.notifier.on(EditorEventType.ToolUpdated, (toolEvt) => {
             if (toolEvt.kind !== EditorEventType.ToolUpdated) {
                 throw new Error('Invalid event type!');
             }
             if (toolEvt.tool === this.tool) {
-                const selection = this.tool.getSelection();
-                const hasSelection = selection && selection.getSelectedItemCount() > 0;
-                updateDisabled(!hasSelection);
+                this.hasSelectionValue.set(hasSelection());
                 this.updateFormatMenu();
             }
         });
+        tool.modeValue.onUpdate(() => {
+            this.updateIcon();
+        });
     }
     resizeImageToSelection() {
         const selection = this.tool.getSelection();
@@ -130,16 +148,66 @@ export default class SelectionToolWidget extends BaseToolWidget {
         return this.localizationTable.select;
     }
     createIcon() {
-        return this.editor.icons.makeSelectionIcon();
+        return this.editor.icons.makeSelectionIcon(this.tool.modeValue.get());
     }
     getHelpText() {
         return this.localizationTable.selectionDropdown__baseHelpText;
     }
+    createSelectionActions(helpDisplay) {
+        const icons = this.editor.icons;
+        const grid = makeButtonGrid([
+            {
+                icon: () => icons.makeDeleteSelectionIcon(),
+                label: this.localizationTable.deleteSelection,
+                onCreated: (button) => {
+                    helpDisplay?.registerTextHelpForElement(button, this.localizationTable.selectionDropdown__deleteHelpText);
+                },
+                onClick: () => {
+                    const selection = this.tool.getSelection();
+                    this.editor.dispatch(selection.deleteSelectedObjects());
+                    this.tool.clearSelection();
+                },
+                enabled: this.hasSelectionValue,
+            },
+            {
+                icon: () => icons.makeDuplicateSelectionIcon(),
+                label: this.localizationTable.duplicateSelection,
+                onCreated: (button) => {
+                    helpDisplay?.registerTextHelpForElement(button, this.localizationTable.selectionDropdown__duplicateHelpText);
+                },
+                onClick: async () => {
+                    const selection = this.tool.getSelection();
+                    const command = await selection?.duplicateSelectedObjects();
+                    if (command) {
+                        this.editor.dispatch(command);
+                    }
+                },
+                enabled: this.hasSelectionValue,
+            },
+            {
+                icon: () => icons.makeResizeImageToSelectionIcon(),
+                label: this.localizationTable.resizeImageToSelection,
+                onCreated: (button) => {
+                    helpDisplay?.registerTextHelpForElement(button, this.localizationTable.selectionDropdown__resizeToHelpText);
+                },
+                onClick: () => {
+                    this.resizeImageToSelection();
+                },
+                enabled: this.hasSelectionValue,
+            },
+        ], 3);
+        return { container: grid.container };
+    }
     fillDropdown(dropdown, helpDisplay) {
         super.fillDropdown(dropdown, helpDisplay);
         const controlsContainer = document.createElement('div');
         controlsContainer.classList.add(`${toolbarCSSPrefix}nonbutton-controls-main-list`);
         dropdown.appendChild(controlsContainer);
+        // Actions (duplicate, delete, etc.)
+        makeSeparator().addTo(controlsContainer);
+        const actions = this.createSelectionActions(helpDisplay);
+        controlsContainer.appendChild(actions.container);
+        // Formatting
         makeSeparator(this.localizationTable.reformatSelection).addTo(controlsContainer);
         const formatMenu = makeFormatMenu(this.editor, this.tool, this.localizationTable);
         formatMenu.addTo(controlsContainer);
@@ -150,4 +218,17 @@ export default class SelectionToolWidget extends BaseToolWidget {
         formatMenu.update();
         return true;
     }
+    serializeState() {
+        return {
+            ...super.serializeState(),
+            selectionMode: this.tool.modeValue.get(),
+        };
+    }
+    deserializeFrom(state) {
+        super.deserializeFrom(state);
+        const isValidSelectionMode = Object.values(SelectionMode).includes(state.selectionMode);
+        if (isValidSelectionMode) {
+            this.tool.modeValue.set(state.selectionMode);
+        }
+    }
 }

package/dist/mjs/toolbar/widgets/components/makeButtonGrid.d.ts

@@ -0,0 +1,17 @@
+import { ReactiveValue } from '../../../util/ReactiveValue';
+import { IconElemType } from '../../IconProvider';
+interface Button {
+    icon: () => IconElemType;
+    label: string;
+    onClick: () => void;
+    onCreated?: (button: HTMLElement) => void;
+    enabled?: ReactiveValue<boolean>;
+}
+/**
+ * Creates HTML `button` elements from `buttonSpecs` and displays them in a
+ * grid with `columnCount` columns.
+ */
+declare const makeButtonGrid: (buttonSpecs: Button[], columnCount: number) => {
+    container: HTMLDivElement;
+};
+export default makeButtonGrid;

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

@@ -0,0 +1,35 @@
+import  addLongPressOrHoverCssClasses  from '../../../util/addLongPressOrHoverCssClasses.mjs';
+/**
+ * Creates HTML `button` elements from `buttonSpecs` and displays them in a
+ * grid with `columnCount` columns.
+ */
+const makeButtonGrid = (buttonSpecs, columnCount) => {
+    const container = document.createElement('div');
+    container.classList.add('toolbar-button-grid');
+    container.style.setProperty('--column-count', `${columnCount}`);
+    const makeButton = (buttonSpec) => {
+        const buttonElement = document.createElement('button');
+        buttonElement.classList.add('button');
+        const iconElement = buttonSpec.icon();
+        iconElement.classList.add('icon');
+        const labelElement = document.createElement('label');
+        labelElement.textContent = buttonSpec.label;
+        labelElement.classList.add('button-label-text');
+        buttonElement.onclick = buttonSpec.onClick;
+        if (buttonSpec.enabled) {
+            buttonSpec.enabled.onUpdateAndNow((enabled) => {
+                buttonElement.disabled = !enabled;
+            });
+        }
+        buttonElement.replaceChildren(iconElement, labelElement);
+        container.appendChild(buttonElement);
+        addLongPressOrHoverCssClasses(buttonElement);
+        buttonSpec.onCreated?.(buttonElement);
+        return buttonElement;
+    };
+    buttonSpecs.map(makeButton);
+    return {
+        container,
+    };
+};
+export default makeButtonGrid;

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

@@ -20,7 +20,7 @@ export default class Selection {
     private innerContainer;
     private backgroundElem;
     private hasParent;
-    constructor(startPoint: Point2, editor: Editor, showContextMenu: (anchor: Point2) => void);
+    constructor(selectedElems: AbstractComponent[], editor: Editor, showContextMenu: (anchor: Point2) => void);
     getBackgroundElem(): HTMLElement;
     getTransform(): Mat33;
     get preTransformRegion(): Rect2;
@@ -43,7 +43,6 @@ export default class Selection {
     sendToBack(): SerializableCommand | null;
     private static ApplyTransformationCommand;
     private previewTransformCmds;
-    resolveToObjects(): boolean;
     recomputeRegion(): boolean;
     padRegion(): void;
     getMinCanvasSize(): number;
@@ -63,10 +62,10 @@ export default class Selection {
     private selectionDuplicatedAnimationTimeout;
     private runSelectionDuplicatedAnimation;
     duplicateSelectedObjects(): Promise<Command>;
+    snapSelectedObjectsToGrid(): void;
     setHandlesVisible(showHandles: boolean): void;
     addTo(elem: HTMLElement): void;
     setToPoint(point: Point2): void;
     cancelSelection(): void;
-    setSelectedObjects(objects: AbstractComponent[], bbox: Rect2): void;
     getSelectedObjects(): AbstractComponent[];
 }

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

@@ -19,7 +19,7 @@ const updateChunkSize = 100;
 const maxPreviewElemCount = 500;
 // @internal
 class Selection {
-    constructor(startPoint, editor, showContextMenu) {
+    constructor(selectedElems, editor, showContextMenu) {
         this.editor = editor;
         // The last-computed bounding box of selected content
         // @see getTightBoundingBox
@@ -33,7 +33,9 @@ class Selection {
         this.activeHandle = null;
         this.backgroundDragging = false;
         this.selectionDuplicatedAnimationTimeout = null;
-        this.originalRegion = new Rect2(startPoint.x, startPoint.y, 0, 0);
+        selectedElems = [...selectedElems];
+        this.selectedElems = selectedElems;
+        this.originalRegion = Rect2.empty;
         this.transformers = {
             drag: new DragTransformer(editor, this),
             resize: new ResizeTransformer(editor, this),
@@ -83,6 +85,7 @@ class Selection {
         for (const widget of this.childwidgets) {
             widget.addTo(this.backgroundElem);
         }
+        this.recomputeRegion();
         this.updateUI();
     }
     // @internal Intended for unit tests
@@ -205,34 +208,6 @@ class Selection {
         wetInkRenderer.popTransform();
         this.updateUI();
     }
-    // Find the objects corresponding to this in the document,
-    // select them.
-    // Returns false iff nothing was selected.
-    resolveToObjects() {
-        let singleItemSelectionMode = false;
-        this.transform = Mat33.identity;
-        // Grow the rectangle, if necessary
-        if (this.region.w === 0 || this.region.h === 0) {
-            const padding = this.editor.viewport.visibleRect.maxDimension / 200;
-            this.originalRegion = Rect2.bboxOf(this.region.corners, padding);
-            // Only select one item if the rectangle was very small.
-            singleItemSelectionMode = true;
-        }
-        this.selectedElems = this.editor.image
-            .getElementsIntersectingRegion(this.region)
-            .filter((elem) => {
-            return elem.intersectsRect(this.region) && elem.isSelectable();
-        });
-        if (singleItemSelectionMode && this.selectedElems.length > 0) {
-            this.selectedElems = [this.selectedElems[this.selectedElems.length - 1]];
-        }
-        // Find the bounding box of all selected elements.
-        if (!this.recomputeRegion()) {
-            return false;
-        }
-        this.updateUI();
-        return true;
-    }
     // Recompute this' region from the selected elements.
     // Returns false if the selection is empty.
     recomputeRegion() {
@@ -354,6 +329,10 @@ class Selection {
         });
     }
     onDragStart(pointer) {
+        // If empty, it isn't possible to drag
+        if (this.selectedElems.length === 0) {
+            return false;
+        }
         // Clear the HTML selection (prevent HTML drag and drop being triggered by this drag)
         document.getSelection()?.removeAllRanges();
         this.activeHandle = null;
@@ -479,6 +458,16 @@ class Selection {
         }
         return command;
     }
+    snapSelectedObjectsToGrid() {
+        const viewport = this.editor.viewport;
+        // Snap the top left corner of what we have selected.
+        const topLeftOfBBox = this.computeTightBoundingBox().topLeft;
+        const snappedTopLeft = viewport.snapToGrid(topLeftOfBBox);
+        const snapDelta = snappedTopLeft.minus(topLeftOfBBox);
+        const oldTransform = this.getTransform();
+        this.setTransform(oldTransform.rightMul(Mat33.translation(snapDelta)));
+        this.finalizeTransform();
+    }
     setHandlesVisible(showHandles) {
         if (!showHandles) {
             this.innerContainer.classList.add('-hide-handles');
@@ -507,16 +496,6 @@ class Selection {
         this.selectionTightBoundingBox = null;
         this.hasParent = false;
     }
-    setSelectedObjects(objects, bbox) {
-        this.addRemoveSelectionFromImage(true);
-        this.originalRegion = bbox;
-        this.selectionTightBoundingBox = bbox;
-        this.selectedElems = objects.filter((object) => object.isSelectable());
-        // Enforce increasing z-index invariant
-        this.selectedElems.sort((a, b) => a.getZIndex() - b.getZIndex());
-        this.padRegion();
-        this.updateUI();
-    }
     getSelectedObjects() {
         return [...this.selectedElems];
     }

package/dist/mjs/tools/SelectionTool/SelectionBuilders/LassoSelectionBuilder.d.ts

@@ -0,0 +1,17 @@
+import { Path, Point2 } from '@js-draw/math';
+import Viewport from '../../../Viewport';
+import EditorImage from '../../../image/EditorImage';
+import AbstractComponent from '../../../components/AbstractComponent';
+import SelectionBuilder from './SelectionBuilder';
+/**
+ * Creates lasso selections.
+ */
+export default class LassoSelectionBuilder extends SelectionBuilder {
+    private viewport;
+    private boundaryPoints;
+    private lastPoint;
+    constructor(startPoint: Point2, viewport: Viewport);
+    onPointerMove(canvasPoint: Point2): void;
+    previewPath(): Path;
+    resolveInternal(image: EditorImage): AbstractComponent[];
+}

package/dist/mjs/tools/SelectionTool/SelectionBuilders/LassoSelectionBuilder.mjs

@@ -0,0 +1,61 @@
+import { Path } from '@js-draw/math';
+import { PathCommandType } from '@js-draw/math';
+import  SelectionBuilder  from './SelectionBuilder.mjs';
+/**
+ * Creates lasso selections.
+ */
+export default class LassoSelectionBuilder extends SelectionBuilder {
+    constructor(startPoint, viewport) {
+        super();
+        this.viewport = viewport;
+        this.boundaryPoints = [];
+        this.boundaryPoints.push(startPoint);
+        this.lastPoint = startPoint;
+    }
+    onPointerMove(canvasPoint) {
+        const lastBoundaryPoint = this.boundaryPoints[this.boundaryPoints.length - 1];
+        const minBoundaryDist = this.viewport.getSizeOfPixelOnCanvas() * 8;
+        if (lastBoundaryPoint.distanceTo(canvasPoint) >= minBoundaryDist) {
+            this.boundaryPoints.push(canvasPoint);
+        }
+        this.lastPoint = canvasPoint;
+    }
+    previewPath() {
+        const pathCommands = this.boundaryPoints.map((point) => {
+            return { kind: PathCommandType.LineTo, point };
+        });
+        pathCommands.push({
+            kind: PathCommandType.LineTo,
+            point: this.lastPoint,
+        });
+        return new Path(this.boundaryPoints[0], pathCommands).asClosed();
+    }
+    resolveInternal(image) {
+        const path = this.previewPath();
+        const lines = path.polylineApproximation();
+        const candidates = image.getElementsIntersectingRegion(path.bbox);
+        const componentIsInSelection = (component) => {
+            if (path.closedContainsRect(component.getExactBBox())) {
+                return true;
+            }
+            let hasKeyPoint = false;
+            for (const point of component.keyPoints()) {
+                if (path.closedContainsPoint(point)) {
+                    hasKeyPoint = true;
+                    break;
+                }
+            }
+            if (!hasKeyPoint) {
+                return false;
+            }
+            // Only select if completely contained within the lasso
+            for (const line of lines) {
+                if (component.intersects(line)) {
+                    return false;
+                }
+            }
+            return true;
+        };
+        return candidates.filter(componentIsInSelection);
+    }
+}

package/dist/mjs/tools/SelectionTool/SelectionBuilders/RectSelectionBuilder.d.ts

@@ -0,0 +1,13 @@
+import { Path, Point2 } from '@js-draw/math';
+import EditorImage from '../../../image/EditorImage';
+import SelectionBuilder from './SelectionBuilder';
+/**
+ * Creates rectangle selections
+ */
+export default class RectSelectionBuilder extends SelectionBuilder {
+    private rect;
+    constructor(startPoint: Point2);
+    onPointerMove(canvasPoint: Point2): void;
+    previewPath(): Path;
+    resolveInternal(image: EditorImage): import("../../../lib").AbstractComponent[];
+}

package/dist/mjs/tools/SelectionTool/SelectionBuilders/RectSelectionBuilder.mjs

@@ -0,0 +1,27 @@
+import { Path, Rect2 } from '@js-draw/math';
+import  SelectionBuilder  from './SelectionBuilder.mjs';
+/**
+ * Creates rectangle selections
+ */
+export default class RectSelectionBuilder extends SelectionBuilder {
+    constructor(startPoint) {
+        super();
+        this.rect = Rect2.fromCorners(startPoint, startPoint);
+    }
+    onPointerMove(canvasPoint) {
+        this.rect = this.rect.grownToPoint(canvasPoint);
+    }
+    previewPath() {
+        return Path.fromRect(this.rect);
+    }
+    resolveInternal(image) {
+        return image.getElementsIntersectingRegion(this.rect).filter((element) => {
+            // Filter out the case where the selection rectangle is completely contained
+            // within the element (and does not intersect it).
+            // This is useful, for example, if a very large stroke is used as the background
+            // for another drawing. This prevents the very large stroke from being selected
+            // unless the selection touches one of its edges.
+            return element.intersectsRect(this.rect);
+        });
+    }
+}

package/dist/mjs/tools/SelectionTool/SelectionBuilders/SelectionBuilder.d.ts

@@ -0,0 +1,15 @@
+import { Color4, Path, Point2 } from '@js-draw/math';
+import AbstractRenderer from '../../../rendering/renderers/AbstractRenderer';
+import EditorImage from '../../../image/EditorImage';
+import AbstractComponent from '../../../components/AbstractComponent';
+import Viewport from '../../../Viewport';
+export default abstract class SelectionBuilder {
+    abstract onPointerMove(canvasPoint: Point2): void;
+    abstract previewPath(): Path;
+    /** Returns the components currently in the selection bounds. Used by {@link resolve}. */
+    protected abstract resolveInternal(image: EditorImage): AbstractComponent[];
+    /** Renders a preview of the selection bounds */
+    render(renderer: AbstractRenderer, color: Color4): void;
+    /** Converts the selection preview into a set of selected elements */
+    resolve(image: EditorImage, viewport: Viewport): AbstractComponent[];
+}

package/dist/mjs/tools/SelectionTool/SelectionBuilders/SelectionBuilder.mjs

@@ -0,0 +1,36 @@
+import  { pathToRenderable }  from '../../../rendering/RenderablePathSpec.mjs';
+export default class SelectionBuilder {
+    /** Renders a preview of the selection bounds */
+    render(renderer, color) {
+        renderer.drawPath(pathToRenderable(this.previewPath(), { fill: color }));
+    }
+    /** Converts the selection preview into a set of selected elements */
+    resolve(image, viewport) {
+        const path = this.previewPath();
+        const filterComponents = (components) => {
+            return components.filter((component) => {
+                return component.isSelectable();
+            });
+        };
+        let components;
+        // If the bounding box is very small, search for items **near** the bounding box,
+        // rather than in the bounding box.
+        const clickSize = viewport.getSizeOfPixelOnCanvas() * 3;
+        const isClick = path.bbox.maxDimension <= clickSize;
+        if (isClick) {
+            const searchRegionSize = viewport.visibleRect.maxDimension / 200;
+            const minSizeBox = path.bbox.grownBy(searchRegionSize);
+            components = image.getElementsIntersectingRegion(minSizeBox).filter((component) => {
+                return minSizeBox.containsRect(component.getBBox()) || component.intersectsRect(minSizeBox);
+            });
+            components = filterComponents(components);
+            if (components.length > 1) {
+                components = [components[0]];
+            }
+        }
+        else {
+            components = filterComponents(this.resolveInternal(image));
+        }
+        return components;
+    }
+}

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

@@ -3,13 +3,18 @@ import Editor from '../../Editor';
 import { ContextMenuEvt, CopyEvent, KeyPressEvent, KeyUpEvent, PointerEvt } from '../../inputEvents';
 import BaseTool from '../BaseTool';
 import Selection from './Selection';
+import { MutableReactiveValue } from '../../util/ReactiveValue';
+import { SelectionMode } from './types';
 export declare const cssPrefix = "selection-tool-";
+export { SelectionMode };
 export default class SelectionTool extends BaseTool {
     private editor;
+    readonly modeValue: MutableReactiveValue<SelectionMode>;
+    private selectionBuilder;
     private handleOverlay;
     private prevSelectionBox;
     private selectionBox;
-    private rebuildSelectionScheduled;
+    private removeSelectionScheduled;
     private startPoint;
     private expandingSelectionBox;
     private shiftKeyPressed;
@@ -17,8 +22,8 @@ export default class SelectionTool extends BaseTool {
     private lastPointer;
     private autoscroller;
     constructor(editor: Editor, description: string);
+    private getSelectionColor;
     private makeSelectionBox;
-    private snapSelectionToGrid;
     private showContextMenu;
     onContextMenu(event: ContextMenuEvt): boolean;
     private selectionBoxHandlingEvt;
@@ -36,7 +41,10 @@ export default class SelectionTool extends BaseTool {
     onCopy(event: CopyEvent): boolean;
     setEnabled(enabled: boolean): void;
     getSelection(): Selection | null;
+    /** @returns true if the selection is currently being created by the user. */
+    isSelecting(): boolean;
     getSelectedObjects(): AbstractComponent[];
     setSelection(objects: AbstractComponent[]): void;
+    private clearSelectionNoUpdateEvent;
     clearSelection(): void;
 }