js-draw 1.6.1 → 1.7.0

package/dist/mjs/rendering/caching/CacheRecordManager.mjs

@@ -40,4 +40,22 @@ export class CacheRecordManager {
         this.cacheRecords.sort((a, b) => a.getLastUsedCycle() - b.getLastUsedCycle());
         return this.cacheRecords[0];
     }
+    // Returns information to (hopefully) help debug performance issues
+    getDebugInfo() {
+        let numberAllocd = 0;
+        let averageReassignedCount = 0;
+        for (const cacheRecord of this.cacheRecords) {
+            averageReassignedCount += cacheRecord.allocCount;
+            if (cacheRecord.isAllocd()) {
+                numberAllocd++;
+            }
+        }
+        averageReassignedCount /= Math.max(this.cacheRecords.length, 0);
+        const debugInfo = [
+            `${this.cacheRecords.length} cache records (max ${this.maxCanvases})`,
+            `${numberAllocd} assigned to screen regions`,
+            `Average number of times reassigned: ${Math.round(averageReassignedCount * 100) / 100}`,
+        ];
+        return debugInfo.join('\n');
+    }
 }

package/dist/mjs/rendering/caching/RenderingCache.d.ts

@@ -8,4 +8,5 @@ export default class RenderingCache {
     private rootNode;
     constructor(cacheProps: CacheProps);
     render(screenRenderer: AbstractRenderer, image: ImageNode, viewport: Viewport): void;
+    getDebugInfo(): string;
 }

package/dist/mjs/rendering/caching/RenderingCache.mjs

@@ -41,4 +41,7 @@ export default class RenderingCache {
             image.render(screenRenderer, visibleRect);
         }
     }
+    getDebugInfo() {
+        return this.recordManager.getDebugInfo();
+    }
 }

package/dist/mjs/rendering/renderers/CanvasRenderer.mjs

@@ -144,9 +144,10 @@ export default class CanvasRenderer extends AbstractRenderer {
             return;
         }
         // If part of a huge object, it might be worth trimming the path
-        if (this.currentObjectBBox?.containsRect(this.getViewport().visibleRect)) {
+        const visibleRect = this.getViewport().visibleRect;
+        if (this.currentObjectBBox?.containsRect(visibleRect)) {
             // Try to trim/remove parts of the path outside of the bounding box.
-            path = visualEquivalent(path, this.getViewport().visibleRect);
+            path = visualEquivalent(path, visibleRect);
         }
         super.drawPath(path);
     }

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

@@ -15,7 +15,8 @@ export default class Selection {
     private transformers;
     private transform;
     private selectedElems;
-    private container;
+    private outerContainer;
+    private innerContainer;
     private backgroundElem;
     private hasParent;
     constructor(startPoint: Point2, editor: Editor);
@@ -32,10 +33,10 @@ export default class Selection {
     get regionRotation(): number;
     get preTransformedScreenRegion(): Rect2;
     get preTransformedScreenRegionRotation(): number;
-    get screenRegion(): Rect2;
+    getScreenRegion(): Rect2;
     get screenRegionRotation(): number;
     setTransform(transform: Mat33, preview?: boolean): void;
-    finalizeTransform(): Promise<void>;
+    finalizeTransform(): void | Promise<void>;
     private static ApplyTransformationCommand;
     private previewTransformCmds;
     resolveToObjects(): boolean;
@@ -53,7 +54,7 @@ export default class Selection {
     onDragUpdate(pointer: Pointer): void;
     onDragEnd(): void;
     onDragCancel(): void;
-    scrollTo(): Promise<void>;
+    scrollTo(): boolean;
     deleteSelectedObjects(): Command;
     private selectionDuplicatedAnimationTimeout;
     private runSelectionDuplicatedAnimation;

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

@@ -36,22 +36,34 @@ class Selection {
             resize: new ResizeTransformer(editor, this),
             rotate: new RotateTransformer(editor, this),
         };
-        this.container = document.createElement('div');
+        // We need two containers for some CSS to apply (the outer container
+        // needs zero height, the inner needs to prevent the selection background
+        // from being visible outside of the editor).
+        this.outerContainer = document.createElement('div');
+        this.outerContainer.classList.add(`${cssPrefix}selection-outer-container`);
+        this.innerContainer = document.createElement('div');
+        this.innerContainer.classList.add(`${cssPrefix}selection-inner-container`);
         this.backgroundElem = document.createElement('div');
         this.backgroundElem.classList.add(`${cssPrefix}selection-background`);
-        this.container.appendChild(this.backgroundElem);
-        const resizeHorizontalHandle = new SelectionHandle({
-            action: HandleAction.ResizeX,
-            side: Vec2.of(1, 0.5),
-        }, this, this.editor.viewport, (startPoint) => this.transformers.resize.onDragStart(startPoint, ResizeMode.HorizontalOnly), (currentPoint) => this.transformers.resize.onDragUpdate(currentPoint), () => this.transformers.resize.onDragEnd());
-        const resizeVerticalHandle = new SelectionHandle({
-            action: HandleAction.ResizeY,
-            side: Vec2.of(0.5, 1),
-        }, this, this.editor.viewport, (startPoint) => this.transformers.resize.onDragStart(startPoint, ResizeMode.VerticalOnly), (currentPoint) => this.transformers.resize.onDragUpdate(currentPoint), () => this.transformers.resize.onDragEnd());
-        const resizeBothHandle = new SelectionHandle({
-            action: HandleAction.ResizeXY,
-            side: Vec2.of(1, 1),
-        }, this, this.editor.viewport, (startPoint) => this.transformers.resize.onDragStart(startPoint, ResizeMode.Both), (currentPoint) => this.transformers.resize.onDragUpdate(currentPoint), () => this.transformers.resize.onDragEnd());
+        this.innerContainer.appendChild(this.backgroundElem);
+        this.outerContainer.appendChild(this.innerContainer);
+        const makeResizeHandle = (mode, side) => {
+            const modeToAction = {
+                [ResizeMode.Both]: HandleAction.ResizeXY,
+                [ResizeMode.HorizontalOnly]: HandleAction.ResizeX,
+                [ResizeMode.VerticalOnly]: HandleAction.ResizeY,
+            };
+            return new SelectionHandle({
+                action: modeToAction[mode],
+                side,
+            }, this, this.editor.viewport, (startPoint) => this.transformers.resize.onDragStart(startPoint, mode), (currentPoint) => this.transformers.resize.onDragUpdate(currentPoint), () => this.transformers.resize.onDragEnd());
+        };
+        const resizeHorizontalHandles = [
+            makeResizeHandle(ResizeMode.HorizontalOnly, Vec2.of(0, 0.5)),
+            makeResizeHandle(ResizeMode.HorizontalOnly, Vec2.of(1, 0.5)),
+        ];
+        const resizeVerticalHandle = makeResizeHandle(ResizeMode.VerticalOnly, Vec2.of(0.5, 1));
+        const resizeBothHandle = makeResizeHandle(ResizeMode.Both, Vec2.of(1, 1));
         const rotationHandle = new SelectionHandle({
             action: HandleAction.Rotate,
             side: Vec2.of(0.5, 0),
@@ -59,7 +71,7 @@ class Selection {
         }, this, this.editor.viewport, (startPoint) => this.transformers.rotate.onDragStart(startPoint), (currentPoint) => this.transformers.rotate.onDragUpdate(currentPoint), () => this.transformers.rotate.onDragEnd());
         this.handles = [
             resizeBothHandle,
-            resizeHorizontalHandle,
+            ...resizeHorizontalHandles,
             resizeVerticalHandle,
             rotationHandle,
         ];
@@ -105,7 +117,7 @@ class Selection {
     get preTransformedScreenRegionRotation() {
         return this.editor.viewport.getRotationAngle();
     }
-    get screenRegion() {
+    getScreenRegion() {
         const toScreen = this.editor.viewport.canvasToScreenTransform;
         const scaleFactor = this.editor.viewport.getScaleFactor();
         const screenCenter = toScreen.transformVec2(this.region.center);
@@ -118,29 +130,33 @@ class Selection {
     setTransform(transform, preview = true) {
         this.transform = transform;
         if (preview && this.hasParent) {
-            this.scrollTo();
             this.previewTransformCmds();
         }
     }
     // Applies the current transformation to the selection
-    async finalizeTransform() {
+    finalizeTransform() {
         const fullTransform = this.transform;
         const selectedElems = this.selectedElems;
         // Reset for the next drag
         this.originalRegion = this.originalRegion.transformedBoundingBox(this.transform);
         this.transform = Mat33.identity;
+        this.scrollTo();
         // Make the commands undo-able.
         // Don't check for non-empty transforms because this breaks changing the
         // z-index of the just-transformed commands.
         //
         // TODO: Check whether the selectedElems are already all toplevel.
-        await this.editor.dispatch(new _a.ApplyTransformationCommand(this, selectedElems, fullTransform));
+        const transformPromise = this.editor.dispatch(new _a.ApplyTransformationCommand(this, selectedElems, fullTransform));
         // Clear renderings of any in-progress transformations
         const wetInkRenderer = this.editor.display.getWetInkRenderer();
         wetInkRenderer.clear();
+        return transformPromise;
     }
     // Preview the effects of the current transformation on the selection
     previewTransformCmds() {
+        if (this.selectedElems.length === 0) {
+            return;
+        }
         // Don't render what we're moving if it's likely to be slow.
         if (this.selectedElems.length > maxPreviewElemCount) {
             this.updateUI();
@@ -221,28 +237,29 @@ class Selection {
         if (!this.hasParent) {
             return;
         }
+        const screenRegion = this.getScreenRegion();
         // marginLeft, marginTop: Display relative to the top left of the selection overlay.
         // left, top don't work for this.
-        this.backgroundElem.style.marginLeft = `${this.screenRegion.topLeft.x}px`;
-        this.backgroundElem.style.marginTop = `${this.screenRegion.topLeft.y}px`;
-        this.backgroundElem.style.width = `${this.screenRegion.width}px`;
-        this.backgroundElem.style.height = `${this.screenRegion.height}px`;
+        this.backgroundElem.style.marginLeft = `${screenRegion.topLeft.x}px`;
+        this.backgroundElem.style.marginTop = `${screenRegion.topLeft.y}px`;
+        this.backgroundElem.style.width = `${screenRegion.width}px`;
+        this.backgroundElem.style.height = `${screenRegion.height}px`;
         const rotationDeg = this.screenRegionRotation * 180 / Math.PI;
         this.backgroundElem.style.transform = `rotate(${rotationDeg}deg)`;
         this.backgroundElem.style.transformOrigin = 'center';
         // If closer to perpendicular, apply different CSS
         const perpendicularClassName = `${cssPrefix}rotated-near-perpendicular`;
         if (Math.abs(Math.sin(this.screenRegionRotation)) > 0.5) {
-            this.container.classList.add(perpendicularClassName);
+            this.innerContainer.classList.add(perpendicularClassName);
         }
         else {
-            this.container.classList.remove(perpendicularClassName);
+            this.innerContainer.classList.remove(perpendicularClassName);
         }
         for (const handle of this.handles) {
             handle.updatePosition();
         }
     }
-    // Add/remove the contents of this' seleciton from the editor.
+    // Add/remove the contents of this seleciton from the editor.
     // Used to prevent previewed content from looking like duplicate content
     // while dragging.
     //
@@ -250,6 +267,9 @@ class Selection {
     // the editor image is likely to be slow.)
     //
     // If removed from the image, selected elements are drawn as wet ink.
+    //
+    // [inImage] should be `true` if the selected elements should be added to the
+    // main image, `false` if they should be removed.
     addRemoveSelectionFromImage(inImage) {
         // Don't hide elements if doing so will be slow.
         if (!inImage && this.selectedElems.length > maxPreviewElemCount) {
@@ -292,17 +312,18 @@ class Selection {
         document.getSelection()?.removeAllRanges();
         this.targetHandle = 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;
+                this.backgroundDragging = false;
                 result = true;
             }
         }
-        this.backgroundDragging = false;
-        if (this.region.containsPoint(pointer.canvasPos)) {
-            this.backgroundDragging = true;
-            result = true;
-        }
         if (result) {
             this.removeDeletedElemsFromSelection();
             this.addRemoveSelectionFromImage(false);
@@ -340,23 +361,29 @@ class Selection {
         this.targetHandle = null;
         this.setTransform(Mat33.identity);
         this.addRemoveSelectionFromImage(true);
+        this.updateUI();
     }
     // Scroll the viewport to this. Does not zoom
-    async scrollTo() {
+    scrollTo() {
         if (this.selectedElems.length === 0) {
-            return;
+            return false;
         }
-        const screenRect = new Rect2(0, 0, this.editor.display.width, this.editor.display.height);
-        if (!screenRect.containsPoint(this.screenRegion.center)) {
-            const closestPoint = screenRect.getClosestPointOnBoundaryTo(this.screenRegion.center);
-            const screenDelta = this.screenRegion.center.minus(closestPoint);
-            const delta = this.editor.viewport.screenToCanvasTransform.transformVec3(screenDelta);
-            await this.editor.dispatchNoAnnounce(Viewport.transformBy(Mat33.translation(delta.times(-1))), false);
-            // Re-renders clear wet ink, so we need to re-draw the preview
-            // after the full re-render.
-            await this.editor.queueRerender();
-            this.previewTransformCmds();
+        const screenSize = this.editor.viewport.getScreenRectSize();
+        const screenRect = new Rect2(0, 0, screenSize.x, screenSize.y);
+        const selectionScreenRegion = this.getScreenRegion();
+        if (!screenRect.containsPoint(selectionScreenRegion.center)) {
+            const targetPointScreen = selectionScreenRegion.center;
+            const closestPointScreen = screenRect.getClosestPointOnBoundaryTo(targetPointScreen);
+            const closestPointCanvas = this.editor.viewport.screenToCanvas(closestPointScreen);
+            const targetPointCanvas = this.region.center;
+            const delta = closestPointCanvas.minus(targetPointCanvas);
+            this.editor.dispatchNoAnnounce(Viewport.transformBy(Mat33.translation(delta.times(0.5))), false);
+            this.editor.queueRerender().then(() => {
+                this.previewTransformCmds();
+            });
+            return true;
         }
+        return false;
     }
     deleteSelectedObjects() {
         if (this.backgroundDragging || this.targetHandle) {
@@ -401,10 +428,10 @@ class Selection {
         return duplicateCommand;
     }
     addTo(elem) {
-        if (this.container.parentElement) {
-            this.container.remove();
+        if (this.outerContainer.parentElement) {
+            this.outerContainer.remove();
         }
-        elem.appendChild(this.container);
+        elem.appendChild(this.outerContainer);
         this.hasParent = true;
     }
     setToPoint(point) {
@@ -413,8 +440,8 @@ class Selection {
         this.updateUI();
     }
     cancelSelection() {
-        if (this.container.parentElement) {
-            this.container.remove();
+        if (this.outerContainer.parentElement) {
+            this.outerContainer.remove();
         }
         this.originalRegion = Rect2.empty;
         this.selectionTightBoundingBox = null;

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

@@ -16,7 +16,7 @@ export interface HandlePresentation {
 export declare const handleSize = 30;
 export type DragStartCallback = (startPoint: Point2) => void;
 export type DragUpdateCallback = (canvasPoint: Point2) => void;
-export type DragEndCallback = () => void;
+export type DragEndCallback = () => Promise<void> | void;
 export default class SelectionHandle {
     readonly presentation: HandlePresentation;
     private readonly parent;
@@ -50,7 +50,7 @@ export default class SelectionHandle {
     private dragLastPos;
     handleDragStart(pointer: Pointer): void;
     handleDragUpdate(pointer: Pointer): void;
-    handleDragEnd(): void;
+    handleDragEnd(): void | Promise<void>;
     setSnapToGrid(snap: boolean): void;
     isSnappingToGrid(): boolean;
 }

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

@@ -13,6 +13,7 @@ export var HandleAction;
     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) {
@@ -25,10 +26,14 @@ export default class SelectionHandle {
         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) {
-            this.element.appendChild(icon);
+            visibleContent.appendChild(icon);
             icon.classList.add('icon');
         }
         if (presentation.action === HandleAction.Rotate) {
@@ -61,7 +66,7 @@ export default class SelectionHandle {
      * selection box.
      */
     getBBoxParentCoords() {
-        const parentRect = this.parent.screenRegion;
+        const parentRect = this.parent.getScreenRegion();
         const size = Vec2.of(handleSize, handleSize);
         const topLeft = parentRect.size.scale(this.parentSide)
             // Center
@@ -115,7 +120,7 @@ export default class SelectionHandle {
         if (!this.dragLastPos) {
             return;
         }
-        this.onDragEnd();
+        return this.onDragEnd();
     }
     setSnapToGrid(snap) {
         this.snapToGrid = snap;

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

@@ -13,13 +13,15 @@ export default class SelectionTool extends BaseTool {
     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 onGestureEnd;
+    private onMainPointerUpdated;
     onPointerUp(event: PointerEvt): void;
     onGestureCancel(): void;
     private lastSelectedObjects;

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

@@ -6,6 +6,7 @@ import  SVGRenderer  from '../../rendering/renderers/SVGRenderer.mjs';
 import  Selection  from './Selection.mjs';
 import  TextComponent  from '../../components/TextComponent.mjs';
 import  { duplicateSelectionShortcut, selectAllKeyboardShortcut, 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.
@@ -17,8 +18,19 @@ class SelectionTool extends BaseTool {
         this.expandingSelectionBox = false;
         this.shiftKeyPressed = false;
         this.snapToGrid = false;
+        this.lastPointer = null;
         this.selectionBoxHandlingEvt = false;
         this.lastSelectedObjects = [];
+        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';
@@ -81,14 +93,22 @@ class SelectionTool extends BaseTool {
                 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;
-        let currentPointer = event.current;
+        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);
@@ -103,21 +123,8 @@ class SelectionTool extends BaseTool {
             this.selectionBox.setToPoint(currentPointer.canvasPos);
         }
     }
-    // Called after a gestureCancel and a pointerUp
-    onGestureEnd() {
-        if (!this.selectionBox)
-            return;
-        if (!this.selectionBoxHandlingEvt) {
-            // Expand/shrink the selection rectangle, if applicable
-            this.selectionBox.resolveToObjects();
-            this.onSelectionUpdated();
-        }
-        else {
-            this.selectionBox.onDragEnd();
-        }
-        this.selectionBoxHandlingEvt = false;
-    }
     onPointerUp(event) {
+        this.autoscroller.stop();
         if (!this.selectionBox)
             return;
         let currentPointer = event.current;
@@ -136,10 +143,20 @@ class SelectionTool extends BaseTool {
             ]);
         }
         else {
-            this.onGestureEnd();
+            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();
         }
@@ -152,6 +169,8 @@ class SelectionTool extends BaseTool {
             this.prevSelectionBox = null;
         }
         this.expandingSelectionBox = false;
+        this.lastPointer = null;
+        this.selectionBoxHandlingEvt = false;
     }
     onSelectionUpdated() {
         const selectedItemCount = this.selectionBox?.getSelectedItemCount() ?? 0;
@@ -277,6 +296,7 @@ class SelectionTool extends BaseTool {
             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();
         }
         if (this.selectionBox && !handled && (event.key === 'Delete' || event.key === 'Backspace')) {
             this.editor.dispatch(this.selectionBox.deleteSelectedObjects());

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

@@ -0,0 +1,23 @@
+import { Point2, Vec2 } from '@js-draw/math';
+import Viewport from '../../Viewport';
+type ScrollByCallback = (delta: Vec2) => void;
+/**
+ * Automatically scrolls the viewport such that the user's pointer is visible.
+ */
+export default class ToPointerAutoscroller {
+    private viewport;
+    private scrollByCanvasDelta;
+    private started;
+    private updateLoopId;
+    private updateLoopRunning;
+    private targetPoint;
+    private scrollRate;
+    constructor(viewport: Viewport, scrollByCanvasDelta: ScrollByCallback);
+    private getScrollForPoint;
+    start(): void;
+    onPointerMove(pointerScreenPosition: Point2): void;
+    stop(): void;
+    private startUpdateLoop;
+    private stopUpdateLoop;
+}
+export {};

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

@@ -0,0 +1,77 @@
+import { Rect2, Vec2 } from '@js-draw/math';
+import  untilNextAnimationFrame  from '../../util/untilNextAnimationFrame.mjs';
+/**
+ * Automatically scrolls the viewport such that the user's pointer is visible.
+ */
+export default class ToPointerAutoscroller {
+    constructor(viewport, scrollByCanvasDelta) {
+        this.viewport = viewport;
+        this.scrollByCanvasDelta = scrollByCanvasDelta;
+        this.started = false;
+        this.updateLoopId = 0;
+        this.updateLoopRunning = false;
+        this.targetPoint = null;
+        this.scrollRate = 1000; // px/s
+    }
+    getScrollForPoint(screenPoint) {
+        const screenSize = this.viewport.getScreenRectSize();
+        const screenRect = new Rect2(0, 0, screenSize.x, screenSize.y);
+        // Starts autoscrolling when the cursor is **outside of** this region
+        const marginSize = 44;
+        const autoscrollBoundary = screenRect.grownBy(-marginSize);
+        if (autoscrollBoundary.containsPoint(screenPoint)) {
+            return Vec2.zero;
+        }
+        const closestEdgePoint = autoscrollBoundary.getClosestPointOnBoundaryTo(screenPoint);
+        const distToEdge = closestEdgePoint.minus(screenPoint).magnitude();
+        const toEdge = closestEdgePoint.minus(screenPoint);
+        // Go faster for points further away from the boundary.
+        const maximumScaleFactor = 1.25;
+        const scaleFactor = Math.min(distToEdge / marginSize, maximumScaleFactor);
+        return toEdge.normalizedOrZero().times(scaleFactor);
+    }
+    start() {
+        this.started = true;
+    }
+    onPointerMove(pointerScreenPosition) {
+        if (!this.started) {
+            return;
+        }
+        if (this.getScrollForPoint(pointerScreenPosition) === Vec2.zero) {
+            this.stopUpdateLoop();
+        }
+        else {
+            this.targetPoint = pointerScreenPosition;
+            this.startUpdateLoop();
+        }
+    }
+    stop() {
+        this.targetPoint = null;
+        this.started = false;
+        this.stopUpdateLoop();
+    }
+    startUpdateLoop() {
+        if (this.updateLoopRunning) {
+            return;
+        }
+        (async () => {
+            this.updateLoopId++;
+            const currentUpdateLoopId = this.updateLoopId;
+            let lastUpdateTime = performance.now();
+            while (this.updateLoopId === currentUpdateLoopId && this.targetPoint) {
+                this.updateLoopRunning = true;
+                const currentTime = performance.now();
+                const deltaTimeMs = currentTime - lastUpdateTime;
+                const scrollDirection = this.getScrollForPoint(this.targetPoint);
+                const screenScrollAmount = scrollDirection.times(this.scrollRate * deltaTimeMs / 1000);
+                this.scrollByCanvasDelta(this.viewport.screenToCanvasTransform.transformVec3(screenScrollAmount));
+                lastUpdateTime = currentTime;
+                await untilNextAnimationFrame();
+            }
+            this.updateLoopRunning = false;
+        })();
+    }
+    stopUpdateLoop() {
+        this.updateLoopId++;
+    }
+}

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

@@ -9,26 +9,33 @@ export declare class DragTransformer {
     constructor(editor: Editor, selection: Selection);
     onDragStart(startPoint: Vec3): void;
     onDragUpdate(canvasPos: Vec3): void;
-    onDragEnd(): void;
+    onDragEnd(): void | Promise<void>;
 }
 export declare class ResizeTransformer {
     private readonly editor;
     private selection;
     private mode;
     private dragStartPoint;
+    private transformOrigin;
+    private scaleRate;
     constructor(editor: Editor, selection: Selection);
     onDragStart(startPoint: Vec3, mode: ResizeMode): void;
+    private computeOriginAndScaleRate;
     onDragUpdate(canvasPos: Vec3): void;
-    onDragEnd(): void;
+    onDragEnd(): void | Promise<void>;
 }
 export declare class RotateTransformer {
     private readonly editor;
     private selection;
     private startAngle;
+    private targetRotation;
+    private maximumDistFromStart;
+    private startPoint;
     constructor(editor: Editor, selection: Selection);
     private getAngle;
     private roundAngle;
     onDragStart(startPoint: Vec3): void;
+    private setRotationTo;
     onDragUpdate(canvasPos: Vec3): void;
-    onDragEnd(): void;
+    onDragEnd(): void | Promise<void>;
 }