js-draw 1.20.3 → 1.21.1

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

@@ -1,137 +0,0 @@
-import  { assertUnreachable }  from '../../util/assertions.mjs';
-import { Rect2, Vec2 } from '@js-draw/math';
-import  { cssPrefix }  from './SelectionTool.mjs';
-var HandleShape;
-(function (HandleShape) {
-    HandleShape[HandleShape["Circle"] = 0] = "Circle";
-    HandleShape[HandleShape["Square"] = 1] = "Square";
-})(HandleShape || (HandleShape = {}));
-export var HandleAction;
-(function (HandleAction) {
-    HandleAction["ResizeXY"] = "resize-xy";
-    HandleAction["Rotate"] = "rotate";
-    HandleAction["ResizeX"] = "resize-x";
-    HandleAction["ResizeY"] = "resize-y";
-})(HandleAction || (HandleAction = {}));
-// The *interactable* handle size. The visual size will be slightly smaller.
-export const handleSize = 30;
-export default class SelectionHandle {
-    constructor(presentation, parent, viewport, onDragStart, onDragUpdate, onDragEnd) {
-        this.presentation = presentation;
-        this.parent = parent;
-        this.viewport = viewport;
-        this.onDragStart = onDragStart;
-        this.onDragUpdate = onDragUpdate;
-        this.onDragEnd = onDragEnd;
-        this.dragLastPos = null;
-        this.element = document.createElement('div');
-        this.element.classList.add(`${cssPrefix}handle`, `${cssPrefix}${presentation.action}`);
-        // Create a slightly smaller content/background element.
-        const visibleContent = document.createElement('div');
-        visibleContent.classList.add(`${cssPrefix}content`);
-        this.element.appendChild(visibleContent);
-        this.parentSide = presentation.side;
-        const icon = presentation.icon;
-        if (icon) {
-            visibleContent.appendChild(icon);
-            icon.classList.add('icon');
-        }
-        if (presentation.action === HandleAction.Rotate) {
-            this.shape = HandleShape.Circle;
-        }
-        else {
-            this.shape = HandleShape.Square;
-        }
-        switch (this.shape) {
-            case HandleShape.Circle:
-                this.element.classList.add(`${cssPrefix}circle`);
-                break;
-            case HandleShape.Square:
-                this.element.classList.add(`${cssPrefix}square`);
-                break;
-            default:
-                assertUnreachable(this.shape);
-        }
-        this.updatePosition();
-    }
-    /**
-     * Adds this to `container`, where `conatiner` should be the background/selection
-     * element visible on the screen.
-     */
-    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.
-     */
-    getBBoxParentCoords() {
-        const parentRect = this.parent.getScreenRegion();
-        const size = Vec2.of(handleSize, handleSize);
-        const topLeft = parentRect.size.scale(this.parentSide)
-            // Center
-            .minus(size.times(1 / 2));
-        return new Rect2(topLeft.x, topLeft.y, size.x, size.y);
-    }
-    /** @returns this handle's bounding box relative to the canvas. */
-    getBBoxCanvasCoords() {
-        const parentRect = this.parent.region;
-        const size = Vec2.of(handleSize, handleSize).times(1 / this.viewport.getScaleFactor());
-        const topLeftFromParent = parentRect.size.scale(this.parentSide).minus(size.times(0.5));
-        return new Rect2(topLeftFromParent.x, topLeftFromParent.y, size.x, size.y).translatedBy(parentRect.topLeft);
-    }
-    /**
-     * Moves the HTML representation of this to the location matching its internal representation.
-     */
-    updatePosition() {
-        const bbox = this.getBBoxParentCoords();
-        // Position within the selection box.
-        this.element.style.marginLeft = `${bbox.topLeft.x}px`;
-        this.element.style.marginTop = `${bbox.topLeft.y}px`;
-        this.element.style.width = `${bbox.w}px`;
-        this.element.style.height = `${bbox.h}px`;
-    }
-    /** @returns true iff `point` (in editor **canvas** coordinates) is in this. */
-    containsPoint(point) {
-        const bbox = this.getBBoxCanvasCoords();
-        const delta = point.minus(bbox.center);
-        // Should have same x and y radius
-        const radius = bbox.size.x / 2;
-        let result;
-        if (this.shape === HandleShape.Circle) {
-            result = delta.magnitude() <= radius;
-        }
-        else {
-            result = Math.abs(delta.x) <= radius && Math.abs(delta.y) <= radius;
-        }
-        return result;
-    }
-    handleDragStart(pointer) {
-        this.onDragStart(pointer.canvasPos);
-        this.dragLastPos = pointer.canvasPos;
-        return true;
-    }
-    handleDragUpdate(pointer) {
-        if (!this.dragLastPos) {
-            return;
-        }
-        this.onDragUpdate(pointer.canvasPos);
-    }
-    handleDragEnd() {
-        if (!this.dragLastPos) {
-            return;
-        }
-        return this.onDragEnd();
-    }
-    setSnapToGrid(snap) {
-        this.snapToGrid = snap;
-    }
-    isSnappingToGrid() {
-        return this.snapToGrid;
-    }
-}

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

@@ -1,40 +0,0 @@
-import AbstractComponent from '../../components/AbstractComponent';
-import Editor from '../../Editor';
-import { CopyEvent, KeyPressEvent, KeyUpEvent, PointerEvt } from '../../inputEvents';
-import BaseTool from '../BaseTool';
-import Selection from './Selection';
-export declare const cssPrefix = "selection-tool-";
-export default class SelectionTool extends BaseTool {
-    private editor;
-    private handleOverlay;
-    private prevSelectionBox;
-    private selectionBox;
-    private startPoint;
-    private expandingSelectionBox;
-    private shiftKeyPressed;
-    private snapToGrid;
-    private lastPointer;
-    private autoscroller;
-    constructor(editor: Editor, description: string);
-    private makeSelectionBox;
-    private snapSelectionToGrid;
-    private selectionBoxHandlingEvt;
-    onPointerDown({ allPointers, current }: PointerEvt): boolean;
-    onPointerMove(event: PointerEvt): void;
-    private onMainPointerUpdated;
-    onPointerUp(event: PointerEvt): void;
-    onGestureCancel(): void;
-    private lastSelectedObjects;
-    private onSelectionUpdated;
-    private zoomToSelection;
-    private static handleableKeys;
-    private hasUnfinalizedTransformFromKeyPress;
-    onKeyPress(event: KeyPressEvent): boolean;
-    onKeyUp(evt: KeyUpEvent): boolean;
-    onCopy(event: CopyEvent): boolean;
-    setEnabled(enabled: boolean): void;
-    getSelection(): Selection | null;
-    getSelectedObjects(): AbstractComponent[];
-    setSelection(objects: AbstractComponent[]): void;
-    clearSelection(): void;
-}

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

@@ -1,488 +0,0 @@
-import { Mat33, Vec2 } from '@js-draw/math';
-import  { EditorEventType }  from '../../types.mjs';
-import  Viewport  from '../../Viewport.mjs';
-import  BaseTool  from '../BaseTool.mjs';
-import  CanvasRenderer  from '../../rendering/renderers/CanvasRenderer.mjs';
-import  SVGRenderer  from '../../rendering/renderers/SVGRenderer.mjs';
-import  Selection  from './Selection.mjs';
-import  TextComponent  from '../../components/TextComponent.mjs';
-import  { duplicateSelectionShortcut, selectAllKeyboardShortcut, sendToBackSelectionShortcut, snapToGridKeyboardShortcutId }  from '../keybindings.mjs';
-import  ToPointerAutoscroller  from './ToPointerAutoscroller.mjs';
-export const cssPrefix = 'selection-tool-';
-// Allows users to select/transform portions of the `EditorImage`.
-// With respect to `extend`ing, `SelectionTool` is not stable.
-class SelectionTool extends BaseTool {
-    constructor(editor, description) {
-        super(editor.notifier, description);
-        this.editor = editor;
-        this.startPoint = null; // canvas position
-        this.expandingSelectionBox = false;
-        this.shiftKeyPressed = false;
-        this.snapToGrid = false;
-        this.lastPointer = null;
-        this.selectionBoxHandlingEvt = false;
-        this.lastSelectedObjects = [];
-        // Whether the last keypress corresponded to an action that didn't transform the
-        // selection (and thus does not need to be finalized on onKeyUp).
-        this.hasUnfinalizedTransformFromKeyPress = false;
-        this.autoscroller = new ToPointerAutoscroller(editor.viewport, (scrollBy) => {
-            editor.dispatch(Viewport.transformBy(Mat33.translation(scrollBy)), false);
-            // Update the selection box/content to match the new viewport.
-            if (this.lastPointer) {
-                // The viewport has changed -- ensure that the screen and canvas positions
-                // of the pointer are both correct
-                const updatedPointer = this.lastPointer.withScreenPosition(this.lastPointer.screenPos, editor.viewport);
-                this.onMainPointerUpdated(updatedPointer);
-            }
-        });
-        this.handleOverlay = document.createElement('div');
-        editor.createHTMLOverlay(this.handleOverlay);
-        this.handleOverlay.style.display = 'none';
-        this.handleOverlay.classList.add('handleOverlay');
-        editor.notifier.on(EditorEventType.ViewportChanged, _data => {
-            // The selection box could be using the wet ink display if its transformation
-            // hasn't been finalized yet. Clear before updating the UI.
-            this.editor.clearWetInk();
-            // If not currently selecting, ensure that the selection box
-            // is large enough.
-            if (!this.expandingSelectionBox) {
-                this.selectionBox?.padRegion();
-            }
-            this.selectionBox?.updateUI();
-        });
-        this.editor.handleKeyEventsFrom(this.handleOverlay);
-        this.editor.handlePointerEventsFrom(this.handleOverlay);
-    }
-    makeSelectionBox(selectionStartPos) {
-        this.prevSelectionBox = this.selectionBox;
-        this.selectionBox = new Selection(selectionStartPos, this.editor);
-        if (!this.expandingSelectionBox) {
-            // Remove any previous selection rects
-            this.prevSelectionBox?.cancelSelection();
-        }
-        this.selectionBox.addTo(this.handleOverlay);
-    }
-    snapSelectionToGrid() {
-        if (!this.selectionBox)
-            throw new Error('No selection to snap!');
-        // Snap the top left corner of what we have selected.
-        const topLeftOfBBox = this.selectionBox.computeTightBoundingBox().topLeft;
-        const snappedTopLeft = this.editor.viewport.snapToGrid(topLeftOfBBox);
-        const snapDelta = snappedTopLeft.minus(topLeftOfBBox);
-        const oldTransform = this.selectionBox.getTransform();
-        this.selectionBox.setTransform(oldTransform.rightMul(Mat33.translation(snapDelta)));
-        this.selectionBox.finalizeTransform();
-    }
-    onPointerDown({ allPointers, current }) {
-        const snapToGrid = this.snapToGrid;
-        if (snapToGrid) {
-            current = current.snappedToGrid(this.editor.viewport);
-        }
-        if (allPointers.length === 1 && current.isPrimary) {
-            this.startPoint = current.canvasPos;
-            let transforming = false;
-            if (this.selectionBox) {
-                if (snapToGrid) {
-                    this.snapSelectionToGrid();
-                }
-                const dragStartResult = this.selectionBox.onDragStart(current);
-                if (dragStartResult) {
-                    transforming = true;
-                    this.selectionBoxHandlingEvt = true;
-                    this.expandingSelectionBox = false;
-                }
-            }
-            if (!transforming) {
-                // Shift key: Combine the new and old selection boxes at the end of the gesture.
-                this.expandingSelectionBox = this.shiftKeyPressed;
-                this.makeSelectionBox(current.canvasPos);
-            }
-            else {
-                // Only autoscroll if we're transforming an existing selection
-                this.autoscroller.start();
-            }
-            return true;
-        }
-        return false;
-    }
-    onPointerMove(event) {
-        this.onMainPointerUpdated(event.current);
-    }
-    onMainPointerUpdated(currentPointer) {
-        this.lastPointer = currentPointer;
-        if (!this.selectionBox)
-            return;
-        this.autoscroller.onPointerMove(currentPointer.screenPos);
-        if (!this.expandingSelectionBox && this.shiftKeyPressed && this.startPoint) {
-            const screenPos = this.editor.viewport.canvasToScreen(this.startPoint);
-            currentPointer = currentPointer.lockedToXYAxesScreen(screenPos, this.editor.viewport);
-        }
-        if (this.snapToGrid) {
-            currentPointer = currentPointer.snappedToGrid(this.editor.viewport);
-        }
-        if (this.selectionBoxHandlingEvt) {
-            this.selectionBox.onDragUpdate(currentPointer);
-        }
-        else {
-            this.selectionBox.setToPoint(currentPointer.canvasPos);
-        }
-    }
-    onPointerUp(event) {
-        this.autoscroller.stop();
-        if (!this.selectionBox)
-            return;
-        let currentPointer = event.current;
-        if (this.snapToGrid) {
-            currentPointer = currentPointer.snappedToGrid(this.editor.viewport);
-        }
-        this.selectionBox.setToPoint(currentPointer.canvasPos);
-        // Were we expanding the previous selection?
-        if (this.expandingSelectionBox && this.prevSelectionBox) {
-            // If so, finish expanding.
-            this.expandingSelectionBox = false;
-            this.selectionBox.resolveToObjects();
-            this.setSelection([
-                ...this.selectionBox.getSelectedObjects(),
-                ...this.prevSelectionBox.getSelectedObjects(),
-            ]);
-        }
-        else {
-            if (!this.selectionBoxHandlingEvt) {
-                // Expand/shrink the selection rectangle, if applicable
-                this.selectionBox.resolveToObjects();
-                this.onSelectionUpdated();
-            }
-            else {
-                this.selectionBox.onDragEnd();
-            }
-            this.selectionBoxHandlingEvt = false;
-            this.lastPointer = null;
-        }
-    }
-    onGestureCancel() {
-        this.autoscroller.stop();
-        if (this.selectionBoxHandlingEvt) {
-            this.selectionBox?.onDragCancel();
-        }
-        else {
-            // Revert to the previous selection, if any.
-            this.selectionBox?.cancelSelection();
-            this.selectionBox = this.prevSelectionBox;
-            this.selectionBox?.addTo(this.handleOverlay);
-            this.selectionBox?.recomputeRegion();
-            this.prevSelectionBox = null;
-        }
-        this.expandingSelectionBox = false;
-        this.lastPointer = null;
-        this.selectionBoxHandlingEvt = false;
-    }
-    onSelectionUpdated() {
-        const selectedItemCount = this.selectionBox?.getSelectedItemCount() ?? 0;
-        const selectedObjects = this.selectionBox?.getSelectedObjects() ?? [];
-        const hasDifferentSelection = this.lastSelectedObjects.length !== selectedItemCount
-            || selectedObjects.some((obj, i) => this.lastSelectedObjects[i] !== obj);
-        if (hasDifferentSelection) {
-            this.lastSelectedObjects = selectedObjects;
-            // Note that the selection has changed
-            this.editor.notifier.dispatch(EditorEventType.ToolUpdated, {
-                kind: EditorEventType.ToolUpdated,
-                tool: this,
-            });
-            // Only fire the SelectionUpdated event if the selection really updated.
-            this.editor.notifier.dispatch(EditorEventType.SelectionUpdated, {
-                kind: EditorEventType.SelectionUpdated,
-                selectedComponents: selectedObjects,
-                tool: this,
-            });
-            if (selectedItemCount > 0) {
-                this.editor.announceForAccessibility(this.editor.localization.selectedElements(selectedItemCount));
-                this.zoomToSelection();
-            }
-        }
-        if (selectedItemCount === 0 && this.selectionBox) {
-            this.selectionBox.cancelSelection();
-            this.prevSelectionBox = this.selectionBox;
-            this.selectionBox = null;
-        }
-    }
-    zoomToSelection() {
-        if (this.selectionBox) {
-            const selectionRect = this.selectionBox.region;
-            this.editor.dispatchNoAnnounce(this.editor.viewport.zoomTo(selectionRect, false), false);
-        }
-    }
-    onKeyPress(event) {
-        const shortcucts = this.editor.shortcuts;
-        if (shortcucts.matchesShortcut(snapToGridKeyboardShortcutId, event)) {
-            this.snapToGrid = true;
-            return true;
-        }
-        if (this.selectionBox && (shortcucts.matchesShortcut(duplicateSelectionShortcut, event)
-            || shortcucts.matchesShortcut(sendToBackSelectionShortcut, event))) {
-            // Handle duplication on key up — we don't want to accidentally duplicate
-            // many times.
-            return true;
-        }
-        else if (shortcucts.matchesShortcut(selectAllKeyboardShortcut, event)) {
-            this.setSelection(this.editor.image.getAllElements());
-            return true;
-        }
-        else if (event.ctrlKey) {
-            // Don't transform the selection with, for example, ctrl+i.
-            // Pass it to another tool, if apliccable.
-            return false;
-        }
-        else if (event.shiftKey || event.key === 'Shift') {
-            this.shiftKeyPressed = true;
-            if (event.key === 'Shift') {
-                return true;
-            }
-        }
-        let rotationSteps = 0;
-        let xTranslateSteps = 0;
-        let yTranslateSteps = 0;
-        let xScaleSteps = 0;
-        let yScaleSteps = 0;
-        switch (event.key) {
-            case 'a':
-            case 'h':
-            case 'ArrowLeft':
-                xTranslateSteps -= 1;
-                break;
-            case 'd':
-            case 'l':
-            case 'ArrowRight':
-                xTranslateSteps += 1;
-                break;
-            case 'q':
-            case 'k':
-            case 'ArrowUp':
-                yTranslateSteps -= 1;
-                break;
-            case 'e':
-            case 'j':
-            case 'ArrowDown':
-                yTranslateSteps += 1;
-                break;
-            case 'r':
-                rotationSteps += 1;
-                break;
-            case 'R':
-                rotationSteps -= 1;
-                break;
-            case 'i':
-                xScaleSteps -= 1;
-                break;
-            case 'I':
-                xScaleSteps += 1;
-                break;
-            case 'o':
-                yScaleSteps -= 1;
-                break;
-            case 'O':
-                yScaleSteps += 1;
-                break;
-        }
-        let handled = xTranslateSteps !== 0
-            || yTranslateSteps !== 0
-            || rotationSteps !== 0
-            || xScaleSteps !== 0
-            || yScaleSteps !== 0;
-        if (!this.selectionBox) {
-            handled = false;
-        }
-        else if (handled) {
-            const translateStepSize = 10 * this.editor.viewport.getSizeOfPixelOnCanvas();
-            const rotateStepSize = Math.PI / 8;
-            const scaleStepSize = 5 / 4;
-            const region = this.selectionBox.region;
-            const scaleFactor = Vec2.of(scaleStepSize ** xScaleSteps, scaleStepSize ** yScaleSteps);
-            const rotationMat = Mat33.zRotation(rotationSteps * rotateStepSize);
-            const roundedRotationMatrix = rotationMat.mapEntries(component => Viewport.roundScaleRatio(component));
-            const regionCenter = this.editor.viewport.roundPoint(region.center);
-            const transform = Mat33.scaling2D(scaleFactor, this.editor.viewport.roundPoint(region.topLeft)).rightMul(Mat33.translation(regionCenter).rightMul(roundedRotationMatrix).rightMul(Mat33.translation(regionCenter.times(-1)))).rightMul(Mat33.translation(this.editor.viewport.roundPoint(Vec2.of(xTranslateSteps, yTranslateSteps).times(translateStepSize))));
-            const oldTransform = this.selectionBox.getTransform();
-            this.selectionBox.setTransform(oldTransform.rightMul(transform));
-            this.selectionBox.scrollTo();
-            // The transformation needs to be finalized at some point (on key up)
-            this.hasUnfinalizedTransformFromKeyPress = true;
-        }
-        if (this.selectionBox && !handled && (event.key === 'Delete' || event.key === 'Backspace')) {
-            this.editor.dispatch(this.selectionBox.deleteSelectedObjects());
-            this.clearSelection();
-            handled = true;
-        }
-        return handled;
-    }
-    onKeyUp(evt) {
-        const shortcucts = this.editor.shortcuts;
-        if (shortcucts.matchesShortcut(snapToGridKeyboardShortcutId, evt)) {
-            this.snapToGrid = false;
-            return true;
-        }
-        if (shortcucts.matchesShortcut(selectAllKeyboardShortcut, evt)) {
-            // Selected all in onKeyDown. Don't finalizeTransform.
-            return true;
-        }
-        if (this.selectionBox && shortcucts.matchesShortcut(duplicateSelectionShortcut, evt)) {
-            // Finalize duplicating the selection
-            this.selectionBox.duplicateSelectedObjects().then(command => {
-                this.editor.dispatch(command);
-            });
-            return true;
-        }
-        if (this.selectionBox && shortcucts.matchesShortcut(sendToBackSelectionShortcut, evt)) {
-            const sendToBackCommand = this.selectionBox.sendToBack();
-            if (sendToBackCommand) {
-                this.editor.dispatch(sendToBackCommand);
-            }
-            return true;
-        }
-        // Here, we check if shiftKey === false because, as of this writing,
-        // evt.shiftKey is an optional property. Being falsey could just mean
-        // that it wasn't set.
-        if (evt.shiftKey === false) {
-            this.shiftKeyPressed = false;
-            // Don't return immediately -- event may be otherwise handled
-        }
-        // Also check for key === 'Shift' (for the case where shiftKey is undefined)
-        if (evt.key === 'Shift') {
-            this.shiftKeyPressed = false;
-            return true;
-        }
-        // If we don't need to finalize the transform
-        if (!this.hasUnfinalizedTransformFromKeyPress) {
-            return true;
-        }
-        if (this.selectionBox && SelectionTool.handleableKeys.some(key => key === evt.key)) {
-            this.selectionBox.finalizeTransform();
-            this.hasUnfinalizedTransformFromKeyPress = false;
-            return true;
-        }
-        return false;
-    }
-    onCopy(event) {
-        if (!this.selectionBox) {
-            return false;
-        }
-        const selectedElems = this.selectionBox.getSelectedObjects();
-        const bbox = this.selectionBox.region;
-        if (selectedElems.length === 0) {
-            return false;
-        }
-        const exportViewport = new Viewport(() => { });
-        const selectionScreenSize = this.selectionBox.getScreenRegion().size.times(this.editor.display.getDevicePixelRatio());
-        // Update the viewport to have screen size roughly equal to the size of the selection box
-        let scaleFactor = selectionScreenSize.maximumEntryMagnitude() / (bbox.size.maximumEntryMagnitude() || 1);
-        // Round to a nearby power of two
-        scaleFactor = Math.pow(2, Math.ceil(Math.log2(scaleFactor)));
-        exportViewport.updateScreenSize(bbox.size.times(scaleFactor));
-        exportViewport.resetTransform(Mat33.scaling2D(scaleFactor)
-            // Move the selection onto the screen
-            .rightMul(Mat33.translation(bbox.topLeft.times(-1))));
-        const { element: svgExportElem, renderer: svgRenderer } = SVGRenderer.fromViewport(exportViewport, { sanitize: true, useViewBoxForPositioning: true });
-        const { element: canvas, renderer: canvasRenderer } = CanvasRenderer.fromViewport(exportViewport, { maxCanvasDimen: 4096 });
-        const text = [];
-        for (const elem of selectedElems) {
-            elem.render(svgRenderer);
-            elem.render(canvasRenderer);
-            if (elem instanceof TextComponent) {
-                text.push(elem.getText());
-            }
-        }
-        event.setData('image/svg+xml', svgExportElem.outerHTML);
-        event.setData('text/html', svgExportElem.outerHTML);
-        event.setData('image/png', new Promise((resolve, reject) => {
-            canvas.toBlob((blob) => {
-                if (blob) {
-                    resolve(blob);
-                }
-                else {
-                    reject(new Error('Failed to convert canvas to blob.'));
-                }
-            }, 'image/png');
-        }));
-        if (text.length > 0) {
-            event.setData('text/plain', text.join('\n'));
-        }
-        return true;
-    }
-    setEnabled(enabled) {
-        const wasEnabled = this.isEnabled();
-        super.setEnabled(enabled);
-        if (wasEnabled === enabled) {
-            return;
-        }
-        // Clear the selection
-        this.selectionBox?.cancelSelection();
-        this.onSelectionUpdated();
-        this.handleOverlay.replaceChildren();
-        this.selectionBox = null;
-        this.shiftKeyPressed = false;
-        this.snapToGrid = false;
-        this.handleOverlay.style.display = enabled ? 'block' : 'none';
-        if (enabled) {
-            this.handleOverlay.tabIndex = 0;
-            this.handleOverlay.setAttribute('aria-label', this.editor.localization.selectionToolKeyboardShortcuts);
-        }
-        else {
-            this.handleOverlay.tabIndex = -1;
-        }
-    }
-    // Get the object responsible for displaying this' selection.
-    // @internal
-    getSelection() {
-        return this.selectionBox;
-    }
-    getSelectedObjects() {
-        return this.selectionBox?.getSelectedObjects() ?? [];
-    }
-    // Select the given `objects`. Any non-selectable objects in `objects` are ignored.
-    setSelection(objects) {
-        // Only select selectable objects.
-        objects = objects.filter(obj => obj.isSelectable());
-        // Sort by z-index
-        objects.sort((a, b) => a.getZIndex() - b.getZIndex());
-        // Remove duplicates
-        objects = objects.filter((current, idx) => {
-            if (idx > 0) {
-                return current !== objects[idx - 1];
-            }
-            return true;
-        });
-        let bbox = null;
-        for (const object of objects) {
-            if (bbox) {
-                bbox = bbox.union(object.getBBox());
-            }
-            else {
-                bbox = object.getBBox();
-            }
-        }
-        if (!bbox) {
-            return;
-        }
-        this.clearSelection();
-        if (!this.selectionBox) {
-            this.makeSelectionBox(bbox.topLeft);
-        }
-        this.selectionBox.setSelectedObjects(objects, bbox);
-        this.onSelectionUpdated();
-    }
-    clearSelection() {
-        this.handleOverlay.replaceChildren();
-        this.prevSelectionBox = this.selectionBox;
-        this.selectionBox = null;
-        this.onSelectionUpdated();
-    }
-}
-SelectionTool.handleableKeys = [
-    'a', 'h', 'ArrowLeft',
-    'd', 'l', 'ArrowRight',
-    'q', 'k', 'ArrowUp',
-    'e', 'j', 'ArrowDown',
-    'r', 'R',
-    'i', 'I', 'o', 'O',
-    'Control', 'Meta',
-];
-export default SelectionTool;

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

@@ -1 +0,0 @@
-export {};

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

@@ -1 +0,0 @@
-export {};