Transforming rotated items

lib/shapes/ellipse.tsx

   },
 
   hitTestBounds(this, shape, brushBounds) {
+    // TODO: Account for rotation
+
     const shapeBounds = this.getBounds(shape)
 
     return (

lib/shapes/index.tsx

     bounds: Bounds,
     info: {
       type: TransformEdge | TransformCorner
+      boundsRotation: number
       initialShape: K
       initialShapeBounds: BoundsSnapshot
       initialBounds: Bounds
       isFlippedX: boolean
       isFlippedY: boolean
+      isSingle: boolean
       anchor: TransformEdge | TransformCorner
     }
   ): K

lib/shapes/rectangle.tsx

     return shape
   },
 
-  transform(shape, bounds) {
-    shape.point = [bounds.minX, bounds.minY]
-    shape.size = [bounds.width, bounds.height]
+  transform(
+    shape,
+    shapeBounds,
+    { initialShape, isSingle, initialShapeBounds, isFlippedX, isFlippedY }
+  ) {
+    // TODO: Apply rotation to single-selection items
+
+    if (shape.rotation === 0 || isSingle) {
+      shape.size = [shapeBounds.width, shapeBounds.height]
+      shape.point = [shapeBounds.minX, shapeBounds.minY]
+    } else {
+      shape.size = vec.mul(
+        initialShape.size,
+        Math.min(
+          shapeBounds.width / initialShapeBounds.width,
+          shapeBounds.height / initialShapeBounds.height
+        )
+      )
+
+      const newCenter = [
+        shapeBounds.minX + shapeBounds.width / 2,
+        shapeBounds.minY + shapeBounds.height / 2,
+      ]
+
+      shape.point = vec.sub(newCenter, vec.div(shape.size, 2))
+    }
+
+    // Rotation for flipped shapes
+
+    shape.rotation = initialShape.rotation
+
+    if (isFlippedX) {
+      shape.rotation *= -1
+    }
+
+    if (isFlippedY) {
+      shape.rotation *= -1
+    }
 
     return shape
   },

state/commands/transform.ts

           initialBounds,
           currentPageId,
           selectedIds,
+          isSingle,
+          boundsRotation,
         } = after
 
         const { shapes } = data.document.pages[currentPageId]
             initialShape,
             initialShapeBounds,
             initialBounds,
+            boundsRotation,
             isFlippedX: false,
             isFlippedY: false,
+            isSingle,
             anchor,
           })
         })
           initialBounds,
           currentPageId,
           selectedIds,
+          isSingle,
+          boundsRotation,
         } = before
 
         const { shapes } = data.document.pages[currentPageId]
             initialShape,
             initialShapeBounds,
             initialBounds,
+            boundsRotation,
             isFlippedX: false,
             isFlippedY: false,
+            isSingle,
             anchor: type,
           })
         })

state/sessions/transform-session.ts

     super(data)
     this.origin = point
     this.transformType = transformType
+
+    // if (data.selectedIds.size === 1) {
+    //   const shape =
+    //     data.document.pages[data.currentPageId].shapes[
+    //       Array.from(data.selectedIds.values())[0]
+    //     ]
+
+    //   if (shape.rotation > 0) {
+
+    //   }
+    // }
+
     this.snapshot = getTransformSnapshot(data, transformType)
 
     const { minX, minY, maxX, maxY } = this.snapshot.initialBounds
   }
 
   update(data: Data, point: number[]) {
-    const { shapeBounds, initialBounds, currentPageId, selectedIds } =
-      this.snapshot
-
-    const { shapes } = data.document.pages[currentPageId]
-
-    const delta = vec.vec(this.origin, point)
-
     const {
       corners: { a, b },
       transformType,
     } = this
 
-    // Edge Transform
+    const {
+      boundsRotation,
+      shapeBounds,
+      initialBounds,
+      currentPageId,
+      selectedIds,
+      isSingle,
+    } = this.snapshot
+
+    const { shapes } = data.document.pages[currentPageId]
+
+    const delta = vec.vec(this.origin, point)
+
     /*
-    Edge transform
+    Transforms
     
     Corners a and b are the original top-left and bottom-right corners of the
     bounding box. Depending on what the user is dragging, change one or both
         initialShape,
         initialShapeBounds,
         initialBounds,
+        boundsRotation,
         isFlippedX: this.isFlippedX,
         isFlippedY: this.isFlippedY,
+        isSingle,
         anchor: getTransformAnchor(
           this.transformType,
           this.isFlippedX,
   }
 
   cancel(data: Data) {
-    const { shapeBounds, initialBounds, currentPageId, selectedIds } =
-      this.snapshot
+    const {
+      shapeBounds,
+      boundsRotation,
+      initialBounds,
+      currentPageId,
+      selectedIds,
+      isSingle,
+    } = this.snapshot
 
     const { shapes } = data.document.pages[currentPageId]
 
         initialShape,
         initialShapeBounds,
         initialBounds,
+        boundsRotation,
         isFlippedX: false,
         isFlippedY: false,
+        isSingle,
         anchor: getTransformAnchor(this.transformType, false, false),
       })
     })
     document: { pages },
     selectedIds,
     currentPageId,
+    boundsRotation,
   } = current(data)
 
   const pageShapes = pages[currentPageId].shapes
     currentPageId,
     type: transformType,
     initialBounds: bounds,
+    boundsRotation,
+    isSingle: selectedIds.size === 1,
     selectedIds: new Set(selectedIds),
     shapeBounds: Object.fromEntries(
       Array.from(selectedIds.values()).map((id) => {