Improves translating, breaks save/load again

hooks/useCanvasEvents.ts

 import { MutableRefObject, useCallback } from 'react'
 import state from 'state'
-import { fastBrushSelect, fastDrawUpdate } from 'state/hacks'
+import { fastBrushSelect, fastDrawUpdate, fastTranslate } from 'state/hacks'
 import inputs from 'state/inputs'
 import { isMobile } from 'utils/utils'
 
   const handlePointerMove = useCallback((e: React.PointerEvent) => {
     if (!inputs.canAccept(e.pointerId)) return
 
+    const info = inputs.pointerMove(e)
+
     if (state.isIn('draw.editing')) {
-      fastDrawUpdate(inputs.pointerMove(e))
+      fastDrawUpdate(info)
       return
     }
 
     if (state.isIn('brushSelecting')) {
-      const info = inputs.pointerMove(e)
       fastBrushSelect(info.point)
       return
     }
 
-    state.send('MOVED_POINTER', inputs.pointerMove(e))
+    if (state.isIn('translatingSelection')) {
+      fastTranslate(info)
+      return
+    }
+
+    state.send('MOVED_POINTER', info)
   }, [])
 
   const handlePointerUp = useCallback((e: React.PointerEvent) => {

hooks/useShapeEvents.ts

       e.stopPropagation()
       rGroup.current.setPointerCapture(e.pointerId)
 
+      const info = inputs.pointerDown(e, id)
+
       if (e.button === 0) {
-        if (inputs.isDoubleClick()) {
-          state.send('DOUBLE_POINTED_SHAPE', inputs.pointerDown(e, id))
+        if (inputs.isDoubleClick() && !(info.altKey || info.metaKey)) {
+          state.send('DOUBLE_POINTED_SHAPE', info)
         }
 
-        state.send('POINTED_SHAPE', inputs.pointerDown(e, id))
+        state.send('POINTED_SHAPE', info)
       } else {
-        state.send('RIGHT_POINTED', inputs.pointerDown(e, id))
+        state.send('RIGHT_POINTED', info)
       }
     },
     [id]

lib/shape-utils/rectangle.tsx

 import { defaultStyle, getShapeStyle } from 'lib/shape-styles'
 import getStroke from 'perfect-freehand'
 
-const pathCache = new WeakMap<RectangleShape, string>([])
+const pathCache = new WeakMap<number[], string>([])
 
 const rectangle = registerShapeUtils<RectangleShape>({
   boundsCache: new WeakMap([]),
     const { id, size, radius, style } = shape
     const styles = getShapeStyle(style)
 
-    if (!pathCache.has(shape)) {
+    if (!pathCache.has(shape.size)) {
       renderPath(shape)
     }
 
-    const path = pathCache.get(shape)
+    const path = pathCache.get(shape.size)
 
     return (
       <g id={id}>
     }
   )
 
-  pathCache.set(shape, getSvgPathFromStroke(stroke))
+  pathCache.set(shape.size, getSvgPathFromStroke(stroke))
 }

state/sessions/translate-session.ts

         for (const { id, point } of initialShapes) {
           const shape = shapes[id]
           getShapeUtils(shape).translateTo(shape, point)
+          shapes[shape.id] = { ...shape }
         }
 
         for (const clone of clones) {
 
           getShapeUtils(shape).translateBy(shape, delta)
 
+          shapes[clone.id] = { ...shape }
+
           const parent = shapes[shape.parentId]
 
           if (!parent) continue
             ...parent.children,
             shape.id,
           ])
+
+          shapes[shape.parentId] = { ...parent }
         }
       }
 
       for (const { id } of clones) {
         const shape = shapes[id]
         getShapeUtils(shape).translateBy(shape, trueDelta)
+        shapes[id] = { ...shape }
       }
 
       setSelectedIds(
           getDocumentBranch(data, initialShape.id).forEach((id) => {
             const shape = shapes[id]
             getShapeUtils(shape).translateBy(shape, delta)
+            shapes[id] = { ...shape }
           })
         }
 
-        initialParents.forEach(
-          (parent) =>
-            ((shapes[parent.id] as GroupShape).children = parent.children)
-        )
+        initialParents.forEach((parent) => {
+          const shape = shapes[parent.id] as GroupShape
+          shapes[parent.id] = { ...shape, children: parent.children }
+        })
       }
 
       for (const initialShape of initialShapes) {
         getDocumentBranch(data, initialShape.id).forEach((id) => {
           const shape = shapes[id]
           getShapeUtils(shape).translateBy(shape, trueDelta)
+
+          shapes[id] = { ...shape }
         })
       }
 
     clones: selectedShapes
       .filter((shape) => shape.type !== ShapeType.Group)
       .flatMap((shape) => {
-        // TODO: Clone children recursively
         const clone = {
           ...shape,
           id: uuid(),
         }
 
         return clone
-
-        // cloneGroup(cData, {
-        //   ...shape,
-        //   id: uuid(),
-        //   parentId: shape.parentId,
-        //   childIndex: getChildIndexAbove(cData, shape.id),
-        // })
       }),
   }
 }

state/storage.ts

 import { v4 as uuid } from 'uuid'
 import * as idb from 'idb-keyval'
 
-const CURRENT_VERSION = 'code_slate_0.0.6'
+const CURRENT_VERSION = 'code_slate_0.0.7'
 const DOCUMENT_ID = '0001'
 
 function storageId(fileId: string, label: string, id?: string) {
 
     this.loadPage(data, data.currentPageId)
 
-    // this.saveToLocalStorage(data, data.document.id)
+    this.saveToLocalStorage(data, data.document.id)
 
     localStorage.setItem(`${CURRENT_VERSION}_lastOpened`, data.document.id)
   }

utils/utils.ts

       parent,
       parent.children.map((id) => shapes[id])
     )
+
+    shapes[parentId] = { ...parent }
   }
 
   updateParents(data, parentToUpdateIds)
 }
 
 export function lzw_encode(s: string) {
+  return s
   const dict = {}
   const data = (s + '').split('')
 
 
 // Decompress an LZW-encoded string
 export function lzw_decode(s: string) {
+  return s
+
   const dict = {}
   const data = (s + '').split('')