Starts implementing locked shapes

components/canvas/bounds/bounding-box.tsx

 import * as React from 'react'
 import { Edge, Corner } from 'types'
 import { useSelector } from 'state'
-import { getSelectedShapes, isMobile } from 'utils/utils'
+import { getPage, getSelectedShapes, isMobile } from 'utils/utils'
 
 import CenterHandle from './center-handle'
 import CornerHandle from './corner-handle'
   const isSelecting = useSelector((s) => s.isIn('selecting'))
   const zoom = useSelector((s) => s.data.camera.zoom)
   const bounds = useSelector((s) => s.values.selectedBounds)
+
   const rotation = useSelector(({ data }) =>
     data.selectedIds.size === 1 ? getSelectedShapes(data)[0].rotation : 0
   )
 
+  const isAllLocked = useSelector((s) => {
+    const page = getPage(s.data)
+    return Array.from(s.data.selectedIds.values()).every(
+      (id) => page.shapes[id].isLocked
+    )
+  })
+
   if (!bounds) return null
   if (!isSelecting) return null
 
         ${(bounds.minY + bounds.maxY) / 2})
         translate(${bounds.minX},${bounds.minY})`}
     >
-      <CenterHandle bounds={bounds} />
-      <EdgeHandle size={size} bounds={bounds} edge={Edge.Top} />
-      <EdgeHandle size={size} bounds={bounds} edge={Edge.Right} />
-      <EdgeHandle size={size} bounds={bounds} edge={Edge.Bottom} />
-      <EdgeHandle size={size} bounds={bounds} edge={Edge.Left} />
-      <CornerHandle size={size} bounds={bounds} corner={Corner.TopLeft} />
-      <CornerHandle size={size} bounds={bounds} corner={Corner.TopRight} />
-      <CornerHandle size={size} bounds={bounds} corner={Corner.BottomRight} />
-      <CornerHandle size={size} bounds={bounds} corner={Corner.BottomLeft} />
-      <RotateHandle size={size} bounds={bounds} />
+      <CenterHandle bounds={bounds} isLocked={isAllLocked} />
+      {!isAllLocked && (
+        <>
+          <EdgeHandle size={size} bounds={bounds} edge={Edge.Top} />
+          <EdgeHandle size={size} bounds={bounds} edge={Edge.Right} />
+          <EdgeHandle size={size} bounds={bounds} edge={Edge.Bottom} />
+          <EdgeHandle size={size} bounds={bounds} edge={Edge.Left} />
+          <CornerHandle size={size} bounds={bounds} corner={Corner.TopLeft} />
+          <CornerHandle size={size} bounds={bounds} corner={Corner.TopRight} />
+          <CornerHandle
+            size={size}
+            bounds={bounds}
+            corner={Corner.BottomRight}
+          />
+          <CornerHandle
+            size={size}
+            bounds={bounds}
+            corner={Corner.BottomLeft}
+          />
+          <RotateHandle size={size} bounds={bounds} />
+        </>
+      )}
     </g>
   )
 }

components/canvas/bounds/center-handle.tsx

-import styled from "styles"
-import { Bounds } from "types"
+import styled from 'styles'
+import { Bounds } from 'types'
 
-export default function CenterHandle({ bounds }: { bounds: Bounds }) {
+export default function CenterHandle({
+  bounds,
+  isLocked,
+}: {
+  bounds: Bounds
+  isLocked: boolean
+}) {
   return (
     <StyledBounds
       width={bounds.width}
       height={bounds.height}
       pointerEvents="none"
+      isLocked={isLocked}
     />
   )
 }
 
-const StyledBounds = styled("rect", {
-  fill: "none",
-  stroke: "$bounds",
+const StyledBounds = styled('rect', {
+  fill: 'none',
+  stroke: '$bounds',
   zStrokeWidth: 2,
+
+  variants: {
+    isLocked: {
+      true: {
+        zStrokeWidth: 1,
+        zDash: 2,
+      },
+    },
+  },
 })

components/canvas/selected.tsx

       as="use"
       href={'#' + id}
       transform={transform}
+      isLocked={shape.isLocked}
       {...events}
     />
   )
   stroke: '$selected',
   fill: 'transparent',
   pointerEvents: 'all',
+
+  variants: {
+    isLocked: {
+      true: {
+        zDash: 2,
+      },
+      false: {},
+    },
+  },
 })

state/commands/transform.ts

-import Command from "./command"
-import history from "../history"
-import { Data, Corner, Edge } from "types"
-import { TransformSnapshot } from "state/sessions/transform-session"
-import { getShapeUtils } from "lib/shape-utils"
-import { getPage } from "utils/utils"
+import Command from './command'
+import history from '../history'
+import { Data } from 'types'
+import { TransformSnapshot } from 'state/sessions/transform-session'
+import { getShapeUtils } from 'lib/shape-utils'
+import { getPage } from 'utils/utils'
 
 export default function transformCommand(
   data: Data,
   before: TransformSnapshot,
-  after: TransformSnapshot,
-  scaleX: number,
-  scaleY: number
+  after: TransformSnapshot
 ) {
   history.execute(
     data,
     new Command({
-      name: "translate_shapes",
-      category: "canvas",
+      name: 'translate_shapes',
+      category: 'canvas',
       do(data) {
-        const { type, selectedIds } = after
+        const { type, shapeBounds } = after
 
         const { shapes } = getPage(data)
 
-        selectedIds.forEach((id) => {
+        for (let id in shapeBounds) {
           const { initialShape, initialShapeBounds, transformOrigin } =
-            after.shapeBounds[id]
+            shapeBounds[id]
           const shape = shapes[id]
 
           getShapeUtils(shape).transform(shape, initialShapeBounds, {
             type,
             initialShape,
+            transformOrigin,
             scaleX: 1,
             scaleY: 1,
-            transformOrigin,
           })
-        })
+        }
       },
       undo(data) {
-        const { type, selectedIds } = before
+        const { type, shapeBounds } = before
 
         const { shapes } = getPage(data)
 
-        selectedIds.forEach((id) => {
+        for (let id in shapeBounds) {
           const { initialShape, initialShapeBounds, transformOrigin } =
-            before.shapeBounds[id]
+            shapeBounds[id]
           const shape = shapes[id]
 
           getShapeUtils(shape).transform(shape, initialShapeBounds, {
             type,
             initialShape,
+            transformOrigin,
             scaleX: 1,
             scaleY: 1,
-            transformOrigin,
           })
-        })
+        }
       },
     })
   )

state/commands/translate.ts

-import Command from "./command"
-import history from "../history"
-import { TranslateSnapshot } from "state/sessions/translate-session"
-import { Data } from "types"
-import { getPage } from "utils/utils"
-import { getShapeUtils } from "lib/shape-utils"
+import Command from './command'
+import history from '../history'
+import { TranslateSnapshot } from 'state/sessions/translate-session'
+import { Data } from 'types'
+import { getPage } from 'utils/utils'
+import { getShapeUtils } from 'lib/shape-utils'
 
 export default function translateCommand(
   data: Data,
   history.execute(
     data,
     new Command({
-      name: isCloning ? "clone_shapes" : "translate_shapes",
-      category: "canvas",
+      name: isCloning ? 'clone_shapes' : 'translate_shapes',
+      category: 'canvas',
       manualSelection: true,
       do(data, initial) {
         if (initial) return

state/sessions/transform-session.ts

-import { Data, Edge, Corner } from "types"
-import * as vec from "utils/vec"
-import BaseSession from "./base-session"
-import commands from "state/commands"
-import { current } from "immer"
-import { getShapeUtils } from "lib/shape-utils"
+import { Data, Edge, Corner } from 'types'
+import * as vec from 'utils/vec'
+import BaseSession from './base-session'
+import commands from 'state/commands'
+import { current } from 'immer'
+import { getShapeUtils } from 'lib/shape-utils'
 import {
   getBoundsCenter,
   getBoundsFromPoints,
   getCommonBounds,
   getPage,
   getRelativeTransformedBoundingBox,
+  getSelectedShapes,
   getShapes,
   getTransformedBoundingBox,
-} from "utils/utils"
+} from 'utils/utils'
 
 export default class TransformSession extends BaseSession {
   scaleX = 1
   update(data: Data, point: number[], isAspectRatioLocked = false) {
     const { transformType } = this
 
-    const { selectedIds, shapeBounds, initialBounds } = this.snapshot
+    const { shapeBounds, initialBounds } = this.snapshot
 
     const { shapes } = getPage(data)
 
 
     // Now work backward to calculate a new bounding box for each of the shapes.
 
-    selectedIds.forEach((id) => {
+    for (let id in shapeBounds) {
       const { initialShape, initialShapeBounds, transformOrigin } =
         shapeBounds[id]
 
         scaleY: this.scaleY,
         transformOrigin,
       })
-    })
+    }
   }
 
   cancel(data: Data) {
-    const { currentPageId, selectedIds, shapeBounds } = this.snapshot
+    const { currentPageId, shapeBounds } = this.snapshot
 
     const page = getPage(data, currentPageId)
 
-    selectedIds.forEach((id) => {
+    for (let id in shapeBounds) {
       const shape = page.shapes[id]
 
       const { initialShape, initialShapeBounds, transformOrigin } =
         scaleY: 1,
         transformOrigin,
       })
-    })
+    }
   }
 
   complete(data: Data) {
     commands.transform(
       data,
       this.snapshot,
-      getTransformSnapshot(data, this.transformType),
-      this.scaleX,
-      this.scaleY
+      getTransformSnapshot(data, this.transformType)
     )
   }
 }
 
 export function getTransformSnapshot(data: Data, transformType: Edge | Corner) {
-  const {
-    document: { pages },
-    selectedIds,
-    currentPageId,
-  } = current(data)
+  const cData = current(data)
+  const { currentPageId } = cData
 
-  const pageShapes = pages[currentPageId].shapes
+  const initialShapes = getSelectedShapes(cData).filter(
+    (shape) => !shape.isLocked
+  )
+  const hasShapes = initialShapes.length > 0
 
   // A mapping of selected shapes and their bounds
   const shapesBounds = Object.fromEntries(
-    Array.from(selectedIds.values()).map((id) => {
-      const shape = pageShapes[id]
-      return [shape.id, getShapeUtils(shape).getBounds(shape)]
-    })
+    initialShapes.map((shape) => [
+      shape.id,
+      getShapeUtils(shape).getBounds(shape),
+    ])
   )
 
   const boundsArr = Object.values(shapesBounds)
   // positions of the shape's bounds within the common bounds shape.
   return {
     type: transformType,
+    hasShapes,
     currentPageId,
-    selectedIds: new Set(selectedIds),
     initialBounds: bounds,
     shapeBounds: Object.fromEntries(
-      Array.from(selectedIds.values()).map((id) => {
-        const shape = pageShapes[id]
-        const initialShapeBounds = shapesBounds[id]
+      initialShapes.map((shape) => {
+        const initialShapeBounds = shapesBounds[shape.id]
         const ic = getBoundsCenter(initialShapeBounds)
 
         let ix = (ic[0] - initialInnerBounds.minX) / initialInnerBounds.width
         let iy = (ic[1] - initialInnerBounds.minY) / initialInnerBounds.height
 
         return [
-          id,
+          shape.id,
           {
             initialShape: shape,
             initialShapeBounds,

state/sessions/translate-session.ts

-import { Data } from "types"
-import * as vec from "utils/vec"
-import BaseSession from "./base-session"
-import commands from "state/commands"
-import { current } from "immer"
-import { v4 as uuid } from "uuid"
-import { getChildIndexAbove, getPage, getSelectedShapes } from "utils/utils"
-import { getShapeUtils } from "lib/shape-utils"
+import { Data } from 'types'
+import * as vec from 'utils/vec'
+import BaseSession from './base-session'
+import commands from 'state/commands'
+import { current } from 'immer'
+import { v4 as uuid } from 'uuid'
+import { getChildIndexAbove, getPage, getSelectedShapes } from 'utils/utils'
+import { getShapeUtils } from 'lib/shape-utils'
 
 export default class TranslateSession extends BaseSession {
   delta = [0, 0]
   }
 
   complete(data: Data) {
+    if (!this.snapshot.hasShapes) return
+
     commands.translate(
       data,
       this.snapshot,
 
 export function getTranslateSnapshot(data: Data) {
   const cData = current(data)
-  const shapes = getSelectedShapes(cData)
+  const shapes = getSelectedShapes(cData).filter((shape) => !shape.isLocked)
+  const hasShapes = shapes.length > 0
 
   return {
     currentPageId: data.currentPageId,
       id: uuid(),
       childIndex: getChildIndexAbove(cData, shape.id),
     })),
+    hasShapes,
   }
 }
 

state/state.ts

             UNDO: 'undo',
             REDO: 'redo',
             SAVED_CODE: 'saveCode',
-            CANCELLED: 'clearSelectedIds',
             DELETED: 'deleteSelectedIds',
             STARTED_PINCHING: { to: 'pinching' },
             INCREASED_CODE_FONT_SIZE: 'increaseCodeFontSize',
           states: {
             notPointing: {
               on: {
+                CANCELLED: 'clearSelectedIds',
                 POINTED_CANVAS: { to: 'brushSelecting' },
                 POINTED_BOUNDS: { to: 'pointingBounds' },
                 POINTED_BOUNDS_HANDLE: {

styles/stitches.config.ts

     transitions: {},
   },
   utils: {
+    zDash: () => (value: number) => {
+      return {
+        strokeDasharray: `calc(${value}px / var(--camera-zoom)) calc(${value}px / var(--camera-zoom))`,
+      }
+    },
     zStrokeWidth: () => (value: number | number[]) => {
       if (Array.isArray(value)) {
         // const [val, min, max] = value