kritzel-stencil 0.1.26 → 0.1.28

package/dist/cjs/{default-line-tool.config-Dbu-DwOX.js → default-line-tool.config-B2cKxcY4.js}

@@ -231,34 +231,45 @@ class KritzelBaseObject {
         };
     }
     get rotatedBoundingBox() {
+        const polygon = this.rotatedPolygon;
+        const xValues = [polygon.topLeft.x, polygon.topRight.x, polygon.bottomRight.x, polygon.bottomLeft.x];
+        const yValues = [polygon.topLeft.y, polygon.topRight.y, polygon.bottomRight.y, polygon.bottomLeft.y];
+        const minX = Math.min(...xValues);
+        const maxX = Math.max(...xValues);
+        const minY = Math.min(...yValues);
+        const maxY = Math.max(...yValues);
         return {
-            x: this.minXRotated,
-            y: this.minYRotated,
+            x: minX,
+            y: minY,
             z: this.scale,
-            width: this.maxXRotated - this.minXRotated,
-            height: this.maxYRotated - this.minYRotated,
+            width: maxX - minX,
+            height: maxY - minY,
         };
     }
     get rotatedPolygon() {
         const cx = this.translateX + this.totalWidth / 2 / this.scale;
         const cy = this.translateY + this.totalHeight / 2 / this.scale;
         const angle = this.rotation;
+        // Optimization: Precomputes cos/sin once
+        const cos = Math.cos(angle);
+        const sin = Math.sin(angle);
         const adjustedWidth = this.totalWidth / this.scale;
         const adjustedHeight = this.totalHeight / this.scale;
-        const corners = {
-            topLeft: { x: this.translateX, y: this.translateY },
-            topRight: { x: this.translateX + adjustedWidth, y: this.translateY },
-            bottomRight: { x: this.translateX + adjustedWidth, y: this.translateY + adjustedHeight },
-            bottomLeft: { x: this.translateX, y: this.translateY + adjustedHeight },
+        const x1 = this.translateX;
+        const y1 = this.translateY;
+        const x2 = x1 + adjustedWidth;
+        const y2 = y1 + adjustedHeight;
+        // Helper to rotate a point around center
+        const rotate = (x, y) => ({
+            x: cos * (x - cx) - sin * (y - cy) + cx,
+            y: sin * (x - cx) + cos * (y - cy) + cy,
+        });
+        return {
+            topLeft: rotate(x1, y1),
+            topRight: rotate(x2, y1),
+            bottomRight: rotate(x2, y2),
+            bottomLeft: rotate(x1, y2),
         };
-        const rotatedCorners = Object.keys(corners).reduce((acc, key) => {
-            const corner = corners[key];
-            const rotatedX = Math.cos(angle) * (corner.x - cx) - Math.sin(angle) * (corner.y - cy) + cx;
-            const rotatedY = Math.sin(angle) * (corner.x - cx) + Math.cos(angle) * (corner.y - cy) + cy;
-            acc[key] = { x: rotatedX, y: rotatedY };
-            return acc;
-        }, {});
-        return rotatedCorners;
     }
     get minXRotated() {
         const corners = [this.rotatedPolygon.topLeft.x, this.rotatedPolygon.topRight.x, this.rotatedPolygon.bottomRight.x, this.rotatedPolygon.bottomLeft.x];
@@ -15151,6 +15162,13 @@ class KritzelPath extends KritzelBaseObject {
         object.updateDimensions();
         return object;
     }
+    copy() {
+        const copiedObject = super.copy();
+        if (this.points) {
+            copiedObject.points = this.points.map(p => [...p]);
+        }
+        return copiedObject;
+    }
     resize(x, y, width, height) {
         if (width <= 1 || height <= 1) {
             return;
@@ -18357,6 +18375,8 @@ class KritzelSelectionHandler extends KritzelBaseHandler {
     touchStartX = 0;
     touchStartY = 0;
     touchStartTimeout = null;
+    // Track previously selected objects for efficient deselection (WeakRef to avoid memory leaks)
+    _previouslySelectedObjects = new Set();
     get isSelectionClick() {
         const selectionBox = this._core.store.selectionBox;
         return selectionBox && selectionBox.width === 0 && selectionBox.height === 0;
@@ -18449,6 +18469,7 @@ class KritzelSelectionHandler extends KritzelBaseHandler {
     removeSelectionBox() {
         this._core.store.state.isSelecting = false;
         this._core.store.state.objects.remove(o => o instanceof KritzelSelectionBox);
+        this._core.store.setSelectionBox(null);
     }
     startMouseSelection(event) {
         let clientX, clientY;
@@ -18461,7 +18482,10 @@ class KritzelSelectionHandler extends KritzelBaseHandler {
         selectionBox.translateY = this.startY;
         this._core.store.state.isSelecting = true;
         this._core.store.state.objects.remove(o => o instanceof KritzelSelectionBox || o instanceof KritzelSelectionGroup);
+        this._core.store.setSelectionBox(null);
+        this._core.store.setSelectionGroup(null);
         this._core.store.state.objects.insert(selectionBox);
+        this._core.store.setSelectionBox(selectionBox);
     }
     startTouchSelection() {
         const activePointers = Array.from(this._core.store.state.pointers.values());
@@ -18481,7 +18505,10 @@ class KritzelSelectionHandler extends KritzelBaseHandler {
         selectionBox.translateY = this.startY;
         this._core.store.state.isSelecting = true;
         this._core.store.state.objects.remove(o => o instanceof KritzelSelectionBox || o instanceof KritzelSelectionGroup);
+        this._core.store.setSelectionBox(null);
+        this._core.store.setSelectionGroup(null);
         this._core.store.state.objects.insert(selectionBox);
+        this._core.store.setSelectionBox(selectionBox);
     }
     updateMouseSelection(event) {
         let clientX, clientY;
@@ -18538,19 +18565,43 @@ class KritzelSelectionHandler extends KritzelBaseHandler {
             return;
         // Compute rotatedPolygon once per update (not per object)
         const selectionPolygon = selectionBox.rotatedPolygon;
+        // Calculate bounding box from the polygon we already have to avoid recomputing it
+        // calling selectionBox.rotatedBoundingBox would trigger another rotatedPolygon computation
+        const xValues = [selectionPolygon.topLeft.x, selectionPolygon.topRight.x, selectionPolygon.bottomRight.x, selectionPolygon.bottomLeft.x];
+        const yValues = [selectionPolygon.topLeft.y, selectionPolygon.topRight.y, selectionPolygon.bottomRight.y, selectionPolygon.bottomLeft.y];
+        const minX = Math.min(...xValues);
+        const maxX = Math.max(...xValues);
+        const minY = Math.min(...yValues);
+        const maxY = Math.max(...yValues);
         // Use quadtree spatial query to get only nearby candidates - O(log n + k) instead of O(n)
-        const selectionBounds = selectionBox.rotatedBoundingBox;
+        const selectionBounds = {
+            x: minX,
+            y: minY,
+            z: selectionBox.scale,
+            width: maxX - minX,
+            height: maxY - minY
+        };
         const candidates = this._core.store.state.objects.query(selectionBounds);
-        // Clear selection on all non-selection objects first
-        this._core.store.allNonSelectionObjects.forEach(obj => {
-            obj.isSelected = false;
-        });
+        // Track newly selected objects for efficient comparison
+        const newlySelectedObjects = new Set();
         // Only test candidates that overlap the bounding box
         for (const object of candidates) {
             if (object instanceof KritzelSelectionBox)
                 continue;
-            object.isSelected = object.hitTestPolygon(selectionPolygon);
+            const isHit = object.hitTestPolygon(selectionPolygon);
+            object.isSelected = isHit;
+            if (isHit) {
+                newlySelectedObjects.add(object);
+            }
         }
+        // Deselect only objects that were previously selected but aren't anymore
+        // This is O(k) where k is the number of previously selected objects, not O(n)
+        for (const prevObj of this._previouslySelectedObjects) {
+            if (!newlySelectedObjects.has(prevObj)) {
+                prevObj.isSelected = false;
+            }
+        }
+        this._previouslySelectedObjects = newlySelectedObjects;
     }
     handleSelectionClick(event) {
         const selectedObject = this.getTopmostHitObject(event);
@@ -18572,9 +18623,11 @@ class KritzelSelectionHandler extends KritzelBaseHandler {
         return null;
     }
     clearSelectionPreview() {
-        this._core.store.allNonSelectionObjects.forEach(object => {
-            object.isSelected = false;
-        });
+        // Only clear previously tracked selected objects - O(k) instead of O(n)
+        for (const obj of this._previouslySelectedObjects) {
+            obj.isSelected = false;
+        }
+        this._previouslySelectedObjects.clear();
     }
     addObjectToSelectionGroup(object) {
         if (!object) {
@@ -35986,6 +36039,7 @@ class KritzelAppStateMap {
     _core = null;
     _isReady = false;
     _onRemoteChangeCallback = null;
+    _workspacesObserver = null;
     get isReady() {
         return this._isReady;
     }
@@ -36017,9 +36071,10 @@ class KritzelAppStateMap {
             this._providers.push(provider);
         }
         // Observe changes to workspaces and sync with application state
-        this._workspacesMap.observe(event => {
+        this._workspacesObserver = event => {
             this.handleWorkspacesChange(event);
-        });
+        };
+        this._workspacesMap.observe(this._workspacesObserver);
         // Connect all providers in parallel
         await Promise.all(this._providers.map(p => p.connect()));
         this._isReady = true;
@@ -36149,8 +36204,16 @@ class KritzelAppStateMap {
         return this.map.has(id);
     }
     destroy() {
-        // Disconnect all providers
-        this._providers.forEach(p => p.disconnect());
+        // Unobserve the workspaces map
+        if (this._workspacesMap && this._workspacesObserver) {
+            this._workspacesMap.unobserve(this._workspacesObserver);
+            this._workspacesObserver = null;
+        }
+        // Disconnect and destroy all providers
+        this._providers.forEach(p => {
+            p.disconnect();
+            p.destroy();
+        });
         this._providers = [];
         // Clear maps
         this.map.clear();
@@ -36160,6 +36223,9 @@ class KritzelAppStateMap {
             this._ydoc.destroy();
             this._ydoc = null;
         }
+        // Clear remaining references
+        this._core = null;
+        this._onRemoteChangeCallback = null;
         this._isReady = false;
     }
 }

package/dist/cjs/index.cjs.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var defaultLineTool_config = require('./default-line-tool.config-Dbu-DwOX.js');
+var defaultLineTool_config = require('./default-line-tool.config-B2cKxcY4.js');
 
 /**
  * BroadcastChannel sync provider for cross-tab synchronization