Fixes selection for shapes in a group

state/commands/delete-selected.ts

 import Command from './command'
 import history from '../history'
 import { TranslateSnapshot } from 'state/sessions/translate-session'
-import { Data } from 'types'
-import { getPage, updateParents } from 'utils/utils'
+import { Data, ShapeType } from 'types'
+import { getDocumentBranch, getPage, updateParents } from 'utils/utils'
 import { current } from 'immer'
 import { getShapeUtils } from 'lib/shape-utils'
 
 
   const page = getPage(current(data))
 
-  const shapes = selectedIds.map((id) => page.shapes[id])
+  const childrenToDelete = selectedIds
+    .flatMap((id) => getDocumentBranch(data, id))
+    .map((id) => page.shapes[id])
 
   data.selectedIds.clear()
 
                 parent.children.map((id) => page.shapes[id])
               )
           }
-          delete page.shapes[id]
+
+          for (let shape of childrenToDelete) {
+            delete page.shapes[shape.id]
+          }
         }
 
         data.selectedIds.clear()
       },
       undo(data) {
         const page = getPage(data, currentPageId)
-        data.selectedIds.clear()
-        for (let shape of shapes) {
+
+        for (let shape of childrenToDelete) {
           page.shapes[shape.id] = shape
-          data.selectedIds.add(shape.id)
         }
+
+        data.selectedIds = new Set(selectedIds)
       },
     })
   )

state/commands/style.ts

 import Command from './command'
 import history from '../history'
 import { Data, ShapeStyles } from 'types'
-import { getPage, getSelectedShapes } from 'utils/utils'
+import { getDocumentBranch, getPage, getSelectedShapes } from 'utils/utils'
 import { getShapeUtils } from 'lib/shape-utils'
 import { current } from 'immer'
 
 export default function styleCommand(data: Data, styles: Partial<ShapeStyles>) {
-  const { currentPageId } = data
-  const initialShapes = getSelectedShapes(current(data))
+  const cData = current(data)
+  const page = getPage(cData)
+  const { currentPageId } = cData
+
+  const shapesToStyle = Array.from(data.selectedIds.values())
+    .flatMap((id) => getDocumentBranch(data, id))
+    .map((id) => page.shapes[id])
 
   history.execute(
     data,
       do(data) {
         const { shapes } = getPage(data, currentPageId)
 
-        for (const { id } of initialShapes) {
+        for (const { id } of shapesToStyle) {
           const shape = shapes[id]
           getShapeUtils(shape).applyStyles(shape, styles)
         }
       undo(data) {
         const { shapes } = getPage(data, currentPageId)
 
-        for (const { id, style } of initialShapes) {
+        for (const { id, style } of shapesToStyle) {
           const shape = shapes[id]
           getShapeUtils(shape).applyStyles(shape, style)
         }

state/history.ts

 import { Data } from 'types'
 import { BaseCommand } from './commands/command'
 
-const CURRENT_VERSION = 'code_slate_0.0.2'
+const CURRENT_VERSION = 'code_slate_0.0.3'
 
 // A singleton to manage history changes.
 

state/sessions/brush-session.ts

 
     const brushBounds = getBoundsFromPoints([origin, point])
 
+    const hits = new Set<string>([])
+
     for (let id in snapshot.shapeHitTests) {
       const { test, selectId } = snapshot.shapeHitTests[id]
-      if (test(brushBounds)) {
-        // When brushing a shape, select its top group parent.
-        if (!data.selectedIds.has(selectId)) {
-          data.selectedIds.add(selectId)
+      if (!hits.has(selectId)) {
+        if (test(brushBounds)) {
+          hits.add(selectId)
+
+          // When brushing a shape, select its top group parent.
+          if (!data.selectedIds.has(selectId)) {
+            data.selectedIds.add(selectId)
+          }
+        } else if (data.selectedIds.has(selectId)) {
+          data.selectedIds.delete(selectId)
         }
-
-        // Possibly... select all of the top group parent's children too?
-        // const selectedId = getTopParentId(data, id)
-        // const idsToSelect = collectChildIds(data, selectedId)
-
-        // for (let id in idsToSelect) {
-        //   if (!data.selectedIds.has(id)) {
-        //     data.selectedIds.add(id)
-        //   }
-        // }
-      } else if (data.selectedIds.has(selectId)) {
-        data.selectedIds.delete(selectId)
       }
     }
 
     ? id
     : getTopParentId(data, shape.parentId)
 }
-
-function collectChildIds(data: Data, id: string): string[] {
-  const shape = getPage(data).shapes[id]
-
-  if (shape.type === ShapeType.Group) {
-    return [
-      id,
-      ...shape.children.flatMap((childId) => collectChildIds(data, childId)),
-    ]
-  }
-
-  return [id]
-}

state/state.ts

       const page = getPage(data)
       selectedIds.clear()
       for (let id in page.shapes) {
-        selectedIds.add(id)
+        if (page.shapes[id].parentId === data.currentPageId) {
+          selectedIds.add(id)
+        }
       }
     },
     setHoveredId(data, payload: PointerInfo) {

utils/utils.ts

 //   })
 // }
 
+/* --------------------- Groups --------------------- */
+
 export function updateParents(data: Data, changedShapeIds: string[]) {
   if (changedShapeIds.length === 0) return
 
     ? rotation + shape.rotation
     : getParentRotation(data, shape.parentId, rotation + shape.rotation)
 }
+
+export function getDocumentBranch(data: Data, id: string): string[] {
+  const shape = getPage(data).shapes[id]
+  if (shape.type !== ShapeType.Group) return [id]
+
+  return [
+    id,
+    ...shape.children.flatMap((childId) => getDocumentBranch(data, childId)),
+  ]
+}