Improves behavior with locked shapes

hooks/useZoomEvents.ts

         if (event.ctrlKey) {
           const { point } = inputs.wheel(event as WheelEvent)
           fastZoomUpdate(point, delta[1])
-          // state.send('ZOOMED_CAMERA', {
-          //   delta: delta[1],
-          //   ...inputs.wheel(event as WheelEvent),
-          // })
           return
         }
 
           angleDelta
         )
 
-        // state.send('PINCHED', {
-        //   delta: vec.sub(rPinchPoint.current, origin),
-        //   point: origin,
-        //   distanceDelta,
-        //   angleDelta,
-        // })
-
         rPinchDa.current = da
         rPinchPoint.current = origin
       },

lib/shape-utils/arrow.tsx

 import { uniqueId } from 'utils/utils'
 import vec from 'utils/vec'
 import {
-  ease,
   getSvgPathFromStroke,
   rng,
   getBoundsFromPoints,
       body = <path d={path} />
     }
 
-    return (
-      <g id={id}>
-        {body}
-        {/* <circle
-          cx={start.point[0]}
-          cy={start.point[1]}
-          r={Math.max(4, +style.strokeWidth)}
-          fill={style.stroke}
-          strokeDasharray="none"
-        /> */}
-      </g>
-    )
+    return <g id={id}>{body}</g>
   },
 
   rotateBy(shape, delta) {
 
   const dist = vec.dist(start.point, end.point)
   const midPoint = vec.med(start.point, end.point)
-  const bendDist = (dist / 2) * shape.bend * Math.min(1, dist / 128)
+  const bendDist = (dist / 2) * shape.bend
   const u = vec.uni(vec.vec(start.point, end.point))
 
   return Math.abs(bendDist) < 10
 
 function renderPath(shape: ArrowShape, endAngle = 0) {
   const { style, id } = shape
-  const { start, end, bend } = shape.handles
+  const { start, end } = shape.handles
 
   const getRandom = rng(id)
-  const offsetA = getRandom()
 
   const strokeWidth = +getShapeStyle(style).strokeWidth * 2
 

state/commands/delete-selected.ts

 import {
   getDocumentBranch,
   getPage,
+  getPageState,
   getSelectedIds,
+  getSelectedShapes,
   setSelectedIds,
   setToArray,
   updateParents,
 export default function deleteSelected(data: Data) {
   const { currentPageId } = data
 
-  const selectedIds = getSelectedIds(data)
-  const selectedIdsArr = setToArray(selectedIds)
+  const selectedShapes = getSelectedShapes(data)
+
+  const selectedIdsArr = selectedShapes
+    .filter((shape) => !shape.isLocked)
+    .map((shape) => shape.id)
 
   const page = getPage(current(data))
 
     .flatMap((id) => getDocumentBranch(data, id))
     .map((id) => page.shapes[id])
 
-  selectedIds.clear()
+  const remainingIds = selectedShapes
+    .filter((shape) => shape.isLocked)
+    .map((shape) => shape.id)
 
   history.execute(
     data,
           delete page.shapes[shape.id]
         }
 
-        setSelectedIds(data, [])
+        setSelectedIds(data, remainingIds)
       },
       undo(data) {
         const page = getPage(data, currentPageId)

state/commands/distribute.ts

 export default function distributeCommand(data: Data, type: DistributeType) {
   const { currentPageId } = data
 
-  const selectedShapes = getSelectedShapes(data)
+  const selectedShapes = getSelectedShapes(data).filter(
+    (shape) => !shape.isLocked
+  )
 
   const entries = selectedShapes.map(
     (shape) => [shape.id, getShapeUtils(shape).getBounds(shape)] as const

state/commands/edit.ts

     new Command({
       name: 'edited_shape',
       category: 'canvas',
-      do(data, isInitial) {
+      do(data) {
         const { initialShape, currentPageId } = after
 
         const page = getPage(data, currentPageId)

state/commands/reset-bounds.ts

       category: 'canvas',
       do(data) {
         getSelectedShapes(data).forEach((shape) => {
+          if (shape.isLocked) return
           getShapeUtils(shape).onBoundsReset(shape)
         })
 
       undo(data) {
         const page = getPage(data)
         getSelectedShapes(data).forEach((shape) => {
+          if (shape.isLocked) return
           page.shapes[shape.id] = initialShapes[shape.id]
         })
 

state/commands/rotate-ccw.ts

 
         for (let id in nextShapes) {
           const shape = shapes[id]
+          if (shape.isLocked) continue
 
           getShapeUtils(shape)
             .setProperty(shape, 'rotation', nextShapes[id].rotation)
           const { point, rotation } = initialShapes[id]
 
           const shape = shapes[id]
+
+          if (shape.isLocked) continue
+
           const utils = getShapeUtils(shape)
           utils
             .setProperty(shape, 'rotation', rotation)

state/commands/toggle.ts

   history.execute(
     data,
     new Command({
-      name: 'hide_shapes',
+      name: 'toggle_shape_prop',
       category: 'canvas',
       do(data) {
         const { shapes } = getPage(data, currentPageId)

state/state.ts

       return data.isReadOnly
     },
     canEditSelectedShape(data, payload, result: Shape) {
-      return getShapeUtils(result).canEdit
+      return getShapeUtils(result).canEdit && !result.isLocked
     },
     distanceImpliesDrag(data, payload: PointerInfo) {
       return vec.dist2(payload.origin, payload.point) > 8