Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

5.8 KB
Raw Blame
import { createHotkeyGroup, registerHotkey } from '@core/hotkey/hotkeys';
import { TOKENS } from '@core/hotkey/tokens';
import type { HotkeyRegistrationOptions } from '@core/hotkey/types';
import { fireAndForget } from '@core/util/fireAndForget';
import { nudgeCommand, selectAllCommand } from '@macro-inc/graphics';
import { onCleanup } from 'solid-js';
import type { CanvasClipboard } from './clipboard';
import type { CanvasState } from './primitives/create-canvas-state';

export function registerCanvasNextHotkeys(
  scopeId: string,
  state: CanvasState,
  clipboard: CanvasClipboard,
  canEdit: () => boolean = () => true,
  onInsert?: () => void
) {
  const group = createHotkeyGroup(),
    editor = state.editor;
  const register = (
    hotkey: HotkeyRegistrationOptions['hotkey'],
    description: string,
    action: () => void,
    token?: HotkeyRegistrationOptions['hotkeyToken'],
    proxiedHotkey = false
  ) => {
    group.add(
      registerHotkey({
        scopeId,
        hotkey,
        hotkeyToken: token,
        description,
        proxiedHotkey,
        keyDownHandler: () => {
          if (!canEdit() || state.text.draft() || state.embeds.active())
            return false;
          action();
          return true;
        },
      })
    );
  };
  register(
    'v',
    'Selection tool',
    () => state.chooseTool('select'),
    TOKENS.canvas.selectTool
  );
  register(
    'r',
    'Rectangle tool',
    () => state.chooseTool('rectangle'),
    TOKENS.canvas.shapeTool
  );
  register('a', 'Arrow tool', () => state.chooseTool('arrow'));
  register('l', 'Line tool', () => state.chooseTool('line'));
  register('e', 'Eraser tool', () => state.chooseTool('eraser'));
  register('t', 'Text tool', () => state.chooseTool('text'));
  if (onInsert) register('i', 'Insert', onInsert);
  register('enter', 'Edit selected text', () => {
    const id = editor.getSession().selectedId;
    if (id) state.text.edit(id);
  });
  register('o', 'Ellipse tool', () => state.chooseTool('ellipse'));
  register(
    'p',
    'Pencil tool',
    () => state.chooseTool('pencil'),
    TOKENS.canvas.pencilTool
  );
  register(
    'h',
    'Hand tool',
    () => state.chooseTool('pan'),
    TOKENS.canvas.handTool
  );
  register(
    'cmd+a',
    'Select all',
    () => {
      state.chooseTool('select');
      editor.execute(selectAllCommand, undefined);
    },
    TOKENS.canvas.selectAll
  );
  register('cmd+d', 'Duplicate selection', state.duplicate);
  register(
    'cmd+c',
    'Copy selection',
    () => {
      fireAndForget(clipboard.copy(), 'canvas-clipboard');
    },
    TOKENS.canvas.copy,
    true
  );
  register(
    'cmd+x',
    'Cut selection',
    () => {
      fireAndForget(clipboard.cut(), 'canvas-clipboard');
    },
    TOKENS.canvas.cut,
    true
  );
  register(
    'cmd+v',
    'Paste shapes',
    () => {
      fireAndForget(clipboard.paste(), 'canvas-clipboard');
    },
    TOKENS.canvas.paste,
    true
  );
  register('cmd+z', 'Undo', editor.undo, TOKENS.canvas.undo);
  register(
    'shift+cmd+v',
    'Paste in place',
    () => {
      fireAndForget(clipboard.paste(true), 'canvas-clipboard');
    },
    undefined,
    true
  );
  register(['shift+cmd+z', 'cmd+y'], 'Redo', editor.redo, TOKENS.canvas.redo);
  register(
    ['delete', 'backspace'],
    'Delete selection',
    editor.deleteSelection,
    TOKENS.canvas.delete
  );
  register('cmd+g', 'Group selection', state.group, TOKENS.canvas.group);
  register(
    'shift+cmd+g',
    'Ungroup selection',
    state.ungroup,
    TOKENS.canvas.ungroup
  );
  register(
    ']',
    'Bring to front',
    () => editor.reorderSelection('front'),
    TOKENS.canvas.bringToFront
  );
  register(
    '[',
    'Send to back',
    () => editor.reorderSelection('back'),
    TOKENS.canvas.sendToBack
  );
  register(
    'opt+]',
    'Bring forward',
    () => editor.reorderSelection('forward'),
    TOKENS.canvas.bringForward
  );
  register(
    'opt+[',
    'Send backward',
    () => editor.reorderSelection('backward'),
    TOKENS.canvas.sendBackward
  );
  for (const [key, x, y] of [
    ['arrowleft', -1, 0],
    ['arrowright', 1, 0],
    ['arrowup', 0, -1],
    ['arrowdown', 0, 1],
  ] as const) {
    register(key, `Nudge ${key.slice(5)}`, () =>
      editor.execute(nudgeCommand, {
        x: x * (editor.getSnapUnit() ?? 1),
        y: y * (editor.getSnapUnit() ?? 1),
      })
    );
    register(`shift+${key}`, `Nudge ${key.slice(5)} by 10`, () =>
      editor.execute(nudgeCommand, {
        x: x * 10 * (editor.getSnapUnit() ?? 1),
        y: y * 10 * (editor.getSnapUnit() ?? 1),
      })
    );
  }
  register(
    'escape',
    'Clear selection / cancel',
    () => {
      state.chooseTool('select');
      editor.select();
    },
    TOKENS.canvas.cancel
  );
  // Surface also handles Escape and space-pan to release pointer capture.
  onCleanup(() => group.dispose());
}

export function registerCanvasZoomHotkeys(
  scopeId: string,
  state: CanvasState,
  zoom: (factor: number) => void,
  fit: () => void
) {
  const group = createHotkeyGroup();
  for (const [hotkey, description, factor, token] of [
    ['cmd+=', 'Zoom In', 1.2, TOKENS.canvas.zoomIn],
    ['cmd+-', 'Zoom Out', 1 / 1.2, TOKENS.canvas.zoomOut],
  ] as const) {
    group.add(
      registerHotkey({
        scopeId,
        hotkey,
        description,
        hotkeyToken: token,
        keyDownHandler: () => {
          if (state.text.draft() || state.embeds.active()) return false;
          zoom(factor);
          return true;
        },
      })
    );
  }
  group.add(
    registerHotkey({
      scopeId,
      hotkey: '.',
      description: 'Zoom to fit',
      hotkeyToken: TOKENS.canvas.zoomFit,
      keyDownHandler: () => {
        if (state.text.draft() || state.embeds.active()) return false;
        fit();
        return true;
      },
    })
  );
  onCleanup(() => group.dispose());
}