Removes translateTo, rotateTo

lib/code/index.ts

-import { Shape } from "types"
+import { Shape } from 'types'
 import shapeUtilityMap, {
   createShape,
   getShapeUtils,
   ShapeUtility,
-} from "lib/shape-utils"
-import * as vec from "utils/vec"
-import Vector from "./vector"
-import { vectorToPoint } from "utils/utils"
+} from 'lib/shape-utils'
+import * as vec from 'utils/vec'
+import Vector from './vector'
+import { vectorToPoint } from 'utils/utils'
 
 export const codeShapes = new Set<CodeShape<Shape>>([])
 
   }
 
   moveTo(point: Vector) {
-    this.utils.translateTo(this._shape, vectorToPoint(point))
+    this.utils.setProperty(this._shape, 'point', vectorToPoint(point))
     return this
   }
 
   translate(delta: Vector) {
-    this.utils.translateTo(
+    this.utils.setProperty(
       this._shape,
+      'point',
       vec.add(this._shape.point, vectorToPoint(delta))
     )
     return this
   }
 
   rotate(rotation: number) {
-    this.utils.rotateTo(this._shape, rotation)
+    this.utils.setProperty(this._shape, 'rotation', rotation)
     return this
   }
 

lib/shape-utils/arrow.tsx

     }
   },
 
-  rotateTo(shape, rotation) {
-    // const rot = rotation - shape.rotation
-    // const center = this.getCenter(shape)
-    // shape.points = shape.points.map((pt) => vec.rotWith(pt, shape.point, rot))
-    shape.rotation = rotation
-    return this
-  },
-
-  translateTo(shape, point) {
-    shape.point = vec.toPrecision(point)
-    return this
-  },
-
   transform(shape, bounds, { initialShape, scaleX, scaleY }) {
     const initialShapeBounds = this.getBounds(initialShape)
 

lib/shape-utils/circle.tsx

     )
   },
 
-  rotateTo(shape, rotation) {
-    shape.rotation = rotation
-    return this
-  },
-
-  translateTo(shape, point) {
-    shape.point = vec.toPrecision(point)
-    return this
-  },
-
   transform(shape, bounds, { initialShape, transformOrigin, scaleX, scaleY }) {
     shape.radius =
       initialShape.radius * Math.min(Math.abs(scaleX), Math.abs(scaleY))

lib/shape-utils/dot.tsx

     )
   },
 
-  rotateTo(shape) {
-    return this
-  },
-
-  translateTo(shape, point) {
-    shape.point = vec.toPrecision(point)
-    return this
-  },
-
   transform(shape, bounds) {
     shape.point = [bounds.minX, bounds.minY]
 

lib/shape-utils/draw.tsx

     )
   },
 
-  rotateTo(shape, rotation) {
-    shape.rotation = rotation
-    // console.log(shape.points.map(([x, y]) => [x, y]))
-    // const bounds = this.getBounds(shape)
-    // const center = [bounds.width / 2, bounds.height / 2]
-    // shape.points = shape.points.map((pt) => vec.rotWith(pt, center, rotation))
-    return this
-  },
-
-  translateTo(shape, point) {
-    shape.point = vec.toPrecision(point)
-    return this
-  },
-
   transform(shape, bounds, { initialShape, scaleX, scaleY }) {
     const initialShapeBounds = this.boundsCache.get(initialShape)
     shape.points = initialShape.points.map(([x, y]) => {

lib/shape-utils/ellipse.tsx

     )
   },
 
-  rotateTo(shape, rotation) {
-    shape.rotation = rotation
-    return this
-  },
-
-  translateTo(shape, point) {
-    shape.point = vec.toPrecision(point)
-    return this
-  },
-
   transform(shape, bounds, { scaleX, scaleY, initialShape }) {
     // TODO: Locked aspect ratio transform
 

lib/shape-utils/index.tsx

 when performing tests (such as hit tests) or mutations, such as translations.
 */
 
-export interface ShapeUtility<K extends Readonly<Shape>> {
+export interface ShapeUtility<K extends Shape> {
   // A cache for the computed bounds of this kind of shape.
   boundsCache: WeakMap<K, Bounds>
 
     style: Partial<ShapeStyles>
   ): ShapeUtility<K>
 
-  // Set the shape's point.
-  translateTo(this: ShapeUtility<K>, shape: K, delta: number[]): ShapeUtility<K>
-
-  // Set the shape's rotation.
-  rotateTo(this: ShapeUtility<K>, shape: K, rotation: number): ShapeUtility<K>
-
   // Transform to fit a new bounding box when more than one shape is selected.
   transform(
     this: ShapeUtility<K>,

lib/shape-utils/line.tsx

     )
   },
 
-  rotateTo(shape) {
-    return this
-  },
-
-  translateTo(shape, point) {
-    shape.point = vec.toPrecision(point)
-    return this
-  },
-
   transform(shape, bounds) {
     shape.point = [bounds.minX, bounds.minY]
 

lib/shape-utils/polyline.tsx

     )
   },
 
-  rotateTo(shape, rotation) {
-    shape.rotation = rotation
-    return this
-  },
-
-  translateTo(shape, point) {
-    shape.point = vec.toPrecision(point)
-    return this
-  },
-
   transform(shape, bounds, { initialShape, scaleX, scaleY }) {
     const initialShapeBounds = this.getBounds(initialShape)
 

lib/shape-utils/ray.tsx

     )
   },
 
-  rotateTo(shape) {
-    return this
-  },
-
-  translateTo(shape, point) {
-    shape.point = vec.toPrecision(point)
-    return this
-  },
-
   transform(shape, bounds) {
     shape.point = [bounds.minX, bounds.minY]
 

lib/shape-utils/rectangle.tsx

     )
   },
 
-  rotateTo(shape, rotation) {
-    shape.rotation = rotation
-    return this
-  },
-
-  translateTo(shape, point) {
-    shape.point = vec.toPrecision(point)
-    return this
-  },
-
   transform(shape, bounds, { initialShape, transformOrigin, scaleX, scaleY }) {
     if (shape.rotation === 0 && !shape.isAspectRatioLocked) {
       shape.size = [bounds.width, bounds.height]

lib/shapes/BaseShape.tsx

+import { defaultStyle } from 'lib/shape-styles'
+import {
+  Shape,
+  Bounds,
+  BaseShape,
+  ShapeSpecificProps,
+  ShapeType,
+  ShapeStyles,
+  MutableShape,
+  Edge,
+  Corner,
+  ShapeBinding,
+} from 'types'
+import { v4 as uuid } from 'uuid'
+import * as vec from 'utils/vec'
+import {
+  getBoundsCenter,
+  getRotatedCorners,
+  getBoundsFromPoints,
+} from 'utils/utils'
+
+class ShapeUtility<K extends MutableShape> {
+  boundsCache = new WeakMap<K, Bounds>([])
+  canTransform = true
+  canChangeAspectRatio = true
+  canStyleFill = true
+
+  // Create a new shape.
+  create(props: Partial<K> & ShapeSpecificProps<K>): K {
+    return {
+      id: uuid(),
+      isGenerated: false,
+      point: [0, 0],
+      name: 'Shape',
+      parentId: 'page0',
+      childIndex: 0,
+      rotation: 0,
+      isAspectRatioLocked: false,
+      isLocked: false,
+      isHidden: false,
+      ...props,
+    } as K
+  }
+
+  applyStyles = (shape: K, style: Partial<ShapeStyles>) => {
+    Object.assign(shape.style, style)
+    return this
+  }
+
+  transform = (
+    shape: K,
+    bounds: Bounds,
+    info: {
+      type: Edge | Corner
+      initialShape: K
+      scaleX: number
+      scaleY: number
+      transformOrigin: number[]
+    }
+  ) => {
+    shape.point = [bounds.minX, bounds.minY]
+
+    return this
+  }
+
+  transformSingle = (
+    shape: K,
+    bounds: Bounds,
+    info: {
+      type: Edge | Corner
+      initialShape: K
+      scaleX: number
+      scaleY: number
+      transformOrigin: number[]
+    }
+  ) => {
+    return this.transform(shape, bounds, info)
+  }
+
+  setProperty = <P extends keyof K>(shape: K, prop: P, value: K[P]) => {
+    shape[prop] = value
+    return this
+  }
+
+  onBindingMove? = (shape: K, bindings: Record<string, ShapeBinding>) => {
+    return this
+  }
+
+  onHandleMove? = (shape: K, handle: Partial<K['handles']>) => {
+    return this
+  }
+
+  render = (shape: K): JSX.Element => {
+    return <circle id={shape.id} />
+  }
+
+  // Get the bounds of the a shape.
+  getBounds = (shape: K): Bounds => {
+    const [x, y] = shape.point
+    return {
+      minX: x,
+      minY: y,
+      maxX: x + 1,
+      maxY: y + 1,
+      width: 1,
+      height: 1,
+    }
+  }
+
+  // Get the routated bounds of the a shape.
+  getRotatedBounds = (shape: K): Bounds => {
+    return getBoundsFromPoints(
+      getRotatedCorners(this.getBounds(shape), shape.rotation)
+    )
+  }
+
+  // Get the center of the shape
+  getCenter = (shape: K): number[] => {
+    return getBoundsCenter(this.getBounds(shape))
+  }
+
+  // Test whether a point lies within a shape.
+  hitTest = (shape: K, test: number[]): boolean => {
+    return true
+  }
+
+  // Test whether bounds collide with or contain a shape.
+  hitTestBounds = (shape: K, bounds: Bounds): boolean => {
+    return true
+  }
+}

state/commands/align.ts

-import Command from "./command"
-import history from "../history"
-import { AlignType, Data } from "types"
-import { getCommonBounds, getPage, getSelectedShapes } from "utils/utils"
-import { getShapeUtils } from "lib/shape-utils"
+import Command from './command'
+import history from '../history'
+import { AlignType, Data } from 'types'
+import { getCommonBounds, getPage, getSelectedShapes } from 'utils/utils'
+import { getShapeUtils } from 'lib/shape-utils'
 
 export default function alignCommand(data: Data, type: AlignType) {
   const { currentPageId } = data
   history.execute(
     data,
     new Command({
-      name: "aligned",
-      category: "canvas",
+      name: 'aligned',
+      category: 'canvas',
       do(data) {
         const { shapes } = getPage(data, currentPageId)
 
           case AlignType.Top: {
             for (let id in boundsForShapes) {
               const shape = shapes[id]
-              getShapeUtils(shape).translateTo(shape, [
+              getShapeUtils(shape).setProperty(shape, 'point', [
                 shape.point[0],
                 commonBounds.minY,
               ])
           case AlignType.CenterVertical: {
             for (let id in boundsForShapes) {
               const shape = shapes[id]
-              getShapeUtils(shape).translateTo(shape, [
+              getShapeUtils(shape).setProperty(shape, 'point', [
                 shape.point[0],
                 midY - boundsForShapes[id].height / 2,
               ])
           case AlignType.Bottom: {
             for (let id in boundsForShapes) {
               const shape = shapes[id]
-              getShapeUtils(shape).translateTo(shape, [
+              getShapeUtils(shape).setProperty(shape, 'point', [
                 shape.point[0],
                 commonBounds.maxY - boundsForShapes[id].height,
               ])
           case AlignType.Left: {
             for (let id in boundsForShapes) {
               const shape = shapes[id]
-              getShapeUtils(shape).translateTo(shape, [
+              getShapeUtils(shape).setProperty(shape, 'point', [
                 commonBounds.minX,
                 shape.point[1],
               ])
           case AlignType.CenterHorizontal: {
             for (let id in boundsForShapes) {
               const shape = shapes[id]
-              getShapeUtils(shape).translateTo(shape, [
+              getShapeUtils(shape).setProperty(shape, 'point', [
                 midX - boundsForShapes[id].width / 2,
                 shape.point[1],
               ])
           case AlignType.Right: {
             for (let id in boundsForShapes) {
               const shape = shapes[id]
-              getShapeUtils(shape).translateTo(shape, [
+              getShapeUtils(shape).setProperty(shape, 'point', [
                 commonBounds.maxX - boundsForShapes[id].width,
                 shape.point[1],
               ])
         for (let id in boundsForShapes) {
           const shape = shapes[id]
           const initialBounds = boundsForShapes[id]
-          getShapeUtils(shape).translateTo(shape, [
+          getShapeUtils(shape).setProperty(shape, 'point', [
             initialBounds.minX,
             initialBounds.minY,
           ])

state/commands/distribute.ts

-import Command from "./command"
-import history from "../history"
-import { Data, DistributeType } from "types"
+import Command from './command'
+import history from '../history'
+import { Data, DistributeType } from 'types'
 import {
   getBoundsCenter,
   getCommonBounds,
   getPage,
   getSelectedShapes,
-} from "utils/utils"
-import { getShapeUtils } from "lib/shape-utils"
+} from 'utils/utils'
+import { getShapeUtils } from 'lib/shape-utils'
 
 export default function distributeCommand(data: Data, type: DistributeType) {
   const { currentPageId } = data
   history.execute(
     data,
     new Command({
-      name: "distributed",
-      category: "canvas",
+      name: 'distributed',
+      category: 'canvas',
       do(data) {
         const { shapes } = getPage(data, currentPageId)
         const len = entries.length
               for (let i = 0; i < entriesToMove.length; i++) {
                 const [id, bounds] = entriesToMove[i]
                 const shape = shapes[id]
-                getShapeUtils(shape).translateTo(shape, [
+                getShapeUtils(shape).setProperty(shape, 'point', [
                   x + step * i - bounds.width / 2,
                   bounds.minY,
                 ])
               for (let i = 0; i < entriesToMove.length - 1; i++) {
                 const [id, bounds] = entriesToMove[i]
                 const shape = shapes[id]
-                getShapeUtils(shape).translateTo(shape, [x, bounds.minY])
+                getShapeUtils(shape).setProperty(shape, 'point', [
+                  x,
+                  bounds.minY,
+                ])
                 x += bounds.width + step
               }
             }
               for (let i = 0; i < entriesToMove.length; i++) {
                 const [id, bounds] = entriesToMove[i]
                 const shape = shapes[id]
-                getShapeUtils(shape).translateTo(shape, [
+                getShapeUtils(shape).setProperty(shape, 'point', [
                   bounds.minX,
                   y + step * i - bounds.height / 2,
                 ])
               for (let i = 0; i < entriesToMove.length - 1; i++) {
                 const [id, bounds] = entriesToMove[i]
                 const shape = shapes[id]
-                getShapeUtils(shape).translateTo(shape, [bounds.minX, y])
+                getShapeUtils(shape).setProperty(shape, 'point', [
+                  bounds.minX,
+                  y,
+                ])
                 y += bounds.height + step
               }
             }
         for (let id in boundsForShapes) {
           const shape = shapes[id]
           const initialBounds = boundsForShapes[id]
-          getShapeUtils(shape).translateTo(shape, [
+          getShapeUtils(shape).setProperty(shape, 'point', [
             initialBounds.minX,
             initialBounds.minY,
           ])

state/commands/nudge.ts

 
         for (let id in shapeBounds) {
           const shape = shapes[id]
-          getShapeUtils(shape).translateTo(shape, vec.add(shape.point, delta))
+          getShapeUtils(shape).setProperty(
+            shape,
+            'point',
+            vec.add(shape.point, delta)
+          )
         }
       },
       undo(data) {
 
         for (let id in shapeBounds) {
           const shape = shapes[id]
-          getShapeUtils(shape).translateTo(shape, vec.sub(shape.point, delta))
+          getShapeUtils(shape).setProperty(
+            shape,
+            'point',
+            vec.sub(shape.point, delta)
+          )
         }
       },
     })

state/commands/rotate-ccw.ts

 
       const rot = (PI2 + (shape.rotation - PI2 / 4)) % PI2
 
-      getShapeUtils(shape).rotateTo(shape, rot).translateTo(shape, nextPoint)
+      getShapeUtils(shape)
+        .setProperty(shape, 'rotation', rot)
+        .setProperty(shape, 'point', nextPoint)
 
       return [id, shape]
     })
           const shape = shapes[id]
 
           getShapeUtils(shape)
-            .rotateTo(shape, nextShapes[id].rotation)
-            .translateTo(shape, nextShapes[id].point)
+            .setProperty(shape, 'rotation', nextShapes[id].rotation)
+            .setProperty(shape, 'point', nextShapes[id].point)
         }
 
         data.boundsRotation = nextboundsRotation
 
           const shape = shapes[id]
           const utils = getShapeUtils(shape)
-          utils.rotateTo(shape, rotation).translateTo(shape, point)
+          utils
+            .setProperty(shape, 'rotation', rotation)
+            .setProperty(shape, 'point', point)
         }
 
         data.boundsRotation = boundsRotation

state/commands/rotate.ts

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

state/commands/translate.ts

 
         for (const { id, point } of initialShapes) {
           const shape = shapes[id]
-          getShapeUtils(shape).translateTo(shape, point)
+          getShapeUtils(shape).setProperty(shape, 'point', point)
           data.selectedIds.add(id)
         }
       },
 
         for (const { id, point } of initialShapes) {
           const shape = shapes[id]
-          getShapeUtils(shape).translateTo(shape, point)
+          getShapeUtils(shape).setProperty(shape, 'point', point)
           data.selectedIds.add(id)
         }
       },

state/sessions/arrow-session.ts

 
     getShapeUtils(shape)
       .onHandleMove(shape, { end: initialShape.handles.end })
-      .translateTo(shape, initialShape.point)
+      .setProperty(shape, 'point', initialShape.point)
   }
 
   complete(data: Data) {
         nextHandles.end.point,
       ])
       .setProperty(shape, 'handles', nextHandles)
-      .translateTo(shape, newPoint)
+      .setProperty(shape, 'point', newPoint)
       .onHandleMove(shape, nextHandles)
 
     commands.arrow(

state/sessions/draw-session.ts

 
     const page = getPage(data)
     const shape = page.shapes[id]
-    getShapeUtils(shape).translateTo(shape, point)
+    getShapeUtils(shape).setProperty(shape, 'point', point)
   }
 
   update = (data: Data, point: number[], isLocked = false) => {
 
       getShapeUtils(shape)
         .setProperty(shape, 'points', pts)
-        .translateTo(shape, vec.add(shape.point, [minX, minY]))
+        .setProperty(shape, 'point', vec.add(shape.point, [minX, minY]))
     }
 
     commands.draw(data, this.snapshot.id, this.points)

state/sessions/rotate-session.ts

       )
 
       getShapeUtils(shape)
-        .rotateTo(shape, (PI2 + nextRotation) % PI2)
-        .translateTo(shape, nextPoint)
+        .setProperty(shape, 'rotation', (PI2 + nextRotation) % PI2)
+        .setProperty(shape, 'point', nextPoint)
     }
   }
 
 
     for (let { id, point, rotation } of this.snapshot.initialShapes) {
       const shape = page.shapes[id]
-      getShapeUtils(shape).rotateTo(shape, rotation).translateTo(shape, point)
+      getShapeUtils(shape)
+        .setProperty(shape, 'rotation', rotation)
+        .setProperty(shape, 'point', point)
     }
   }
 

state/sessions/translate-session.ts

 
         for (const { id, point } of initialShapes) {
           const shape = shapes[id]
-          getShapeUtils(shape).translateTo(shape, point)
+          getShapeUtils(shape).setProperty(shape, 'point', point)
         }
 
         for (const clone of clones) {
 
       for (const { id, point } of clones) {
         const shape = shapes[id]
-        getShapeUtils(shape).translateTo(shape, vec.add(point, delta))
+        getShapeUtils(shape).setProperty(shape, 'point', vec.add(point, delta))
       }
     } else {
       if (this.isCloning) {
 
       for (const { id, point } of initialShapes) {
         const shape = shapes[id]
-        getShapeUtils(shape).translateTo(shape, vec.add(point, delta))
+        getShapeUtils(shape).setProperty(shape, 'point', vec.add(point, delta))
       }
     }
   }
 
     for (const { id, point } of initialShapes) {
       const shape = shapes[id]
-      getShapeUtils(shape).translateTo(shape, point)
+      getShapeUtils(shape).setProperty(shape, 'point', point)
     }
 
     for (const { id } of clones) {