improves bounds, arrow rotation

components/canvas/bounds/bounding-box.tsx

   if (isSingleHandles) return null
 
   const size = (isMobile().any ? 10 : 8) / zoom // Touch target size
+  const center = getBoundsCenter(bounds)
 
   return (
     <g
       pointerEvents={isBrushing ? 'none' : 'all'}
       transform={`
-        rotate(${rotation * (180 / Math.PI)}, 
-        ${(bounds.minX + bounds.maxX) / 2}, 
-        ${(bounds.minY + bounds.maxY) / 2})
+        rotate(${rotation * (180 / Math.PI)},${center})
         translate(${bounds.minX},${bounds.minY})
         rotate(${(bounds.rotation || 0) * (180 / Math.PI)}, 0, 0)`}
     >

components/canvas/bounds/handles.tsx

 
   if (!shape.handles || !isSelecting) return null
 
+  const center = getShapeUtils(shape).getCenter(shape)
+
   return (
-    <g>
+    <g transform={`rotate(${shape.rotation * (180 / Math.PI)},${center})`}>
       {Object.values(shape.handles).map((handle) => (
         <Handle
           key={handle.id}

lib/shape-utils/arrow.tsx

     )
   },
 
+  rotateTo(shape, rotation, delta) {
+    const { start, end, bend } = shape.handles
+    // const mp = vec.med(start.point, end.point)
+    // start.point = vec.rotWith(start.point, mp, delta)
+    // end.point = vec.rotWith(end.point, mp, delta)
+    // bend.point = vec.rotWith(bend.point, mp, delta)
+    // this.onHandleChange(shape, shape.handles)
+
+    // const bounds = this.getBounds(shape)
+
+    // const offset = vec.sub([bounds.minX, bounds.minY], shape.point)
+
+    // this.translateTo(shape, vec.add(shape.point, offset))
+
+    // start.point = vec.sub(start.point, offset)
+    // end.point = vec.sub(end.point, offset)
+    // bend.point = vec.sub(bend.point, offset)
+
+    shape.rotation = rotation
+    return this
+  },
+
   getBounds(shape) {
     if (!this.boundsCache.has(shape)) {
       const { start, end } = shape.handles

lib/shape-utils/index.tsx

   // Create a new shape.
   create(props: Partial<K>): K
 
+  // Update a shape's styles
   applyStyles(
     this: ShapeUtility<K>,
     shape: Mutable<K>,
     point: number[]
   ): ShapeUtility<K>
 
+  rotateBy(
+    this: ShapeUtility<K>,
+    shape: Mutable<K>,
+    rotation: number
+  ): ShapeUtility<K>
+
+  rotateTo(
+    this: ShapeUtility<K>,
+    shape: Mutable<K>,
+    rotation: number,
+    delta: number
+  ): ShapeUtility<K>
+
   // Transform to fit a new bounding box when more than one shape is selected.
   transform(
     this: ShapeUtility<K>,
       return this
     },
 
+    rotateTo(shape, rotation) {
+      shape.rotation = rotation
+      return this
+    },
+
+    rotateBy(shape, rotation) {
+      shape.rotation += rotation
+      return this
+    },
+
     transform(shape, bounds) {
       shape.point = [bounds.minX, bounds.minY]
       return this

state/commands/arrow.ts

 import Command from './command'
 import history from '../history'
-import { ArrowShape, Data } from 'types'
-import * as vec from 'utils/vec'
+import { Data } from 'types'
 import { getPage } from 'utils/utils'
 import { ArrowSnapshot } from 'state/sessions/arrow-session'
-import { getShapeUtils } from 'lib/shape-utils'
 
 export default function arrowCommand(
   data: Data,

state/commands/rotate.ts

           const shape = shapes[id]
           const utils = getShapeUtils(shape)
           utils
-            .setProperty(shape, 'rotation', rotation)
-            .setProperty(shape, 'point', point)
+            .rotateTo(shape, rotation, rotation - shape.rotation)
+            .translateTo(shape, point)
         }
 
         data.boundsRotation = after.boundsRotation
           const shape = shapes[id]
           const utils = getShapeUtils(shape)
           utils
-            .setProperty(shape, 'rotation', rotation)
-            .setProperty(shape, 'point', point)
+            .rotateTo(shape, rotation, rotation - shape.rotation)
+            .translateTo(shape, point)
         }
 
         data.boundsRotation = before.boundsRotation

state/sessions/rotate-session.ts

   delta = [0, 0]
   origin: number[]
   snapshot: RotateSnapshot
+  prev = 0
 
   constructor(data: Data, point: number[]) {
     super(data)
 
     let rot = a2 - a1
 
+    const delta = rot - this.prev
+    this.prev = rot
+
     if (isLocked) {
       rot = clampToRotationToSegments(rot, 24)
     }
     for (let { id, center, offset, rotation } of initialShapes) {
       const shape = page.shapes[id]
 
-      // const rotationOffset = vec.sub(
-      //   getBoundsCenter(getShapeBounds(shape)),
-      //   getBoundsCenter(getRotatedBounds(shape))
-      // )
-
-      const nextRotation = isLocked
-        ? clampToRotationToSegments(rotation + rot, 24)
-        : rotation + rot
+      const nextRotation =
+        PI2 +
+        ((isLocked
+          ? clampToRotationToSegments(rotation + rot, 24)
+          : rotation + rot) %
+          PI2)
 
       const nextPoint = vec.sub(
         vec.rotWith(center, commonBoundsCenter, rot),
       )
 
       getShapeUtils(shape)
-        .setProperty(shape, 'rotation', (PI2 + nextRotation) % PI2)
-        .setProperty(shape, 'point', nextPoint)
+        .rotateTo(shape, nextRotation, delta)
+        .translateTo(shape, nextPoint)
     }
 
     updateParents(
     for (let { id, point, rotation } of initialShapes) {
       const shape = page.shapes[id]
       getShapeUtils(shape)
-        .setProperty(shape, 'rotation', rotation)
-        .setProperty(shape, 'point', point)
+        .rotateTo(shape, rotation, rotation - shape.rotation)
+        .translateTo(shape, point)
     }
 
     updateParents(

todo.md

 # Todo
 
-## Groups
+## Done
+
+- fix select indicator placement for arrow
+
+## Todo
 
 - Restore select highlight, fix for children of rotated groups
 - Transforming on rotated shapes