Adds alignment to context menu

components/canvas/canvas.tsx

 import Selected from './selected'
 import Handles from './bounds/handles'
 import useCanvasEvents from 'hooks/useCanvasEvents'
-import ContextMenu from 'components/context-menu'
+import ContextMenu from './context-menu/context-menu'
 
 export default function Canvas() {
   const rCanvas = useRef<SVGSVGElement>(null)

components/context-menu.tsx → components/canvas/context-menu/context-menu.tsx

 import * as _ContextMenu from '@radix-ui/react-context-menu'
 import * as _Dropdown from '@radix-ui/react-dropdown-menu'
 import styled from 'styles'
-import { IconWrapper, RowButton } from './shared'
+import {
+  IconWrapper,
+  IconButton as _IconButton,
+  RowButton,
+} from 'components/shared'
 import {
   commandKey,
   deepCompareArrays,
   isMobile,
 } from 'utils/utils'
 import state, { useSelector } from 'state'
-import { MoveType, ShapeType } from 'types'
+import {
+  AlignType,
+  DistributeType,
+  MoveType,
+  ShapeType,
+  StretchType,
+} from 'types'
 import React, { useRef } from 'react'
-import { ChevronRightIcon } from '@radix-ui/react-icons'
+import {
+  ChevronRightIcon,
+  AlignBottomIcon,
+  AlignCenterHorizontallyIcon,
+  AlignCenterVerticallyIcon,
+  AlignLeftIcon,
+  AlignRightIcon,
+  AlignTopIcon,
+  SpaceEvenlyHorizontallyIcon,
+  SpaceEvenlyVerticallyIcon,
+  StretchHorizontallyIcon,
+  StretchVerticallyIcon,
+} from '@radix-ui/react-icons'
+
+function alignTop() {
+  state.send('ALIGNED', { type: AlignType.Top })
+}
+
+function alignCenterVertical() {
+  state.send('ALIGNED', { type: AlignType.CenterVertical })
+}
+
+function alignBottom() {
+  state.send('ALIGNED', { type: AlignType.Bottom })
+}
+
+function stretchVertically() {
+  state.send('STRETCHED', { type: StretchType.Vertical })
+}
+
+function distributeVertically() {
+  state.send('DISTRIBUTED', { type: DistributeType.Vertical })
+}
+
+function alignLeft() {
+  state.send('ALIGNED', { type: AlignType.Left })
+}
+
+function alignCenterHorizontal() {
+  state.send('ALIGNED', { type: AlignType.CenterHorizontal })
+}
+
+function alignRight() {
+  state.send('ALIGNED', { type: AlignType.Right })
+}
+
+function stretchHorizontally() {
+  state.send('STRETCHED', { type: StretchType.Horizontal })
+}
+
+function distributeHorizontally() {
+  state.send('DISTRIBUTED', { type: DistributeType.Horizontal })
+}
 
 export default function ContextMenu({
   children,
   const rContent = useRef<HTMLDivElement>(null)
 
   const hasGroupSelectd = selectedShapes.some((s) => s.type === ShapeType.Group)
-  const hasMultipleSelected = selectedShapes.length > 1
+  const hasTwoOrMore = selectedShapes.length > 1
+  const hasThreeOrMore = selectedShapes.length > 2
 
   return (
     <_ContextMenu.Root>
             </Button>
             <StyledDivider />
             {hasGroupSelectd ||
-              (hasMultipleSelected && (
+              (hasTwoOrMore && (
                 <>
                   {hasGroupSelectd && (
                     <Button onSelect={() => state.send('UNGROUPED')}>
                       </kbd>
                     </Button>
                   )}
-                  {hasMultipleSelected && (
+                  {hasTwoOrMore && (
                     <Button onSelect={() => state.send('GROUPED')}>
                       <span>Group</span>
                       <kbd>
                 </kbd>
               </Button>
             </SubMenu>
+            {hasTwoOrMore && (
+              <AlignDistributeSubMenu
+                hasTwoOrMore={hasTwoOrMore}
+                hasThreeOrMore={hasThreeOrMore}
+              />
+            )}
             <MoveToPageMenu />
             <StyledDivider />
             <Button onSelect={() => state.send('DELETED')}>
   )
 }
 
+function IconButton({
+  onSelect,
+  children,
+  disabled = false,
+}: {
+  onSelect: () => void
+  disabled?: boolean
+  children: React.ReactNode
+}) {
+  return (
+    <_ContextMenu.Item
+      as={_IconButton}
+      bp={{ '@initial': 'mobile', '@sm': 'small' }}
+      disabled={disabled}
+      onSelect={onSelect}
+    >
+      {children}
+    </_ContextMenu.Item>
+  )
+}
+
 function SubMenu({
   children,
   label,
   )
 }
 
+function AlignDistributeSubMenu({
+  hasTwoOrMore,
+  hasThreeOrMore,
+}: {
+  hasTwoOrMore: boolean
+  hasThreeOrMore: boolean
+}) {
+  return (
+    <_ContextMenu.Root>
+      <_ContextMenu.TriggerItem
+        as={RowButton}
+        bp={{ '@initial': 'mobile', '@sm': 'small' }}
+      >
+        <span>Align / Distribute</span>
+        <IconWrapper size="small">
+          <ChevronRightIcon />
+        </IconWrapper>
+      </_ContextMenu.TriggerItem>
+      <StyledGrid
+        sideOffset={2}
+        alignOffset={-2}
+        isMobile={isMobile()}
+        selectedStyle={hasThreeOrMore ? 'threeOrMore' : 'twoOrMore'}
+      >
+        <IconButton onSelect={alignLeft}>
+          <AlignLeftIcon />
+        </IconButton>
+        <IconButton onSelect={alignCenterHorizontal}>
+          <AlignCenterHorizontallyIcon />
+        </IconButton>
+        <IconButton onSelect={alignRight}>
+          <AlignRightIcon />
+        </IconButton>
+        <IconButton onSelect={stretchHorizontally}>
+          <StretchHorizontallyIcon />
+        </IconButton>
+        {hasThreeOrMore && (
+          <IconButton onSelect={distributeHorizontally}>
+            <SpaceEvenlyHorizontallyIcon />
+          </IconButton>
+        )}
+
+        <IconButton onSelect={alignTop}>
+          <AlignTopIcon />
+        </IconButton>
+        <IconButton onSelect={alignCenterVertical}>
+          <AlignCenterVerticallyIcon />
+        </IconButton>
+        <IconButton onSelect={alignBottom}>
+          <AlignBottomIcon />
+        </IconButton>
+        <IconButton onSelect={stretchVertically}>
+          <StretchVerticallyIcon />
+        </IconButton>
+        {hasThreeOrMore && (
+          <IconButton onSelect={distributeVertically}>
+            <SpaceEvenlyVerticallyIcon />
+          </IconButton>
+        )}
+        <StyledArrow offset={13} />
+      </StyledGrid>
+    </_ContextMenu.Root>
+  )
+}
+
+const StyledGrid = styled(StyledContent, {
+  display: 'grid',
+  variants: {
+    selectedStyle: {
+      threeOrMore: {
+        gridTemplateColumns: 'repeat(5, auto)',
+      },
+      twoOrMore: {
+        gridTemplateColumns: 'repeat(4, auto)',
+      },
+    },
+  },
+})
+
 function MoveToPageMenu() {
   const documentPages = useSelector((s) => s.data.document.pages)
   const currentPageId = useSelector((s) => s.data.currentPageId)
     .sort((a, b) => a.childIndex - b.childIndex)
     .filter((a) => a.id !== currentPageId)
 
+  if (sorted.length === 0) return null
+
   return (
     <_ContextMenu.Root>
       <_ContextMenu.TriggerItem

components/canvas/shape.tsx

 import useShapeEvents from 'hooks/useShapeEvents'
 import vec from 'utils/vec'
 import { getShapeStyle } from 'lib/shape-styles'
-import ContextMenu from 'components/context-menu'
+import ContextMenu from 'components/canvas/context-menu/context-menu'
 
 interface ShapeProps {
   id: string

components/editor.tsx

 import { useSelector } from 'state'
 import styled from 'styles'
 import PagePanel from './page-panel/page-panel'
-import ContextMenu from './context-menu'
+import ContextMenu from './canvas/context-menu/context-menu'
 
 export default function Editor() {
   useKeyboardEvents()

components/shared.tsx

 import * as RadioGroup from '@radix-ui/react-radio-group'
 import * as Panel from './panel'
 import styled from 'styles'
-import Tooltip from './tooltip'
 
 export const IconButton = styled('button', {
   height: '32px',

state/commands/create-page.ts

 import { current } from 'immer'
 import storage from 'state/storage'
 
-export default function createPage(data: Data) {
+export default function createPage(data: Data, goToPage = true) {
   const snapshot = getSnapshot(data)
 
   history.execute(
       name: 'change_page',
       category: 'canvas',
       do(data) {
-        const { page, pageState } = snapshot
+        const { page, pageState, currentPageId } = snapshot
         data.document.pages[page.id] = page
         data.pageStates[page.id] = pageState
+
         data.currentPageId = page.id
         storage.savePage(data, data.document.id, page.id)
         storage.saveDocumentToLocalStorage(data)
+
+        if (goToPage) {
+          data.currentPageId = page.id
+        } else {
+          data.currentPageId = currentPageId
+        }
       },
       undo(data) {
         const { page, currentPageId } = snapshot
     childIndex: pages.length,
     shapes: {},
   }
+
   const pageState: PageState = {
     id,
     selectedIds: new Set([]),

state/state.ts

   setSelectedIds,
   getPageState,
   getShapes,
+  setToArray,
 } from 'utils/utils'
 import {
   Data,
       commands.changePage(data, payload.id)
     },
     createPage(data) {
-      commands.createPage(data)
+      commands.createPage(data, true)
     },
     deletePage(data, payload: { id: string }) {
       commands.deletePage(data, payload.id)
     },
-
     /* --------------------- Shapes --------------------- */
     resetShapes(data) {
       const page = getPage(data)