Fixes deleting undos

state/commands/delete-selected.ts

           page.shapes[shape.id] = shape
         }
 
+        for (let shape of childrenToDelete) {
+          if (shape.parentId !== data.currentPageId) {
+            const parent = page.shapes[shape.parentId]
+            getShapeUtils(parent)
+              .setProperty(parent, 'children', [...parent.children, shape.id])
+              .onChildrenChange(
+                parent,
+                parent.children.map((id) => page.shapes[id])
+              )
+          }
+        }
+
         data.selectedIds = new Set(selectedIds)
       },
     })

state/commands/translate.ts

 import Command from './command'
 import history from '../history'
 import { TranslateSnapshot } from 'state/sessions/translate-session'
-import { Data } from 'types'
+import { Data, GroupShape, Shape, ShapeType } from 'types'
 import { getPage, updateParents } from 'utils/utils'
 import { getShapeUtils } from 'lib/shape-utils'
+import { v4 as uuid } from 'uuid'
 
 export default function translateCommand(
   data: Data,
                 ...parent.children,
                 clone.id,
               ])
+
+              if (clone.type === ShapeType.Group) {
+              }
             }
           }
         }

state/sessions/translate-session.ts

-import { Data, GroupShape, ShapeType } from 'types'
+import { Data, GroupShape, Shape, ShapeType } from 'types'
 import * as vec from 'utils/vec'
 import BaseSession from './base-session'
 import commands from 'state/commands'
         for (const clone of clones) {
           data.selectedIds.add(clone.id)
           shapes[clone.id] = { ...clone }
-          if (clone.parentId !== data.currentPageId) {
-            const parent = shapes[clone.parentId]
-            getShapeUtils(parent).setProperty(parent, 'children', [
-              ...parent.children,
-              clone.id,
-            ])
-          }
+          const parent = shapes[clone.parentId]
+          if (!parent) continue
+          getShapeUtils(parent).setProperty(parent, 'children', [
+            ...parent.children,
+            clone.id,
+          ])
         }
       }
 
   const selectedShapes = getSelectedShapes(cData).filter(
     (shape) => !shape.isLocked
   )
+
   const hasUnlockedShapes = selectedShapes.length > 0
 
   const parents = Array.from(
       point,
       parentId,
     })),
-    clones: selectedShapes.map((shape) => ({
-      ...shape,
-      id: uuid(),
-      parentId: shape.parentId,
-      childIndex: getChildIndexAbove(cData, shape.id),
-    })),
+    clones: selectedShapes
+      .filter((shape) => shape.type !== ShapeType.Group)
+      .flatMap((shape) => {
+        const clone = {
+          ...shape,
+          id: uuid(),
+          parentId: shape.parentId,
+          childIndex: getChildIndexAbove(cData, shape.id),
+        }
+
+        return clone
+
+        // cloneGroup(cData, {
+        //   ...shape,
+        //   id: uuid(),
+        //   parentId: shape.parentId,
+        //   childIndex: getChildIndexAbove(cData, shape.id),
+        // })
+      }),
   }
 }
 
 export type TranslateSnapshot = ReturnType<typeof getTranslateSnapshot>
+
+function cloneGroup(data: Data, clone: Shape): Shape[] {
+  if (clone.type !== ShapeType.Group) {
+    return [clone]
+  }
+
+  const page = getPage(data)
+  const childClones = clone.children.flatMap((id) => {
+    const newId = uuid()
+    const source = page.shapes[id]
+    const next = { ...source, id: newId, parentId: clone.id }
+
+    if (next.type === ShapeType.Group) {
+      return [next, ...cloneGroup(data, next)]
+    }
+
+    return [next]
+  })
+
+  return [clone, ...childClones]
+}

state/state.ts

     },
 
     restoreSavedData(data) {
-      history.load(data)
+      // history.load(data)
     },
 
     clearBoundsRotation(data) {