Improves cloning

state/commands/translate.ts

 
         data.selectedIds.clear()
 
-        for (let id in initialShapes) {
-          shapes[id].point = initialShapes[id].point
-          shapes[clones[id].id] = clones[id]
+        if (isCloning) {
+          for (const clone of clones) {
+            shapes[clone.id] = clone
+          }
+        }
+
+        for (const { id, point } of initialShapes) {
+          shapes[id].point = point
           data.selectedIds.add(id)
         }
       },
 
         data.selectedIds.clear()
 
-        for (let id in initialShapes) {
-          shapes[id].point = initialShapes[id].point
-          data.selectedIds.add(id)
-
-          if (isCloning) {
-            const clone = clones[id]
-            delete shapes[clone.id]
+        if (isCloning) {
+          for (const { id } of clones) {
+            delete shapes[id]
           }
         }
+
+        for (const { id, point } of initialShapes) {
+          shapes[id].point = point
+          data.selectedIds.add(id)
+        }
       },
     })
   )

state/sessions/translate-session.ts

   update(data: Data, point: number[], isAligned: boolean, isCloning: boolean) {
     const { currentPageId, clones, initialShapes } = this.snapshot
     const { shapes } = data.document.pages[currentPageId]
+
     const delta = vec.vec(this.origin, point)
 
     if (isAligned) {
       }
     }
 
-    if (isCloning && !this.isCloning) {
-      this.isCloning = true
-      for (let id in clones) {
-        const clone = clones[id]
-        shapes[clone.id] = clone
+    if (isCloning) {
+      if (!this.isCloning) {
+        this.isCloning = true
+        data.selectedIds.clear()
+
+        for (const { id, point } of initialShapes) {
+          shapes[id].point = point
+        }
+
+        for (const clone of clones) {
+          shapes[clone.id] = { ...clone }
+          data.selectedIds.add(clone.id)
+        }
       }
-    } else if (!isCloning && this.isCloning) {
-      this.isCloning = false
-      for (let id in clones) {
-        const clone = clones[id]
-        delete shapes[clone.id]
+
+      for (const { id, point } of clones) {
+        shapes[id].point = vec.add(point, delta)
       }
-    }
+    } else {
+      if (this.isCloning) {
+        this.isCloning = false
+        data.selectedIds.clear()
+
+        for (const { id } of initialShapes) {
+          data.selectedIds.add(id)
+        }
 
-    for (let id in initialShapes) {
-      shapes[id].point = vec.add(initialShapes[id].point, delta)
+        for (const clone of clones) {
+          delete shapes[clone.id]
+        }
+      }
+
+      for (const { id, point } of initialShapes) {
+        shapes[id].point = vec.add(point, delta)
+      }
     }
   }
 
     const { initialShapes, clones, currentPageId } = this.snapshot
     const { shapes } = data.document.pages[currentPageId]
 
-    for (let id in initialShapes) {
-      shapes[id].point = initialShapes[id].point
-      delete shapes[clones[id].id]
+    for (const { id, point } of initialShapes) {
+      shapes[id].point = point
+    }
+
+    for (const { id } of clones) {
+      delete shapes[id]
     }
   }
 
 }
 
 export function getTranslateSnapshot(data: Data) {
-  const {
-    document: { pages },
-    currentPageId,
-  } = current(data)
+  const { document, selectedIds, currentPageId } = current(data)
 
-  const shapes = Array.from(data.selectedIds.values()).map(
-    (id) => pages[currentPageId].shapes[id]
+  const shapes = Array.from(selectedIds.values()).map(
+    (id) => document.pages[currentPageId].shapes[id]
   )
 
-  // Clones and shapes are keyed under the same id, though the clone itself
-  // has a different id.
-
   return {
     currentPageId,
-    initialShapes: Object.fromEntries(shapes.map((shape) => [shape.id, shape])),
-    clones: Object.fromEntries(
-      shapes.map((shape) => [shape.id, { ...shape, id: uuid() }])
-    ),
+    initialShapes: shapes.map(({ id, point }) => ({ id, point })),
+    clones: shapes.map((shape) => ({ ...shape, id: uuid() })),
   }
 }
 

state/state.ts

                 },
                 UNHOVERED_SHAPE: "clearHoveredId",
                 POINTED_SHAPE: [
-                  "setPointedId",
                   {
-                    if: "isPressingShiftKey",
-                    unless: "isPointedShapeSelected",
-                    do: ["pushPointedIdToSelectedIds", "clearPointedId"],
-                    to: "pointingBounds",
+                    if: "isPressingMetaKey",
+                    to: "brushSelecting",
                   },
+                  "setPointedId",
                   {
                     unless: "isPointedShapeSelected",
-                    do: ["clearSelectedIds", "pushPointedIdToSelectedIds"],
+                    then: {
+                      if: "isPressingShiftKey",
+                      do: ["pushPointedIdToSelectedIds", "clearPointedId"],
+                      else: ["clearSelectedIds", "pushPointedIdToSelectedIds"],
+                    },
                   },
                   {
                     to: "pointingBounds",
                       do: "pullPointedIdFromSelectedIds",
                     },
                     else: {
-                      if: "isPointingBounds",
+                      unless: "isPointingBounds",
                       do: ["clearSelectedIds", "pushPointedIdToSelectedIds"],
                     },
                   },
             },
             brushSelecting: {
               onEnter: [
-                { unless: "isPressingShiftKey", do: "clearSelectedIds" },
+                {
+                  unless: ["isPressingMetaKey", "isPressingShiftKey"],
+                  do: "clearSelectedIds",
+                },
                 "clearBoundsRotation",
                 "startBrushSession",
               ],
     isPointedShapeSelected(data) {
       return data.selectedIds.has(data.pointedId)
     },
-    isPressingShiftKey(data, payload: { shiftKey: boolean }) {
+    isPressingShiftKey(data, payload: PointerInfo) {
       return payload.shiftKey
     },
+    isPressingMetaKey(data, payload: PointerInfo) {
+      return payload.metaKey
+    },
     shapeIsHovered(data, payload: { target: string }) {
       return data.hoveredId === payload.target
     },
       )
     },
     updateTranslateSession(data, payload: PointerInfo) {
-      console.log(payload.altKey)
       session.update(
         data,
         screenToWorld(payload.point, data),