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.

36.0 KB
Raw Blame
import {
  INSERT_HORIZONTAL_RULE_COMMAND,
  NODE_TRANSFORM,
  type NodeTransformType,
  type SelectionData,
  TRY_INSERT_EQUATION_COMMAND,
  TRY_INSERT_LINK_COMMAND,
  UNLINK_COMMAND,
} from '@core/component/LexicalMarkdown/plugins/';
import { CREATE_DRAFT_COMMENT_COMMAND } from '@core/component/LexicalMarkdown/plugins/comments/commentPlugin';
import { editorFocusSignal } from '@core/component/LexicalMarkdown/utils';
import { toast } from '@core/component/Toast/Toast';
import { ENABLE_MARKDOWN_COMMENTS } from '@core/constant/featureFlags';
import type { ValidHotkey } from '@core/hotkey/types';
import CaretDown from '@icon/system/regular/caret-down.svg';
import CaretRight from '@icon/system/regular/caret-right.svg';
import Check from '@icon/system/regular/check-square.svg';
import TextCode from '@icon/system/regular/code.svg';
import CodeBlock from '@icon/system/regular/code-block.svg';
import CornersIn from '@icon/system/regular/corners-in.svg';
import CornersOut from '@icon/system/regular/corners-out.svg';
import DotsThreeLarge from '@icon/system/regular/dots-three.svg';
import ThreeDots from '@icon/system/regular/dots-three.svg';
import MathIcon from '@icon/system/regular/function.svg';
import Grid from '@icon/system/regular/grid-four.svg';
import BrokenLinkIcon from '@icon/system/regular/link-break.svg';
import LinkIcon from '@icon/system/regular/link-simple.svg';
import ListBullets from '@icon/system/regular/list-bullets.svg';
import ListChecks from '@icon/system/regular/list-checks.svg';
import ListNumbers from '@icon/system/regular/list-numbers.svg';
import Minus from '@icon/system/regular/minus.svg';
import One from '@icon/system/regular/number-one.svg';
import TextHighlight from '@icon/system/regular/paint-roller.svg';
import PlusSquare from '@icon/system/regular/plus-square.svg';
import Quote from '@icon/system/regular/quotes.svg';
import TextAA from '@icon/system/regular/text-aa.svg';
import TextBold from '@icon/system/regular/text-b.svg';
import TextH from '@icon/system/regular/text-h.svg';
import TextH1 from '@icon/system/regular/text-h-one.svg';
import TextH3 from '@icon/system/regular/text-h-three.svg';
import TextH2 from '@icon/system/regular/text-h-two.svg';
import TextItalic from '@icon/system/regular/text-italic.svg';
import TextStriketrough from '@icon/system/regular/text-strikethrough.svg';
import TextSub from '@icon/system/regular/text-subscript.svg';
import TextSuper from '@icon/system/regular/text-superscript.svg';
import TextT from '@icon/system/regular/text-t.svg';
import TextUnderline from '@icon/system/regular/text-underline.svg';
import {
  $isTableCellNode,
  $isTableSelection,
  $mergeCells,
  $unmergeCell,
} from '@lexical/table';
import type { ElementName } from '@macro-inc/lexical-core';
import {
  Button,
  type ButtonSize,
  Dropdown,
  Hotkey,
  SingleSelectCheck,
  Toolbar,
} from '@ui';
import {
  $getSelection,
  COMMAND_PRIORITY_LOW,
  FOCUS_COMMAND,
  FORMAT_TEXT_COMMAND,
  type LexicalEditor,
  type TextFormatType,
} from 'lexical';
import {
  type Accessor,
  type Component,
  createEffect,
  createMemo,
  createSignal,
  For,
  type JSX,
  onCleanup,
  type ParentProps,
  Show,
} from 'solid-js';
import { Dynamic } from 'solid-js/web';
import { useMarkdownDocument } from '../context/markdown-document-context';
import { CommentButton } from './CommentButton';
import { MediaSelector } from './MediaSelector';
import { TableInsert } from './TableInsert';

function VerticalBar() {
  return <div class="w-px mx-1 h-full bg-edge"></div>;
}

type DropdownItemProps = {
  label: string;
  icon: Component<JSX.SvgSVGAttributes<SVGSVGElement>>;
  show: boolean;
  themeClass?: string;
  before?: JSX.Element;
};

export const NodeMenuOptions: Record<ElementName, DropdownItemProps> = {
  paragraph: {
    label: 'Body',
    icon: TextT,
    show: false,
    themeClass: '',
  },
  heading1: {
    label: 'Heading 1',
    icon: TextH1,
    show: true,
    themeClass: 'text-[1.15em] font-bold',
  },
  heading2: {
    label: 'Heading 2',
    icon: TextH2,
    show: true,
    themeClass: 'text-[1.07em] font-bold',
  },
  heading3: {
    label: 'Heading 3',
    icon: TextH3,
    show: true,
    themeClass: 'text-[1.03em] font-bold',
  },
  quote: { label: 'Quote', icon: Quote, show: true, themeClass: 'italic' },
  code: { label: 'Code', icon: CodeBlock, show: true, themeClass: 'font-mono' },
  'custom-code': {
    label: 'Code',
    icon: CodeBlock,
    show: false,
    themeClass: 'font-mono',
  },
  'list-bullet': {
    label: 'Bullet List',
    icon: ListBullets,
    show: true,
    before: <div class="bg-ink size-1.5 rounded-full ml-1.5 mr-3" />,
  },
  'list-number': {
    label: 'Numbered List',
    icon: ListNumbers,
    show: true,
    before: <One class="size-4 mr-2" />,
  },
  'list-check': {
    label: 'Checklist',
    icon: ListChecks,
    show: true,
    before: <Check class="size-4 mr-2" />,
  },
  link: { label: 'Link', icon: LinkIcon, show: false, themeClass: '' },
} as const;

type InlineFormat =
  | 'bold'
  | 'italic'
  | 'underline'
  | 'strikethrough'
  | 'highlight'
  | 'code'
  | 'superscript'
  | 'subscript';

const InlineIcons: Record<
  InlineFormat,
  Component<JSX.SvgSVGAttributes<SVGSVGElement>>
> = {
  bold: TextBold,
  italic: TextItalic,
  underline: TextUnderline,
  strikethrough: TextStriketrough,
  highlight: TextHighlight,
  code: TextCode,
  superscript: TextSuper,
  subscript: TextSub,
} as const;

const InlineShortcuts: Partial<Record<InlineFormat, ValidHotkey>> = {
  bold: 'cmd+b',
  italic: 'cmd+i',
  underline: 'cmd+u',
  strikethrough: 'shift+cmd+x',
  highlight: 'shift+cmd+h',
  code: 'cmd+e',
} as const;

const InlineLabels: Record<InlineFormat, string> = {
  bold: 'Bold',
  italic: 'Italic',
  underline: 'Underline',
  strikethrough: 'Strikethrough',
  highlight: 'Highlight',
  code: 'Inline code',
  superscript: 'Superscript',
  subscript: 'Subscript',
} as const;

const isInlineFormatActive = (
  selection: SelectionData | undefined,
  format: InlineFormat
) => !!selection?.[format];

const hasActiveInlineFormat = (
  selection: SelectionData | undefined,
  formats: InlineFormat[]
) => formats.some((format) => isInlineFormatActive(selection, format));

const isElementFormatActive = (
  selection: SelectionData | undefined,
  format: ElementName
) => !!selection?.elementsInRange?.has(format);

const hasActiveElementFormat = (
  selection: SelectionData | undefined,
  formats: ElementName[]
) => formats.some((format) => isElementFormatActive(selection, format));

const InlineFormatButton = (props: {
  format: InlineFormat;
  selection: () => SelectionData | undefined;
  onClick: (e: MouseEvent) => void;
  buttonIsDisabled: Accessor<boolean>;
  size?: ButtonSize;
}) => {
  const icon = InlineIcons[props.format];
  const isActive = () => isInlineFormatActive(props.selection(), props.format);
  return (
    <Button
      aria-label={InlineLabels[props.format]}
      tooltip={{
        content: InlineLabels[props.format],
        shortcut: InlineShortcuts[props.format],
      }}
      size={props.size ?? 'icon-sm'}
      variant={isActive() ? 'primary' : 'ghost'}
      onClick={(e: MouseEvent | KeyboardEvent) =>
        props.onClick(e as MouseEvent)
      }
      disabled={props.buttonIsDisabled()}
    >
      <Dynamic component={icon} class="size-4" />
    </Button>
  );
};

const InlineFormatMenuItem = (props: {
  format: InlineFormat;
  selection: () => SelectionData | undefined;
  onClick: () => void;
  buttonIsDisabled: Accessor<boolean>;
}) => {
  const icon = InlineIcons[props.format];
  const isActive = () => isInlineFormatActive(props.selection(), props.format);
  return (
    <Dropdown.Item
      onSelect={props.onClick}
      disabled={props.buttonIsDisabled()}
      class={isActive() ? 'text-ink' : ''}
      role="menuitemradio"
      aria-checked={isActive()}
    >
      <Dynamic component={icon} class="size-4 shrink-0" />
      <span class="flex-1 truncate">{InlineLabels[props.format]}</span>
      <Show when={InlineShortcuts[props.format]}>
        {(shortcut) => <Hotkey shortcut={shortcut()} theme="subtle" />}
      </Show>
      <SingleSelectCheck active={isActive()} />
    </Dropdown.Item>
  );
};

export const ElementFormatButton = (props: {
  format: ElementName;
  selection: () => SelectionData | undefined;
  onClick: (e: MouseEvent) => void;
  buttonIsDisabled: Accessor<boolean>;
  size?: ButtonSize;
}) => {
  const name = NodeMenuOptions[props.format]?.label || 'Body';
  const icon = NodeMenuOptions[props.format]?.icon;
  return (
    <Button
      tooltip={name}
      size={props.size ?? 'icon-sm'}
      variant={
        isElementFormatActive(props.selection(), props.format)
          ? 'primary'
          : 'ghost'
      }
      onClick={(e: MouseEvent | KeyboardEvent) =>
        props.onClick(e as MouseEvent)
      }
      disabled={props.buttonIsDisabled()}
    >
      <Dynamic component={icon} class="size-4" />
    </Button>
  );
};

const ElementFormatMenuItem = (
  props: ParentProps<{
    format: ElementName;
    selection: () => SelectionData | undefined;
    onClick: () => void;
    useIcon?: boolean;
    useStyle?: boolean;
    buttonIsDisabled: Accessor<boolean>;
  }>
) => {
  const name = NodeMenuOptions[props.format]?.label || 'Text';
  const themeClass = NodeMenuOptions[props.format]?.themeClass || '';
  const before = NodeMenuOptions[props.format]?.before;
  const isActive = () => isElementFormatActive(props.selection(), props.format);
  const inner = () => {
    if (props.useStyle) {
      return (
        <span class={themeClass + ' flex items-center gap-0 justify-start'}>
          {before}
          {name}
        </span>
      );
    }
    return <span>{name}</span>;
  };
  const icon = () =>
    props.useIcon ? NodeMenuOptions[props.format]?.icon : undefined;
  return (
    <Dropdown.Item
      onSelect={props.onClick}
      disabled={props.buttonIsDisabled()}
      class={isActive() ? 'text-ink' : ''}
      role="menuitemradio"
      aria-checked={isActive()}
    >
      <Show when={icon()}>
        {(IconComp) => (
          <Dynamic component={IconComp()} class="size-4 shrink-0" />
        )}
      </Show>
      <span class="flex-1 truncate">{inner()}</span>
      <SingleSelectCheck active={isActive()} />
    </Dropdown.Item>
  );
};

export function FormatTools(props: {
  withinPopup?: boolean;
  size?: ButtonSize;
  onRequestLink?: () => void;
}) {
  const { permissions, state } = useMarkdownDocument();
  const { md: mdData, error: editorError } = state.editor;
  const buttonSize = () => props.size ?? 'icon-sm';
  const editor = () => mdData.editor;
  const titleEditor = () => mdData.titleEditor;
  const selection = () => mdData.selection;
  const { isGenerating, generatedAndWaiting } = state.generation;

  const [editorHasFocus, setEditorHasFocus] = createSignal(false);
  const [, setTitleEditorHasFocus] = createSignal(false);

  const [moreOptionsOpen, setMoreOptionsOpen] = createSignal(false);

  const [lastFocusedEditor, setLastFocusedEditor] =
    createSignal<LexicalEditor>();

  const editAccess = permissions.canEdit;
  const canEdit = () => editAccess();

  const canComment = ENABLE_MARKDOWN_COMMENTS
    ? permissions.canComment
    : () => false;

  const buttonIsDisabled = createMemo(() => {
    return !(
      canEdit() &&
      !isGenerating() &&
      !generatedAndWaiting() &&
      editorError() === null
    );
  });
  const commentButtonIsDisabled = createMemo(() => {
    return !(
      canComment() &&
      !isGenerating() &&
      !generatedAndWaiting() &&
      editorError() === null
    );
  });
  const cleanups: Array<() => void> = [];

  function handleLink(e?: MouseEvent | KeyboardEvent) {
    e?.preventDefault();
    e?.stopPropagation();

    const currentEditor = editor();
    if (currentEditor === undefined) return;
    if (selection()?.hasLinks) {
      currentEditor.dispatchCommand(UNLINK_COMMAND, undefined);
      setTimeout(() => {
        currentEditor.focus();
      });
      return;
    }
    currentEditor.dispatchCommand(TRY_INSERT_LINK_COMMAND, undefined);
  }

  function handleInsertEquation() {
    const currentEditor = editor();
    if (currentEditor === undefined) return;
    currentEditor.dispatchCommand(TRY_INSERT_EQUATION_COMMAND, undefined);
  }

  function handleMergeCells() {
    editor()?.update(() => {
      const lexicalSelection = $getSelection();
      if (!$isTableSelection(lexicalSelection)) return;
      $mergeCells(lexicalSelection.getNodes().filter($isTableCellNode));
    });
  }

  function handleSplitCell() {
    editor()?.update(() => $unmergeCell());
  }

  createEffect(() => {
    const editor_ = editor();
    if (editor_ !== undefined) {
      cleanups.push(editorFocusSignal(editor_, setEditorHasFocus));
      cleanups.push(
        editor_.registerCommand(
          FOCUS_COMMAND,
          () => {
            setLastFocusedEditor(editor_);
            return false;
          },
          COMMAND_PRIORITY_LOW
        )
      );
    }
    const titleEditor_ = titleEditor();
    if (titleEditor_ !== undefined) {
      cleanups.push(editorFocusSignal(titleEditor_, setTitleEditorHasFocus));
      cleanups.push(
        titleEditor_.registerCommand(
          FOCUS_COMMAND,
          () => {
            setLastFocusedEditor(titleEditor_);
            return false;
          },
          COMMAND_PRIORITY_LOW
        )
      );
    }
  });

  onCleanup(() => {
    cleanups.forEach((cleanup) => cleanup());
  });

  function inlineFormat(format: TextFormatType): void {
    if (
      editorHasFocus() ||
      lastFocusedEditor() === editor() ||
      props.withinPopup
    ) {
      editor()?.dispatchCommand(FORMAT_TEXT_COMMAND, format);
    }
  }

  function nodeFormat(transform: NodeTransformType): void {
    if (
      editorHasFocus() ||
      lastFocusedEditor() === editor() ||
      props.withinPopup
    ) {
      const isActive = selection()?.elementsInRange?.has(transform);
      // If the node type is already active, transform to paragraph (normal text)
      const targetTransform = isActive ? 'paragraph' : transform;
      editor()?.dispatchCommand(NODE_TRANSFORM, targetTransform);
    }
  }

  const handleInsertComment = () => {
    const created = editor()?.dispatchCommand(
      CREATE_DRAFT_COMMENT_COMMAND,
      undefined
    );
    if (!created) {
      toast.failure('Please highlight text to comment.');
    }
  };
  const InlineFormats: InlineFormat[] = [
    'bold',
    'italic',
    'underline',
    'strikethrough',
    'highlight',
  ];

  const MainFormatOptions: ElementName[] = [
    'heading1',
    'heading2',
    'heading3',
    'paragraph',
    'code',
    'quote',
    'list-bullet',
    'list-number',
    'list-check',
  ];

  const FormatDropDown = (props: { buttonIsDisabled: Accessor<boolean> }) => {
    const [menuOpen, setMenuOpen] = createSignal(false);
    const isActive = () =>
      hasActiveInlineFormat(selection(), InlineFormats) ||
      hasActiveElementFormat(selection(), MainFormatOptions);
    return (
      <Dropdown open={menuOpen()} onOpenChange={setMenuOpen}>
        <Dropdown.Trigger
          variant={isActive() ? 'primary' : 'ghost'}
          size={buttonSize()}
          tooltip="Text Styles"
          disabled={buttonIsDisabled()}
          tabIndex={-1}
        >
          <TextAA class="size-3.5 touch:size-6 shrink-0 pointer-events-none" />
        </Dropdown.Trigger>
        <Dropdown.Content
          onCloseAutoFocus={() => {
            lastFocusedEditor()?.focus();
          }}
        >
          <Dropdown.Group>
            <div class="w-full flex gap-1 justify-center items-center">
              <For each={InlineFormats}>
                {(format) => (
                  <InlineFormatButton
                    format={format}
                    selection={selection}
                    onClick={(e) => {
                      e.preventDefault();
                      e.stopPropagation();
                      inlineFormat(format);
                      setMenuOpen(false);
                    }}
                    buttonIsDisabled={buttonIsDisabled}
                  />
                )}
              </For>
            </div>
          </Dropdown.Group>
          <Dropdown.Group>
            <For each={MainFormatOptions}>
              {(format) => (
                <ElementFormatMenuItem
                  format={format}
                  selection={selection}
                  onClick={() => {
                    nodeFormat(format);
                    setMenuOpen(false);
                  }}
                  useIcon={true}
                  buttonIsDisabled={props.buttonIsDisabled}
                />
              )}
            </For>
          </Dropdown.Group>
        </Dropdown.Content>
      </Dropdown>
    );
  };

  const InlineFormatPopDown = (props: {
    formats: InlineFormat[];
    buttonIsDisabled: Accessor<boolean>;
  }) => {
    const [menuOpen, setMenuOpen] = createSignal(false);
    const isActive = () => hasActiveInlineFormat(selection(), props.formats);
    return (
      <Dropdown open={menuOpen()} onOpenChange={setMenuOpen}>
        <Dropdown.Trigger
          variant={isActive() ? 'primary' : 'ghost'}
          size={buttonSize()}
          tooltip="Text Styles"
          disabled={props.buttonIsDisabled()}
          tabIndex={-1}
        >
          <TextAA class="size-3.5 touch:size-6 shrink-0 pointer-events-none" />
        </Dropdown.Trigger>
        <Show when={!props.buttonIsDisabled()}>
          <Dropdown.Content
            onCloseAutoFocus={() => {
              lastFocusedEditor()?.focus();
            }}
          >
            <Dropdown.Group>
              <div class="w-full flex gap-1 justify-center items-center">
                <For each={props.formats}>
                  {(format) => (
                    <InlineFormatButton
                      format={format}
                      selection={selection}
                      onClick={(e) => {
                        e.preventDefault();
                        e.stopPropagation();
                        inlineFormat(format);
                        setMenuOpen(false);
                      }}
                      buttonIsDisabled={buttonIsDisabled}
                    />
                  )}
                </For>
              </div>
            </Dropdown.Group>
          </Dropdown.Content>
        </Show>
      </Dropdown>
    );
  };

  // Text formatting dropdown for more options
  const InlineFormatMenu = (props: {
    excludes?: InlineFormat[];
    icon?: Component<JSX.SvgSVGAttributes<SVGSVGElement>>;
    label?: string;
    buttonIsDisabled: Accessor<boolean>;
  }) => (
    <Dropdown>
      <Dropdown.Trigger
        variant={
          hasActiveInlineFormat(
            selection(),
            (Object.keys(InlineIcons) as InlineFormat[]).filter(
              (format) => !props.excludes?.includes(format)
            )
          )
            ? 'primary'
            : 'ghost'
        }
        size={buttonSize()}
        tooltip={props.label ?? 'More Formats'}
        disabled={buttonIsDisabled()}
        tabIndex={-1}
      >
        <Dynamic component={props.icon ?? ThreeDots} />
      </Dropdown.Trigger>
      <Show when={!buttonIsDisabled()}>
        <Dropdown.Content
          onCloseAutoFocus={() => {
            lastFocusedEditor()?.focus();
          }}
        >
          <Dropdown.Group>
            <For each={Object.keys(InlineIcons)}>
              {(format) => (
                <Show when={!props.excludes?.includes(format as InlineFormat)}>
                  <InlineFormatMenuItem
                    format={format as InlineFormat}
                    selection={selection}
                    onClick={() => {
                      inlineFormat(format as InlineFormat);
                    }}
                    buttonIsDisabled={buttonIsDisabled}
                  />
                </Show>
              )}
            </For>
          </Dropdown.Group>
        </Dropdown.Content>
      </Show>
    </Dropdown>
  );

  const ElementFormatMenu = (props: {
    elements: ElementName[];
    icon?: Component<JSX.SvgSVGAttributes<SVGSVGElement>>;
    label?: string;
    buttonIsDisabled: Accessor<boolean>;
  }) => (
    <Dropdown>
      <Dropdown.Trigger
        variant={
          hasActiveElementFormat(selection(), props.elements)
            ? 'primary'
            : 'ghost'
        }
        size={buttonSize()}
        tooltip={props.label ?? 'More Formats'}
        disabled={buttonIsDisabled()}
        tabIndex={-1}
      >
        <Dynamic component={props.icon ?? ThreeDots} />
      </Dropdown.Trigger>
      <Show when={!buttonIsDisabled()}>
        <Dropdown.Content
          onCloseAutoFocus={() => {
            lastFocusedEditor()?.focus();
          }}
        >
          <Dropdown.Group>
            <For each={props.elements}>
              {(format) => (
                <ElementFormatMenuItem
                  format={format}
                  selection={selection}
                  onClick={() => {
                    nodeFormat(format);
                  }}
                  useIcon={true}
                  buttonIsDisabled={buttonIsDisabled}
                />
              )}
            </For>
          </Dropdown.Group>
        </Dropdown.Content>
      </Show>
    </Dropdown>
  );

  const FullWithElementButtons: ElementName[] = [
    'heading1',
    'heading2',
    'heading3',
    'list-bullet',
    'list-number',
    'list-check',
    'code',
    'quote',
  ];

  // The inline formats that aren't surfaced as their own buttons, tucked
  // behind a "..." trigger that opens them as a horizontal row of buttons.
  const MoreInlineFormats: InlineFormat[] = [
    'underline',
    'strikethrough',
    'highlight',
    'code',
    'superscript',
    'subscript',
  ];
  const MoreInlineDropdown = () => {
    const [moreInlineOpen, setMoreInlineOpen] = createSignal(false);
    return (
      <Dropdown open={moreInlineOpen()} onOpenChange={setMoreInlineOpen}>
        <Dropdown.Trigger
          variant="ghost"
          size={buttonSize()}
          tooltip="More formatting"
          disabled={buttonIsDisabled()}
          tabIndex={-1}
        >
          <DotsThreeLarge class="size-3.5 touch:size-6 shrink-0 pointer-events-none" />
        </Dropdown.Trigger>
        <Show when={!buttonIsDisabled()}>
          <Dropdown.Content
            onCloseAutoFocus={() => {
              lastFocusedEditor()?.focus();
            }}
          >
            <Dropdown.Group>
              <div class="flex items-center gap-1">
                <For each={MoreInlineFormats}>
                  {(format) => (
                    <InlineFormatButton
                      format={format}
                      selection={selection}
                      onClick={(e) => {
                        e.preventDefault();
                        e.stopPropagation();
                        inlineFormat(format);
                      }}
                      buttonIsDisabled={buttonIsDisabled}
                    />
                  )}
                </For>
              </div>
            </Dropdown.Group>
          </Dropdown.Content>
        </Show>
      </Dropdown>
    );
  };

  // A single "Text" trigger that opens the block-level style menu
  // (paragraph, headings, lists, code, quote), used by the selection popup.
  // Reflects the selected block when the selection is a single block type.
  const TextBlockDropdown = () => {
    const [textMenuOpen, setTextMenuOpen] = createSignal(false);
    const blockFormats: ElementName[] = [
      'paragraph',
      'heading1',
      'heading2',
      'heading3',
      'list-bullet',
      'list-number',
      'list-check',
      'code',
      'quote',
    ];
    const currentBlockLabel = () => {
      const active = blockFormats.filter((format) =>
        isElementFormatActive(selection(), format)
      );
      return active.length === 1
        ? (NodeMenuOptions[active[0]]?.label ?? 'Text')
        : 'Text';
    };
    return (
      <Dropdown open={textMenuOpen()} onOpenChange={setTextMenuOpen}>
        <Dropdown.Trigger
          variant="ghost"
          size="sm"
          class="gap-1"
          tooltip="Text style"
          disabled={buttonIsDisabled()}
          tabIndex={-1}
        >
          {currentBlockLabel()}
          <CaretDown class="size-3" />
        </Dropdown.Trigger>
        <Show when={!buttonIsDisabled()}>
          <Dropdown.Content
            class="text-xs"
            onCloseAutoFocus={() => {
              lastFocusedEditor()?.focus();
            }}
          >
            <Dropdown.Group>
              <For each={blockFormats}>
                {(format) => (
                  <ElementFormatMenuItem
                    format={format}
                    selection={selection}
                    onClick={() => {
                      nodeFormat(format);
                      setTextMenuOpen(false);
                    }}
                    useIcon={true}
                    useStyle={false}
                    buttonIsDisabled={buttonIsDisabled}
                  />
                )}
              </For>
            </Dropdown.Group>
          </Dropdown.Content>
        </Show>
      </Dropdown>
    );
  };

  if (props.withinPopup) {
    return (
      <div class="flex h-full items-center gap-1">
        <Show when={canEdit()}>
          <InlineFormatButton
            format="bold"
            selection={selection}
            onClick={(e) => {
              e.preventDefault();
              e.stopPropagation();
              inlineFormat('bold');
            }}
            buttonIsDisabled={buttonIsDisabled}
            size={buttonSize()}
          />
          <InlineFormatButton
            format="italic"
            selection={selection}
            onClick={(e) => {
              e.preventDefault();
              e.stopPropagation();
              inlineFormat('italic');
            }}
            buttonIsDisabled={buttonIsDisabled}
            size={buttonSize()}
          />
          <Button
            variant="ghost"
            size={buttonSize()}
            onPointerDown={(e: PointerEvent) => e.preventDefault()}
            onClick={(e) => {
              if (!selection()?.hasLinks && props.onRequestLink) {
                e.preventDefault();
                e.stopPropagation();
                props.onRequestLink();
              } else {
                handleLink(e);
              }
            }}
            tooltip={selection()?.hasLinks ? 'Remove Link' : 'Insert Link'}
            disabled={buttonIsDisabled()}
          >
            <Dynamic
              component={selection()?.hasLinks ? BrokenLinkIcon : LinkIcon}
              class="size-4"
            />
          </Button>
          <MoreInlineDropdown />
          <Toolbar.Divider />
          <TextBlockDropdown />
          <Show when={selection()?.onMergableCells}>
            <Button
              variant="ghost"
              size={buttonSize()}
              tooltip="Merge cells"
              onClick={handleMergeCells}
              disabled={buttonIsDisabled()}
            >
              <CornersIn class="size-3.5 touch:size-6 shrink-0 pointer-events-none" />
            </Button>
          </Show>
          <Show when={selection()?.onSplittableCells}>
            <Button
              variant="ghost"
              size={buttonSize()}
              tooltip="Split cell"
              onClick={handleSplitCell}
              disabled={buttonIsDisabled()}
            >
              <CornersOut class="size-3.5 touch:size-6 shrink-0 pointer-events-none" />
            </Button>
          </Show>
        </Show>
      </div>
    );
  } else {
    return (
      <>
        <Show when={canEdit()}>
          {/* ------------ Full width breakpoint ----------- */}
          <div class="hidden @4xl:flex h-full flex-nowrap">
            <div class="flex h-full gap-1">
              <For each={FullWithElementButtons}>
                {(format) => (
                  <ElementFormatButton
                    format={format}
                    selection={selection}
                    onClick={(e) => {
                      e.preventDefault();
                      e.stopPropagation();
                      nodeFormat(format);
                    }}
                    buttonIsDisabled={buttonIsDisabled}
                  />
                )}
              </For>
              {/* <IconButton */}
              {/*   icon={TextSlash} */}
              {/*   theme="clear" */}
              {/*   tooltip={{ label: 'Clear Formatting' }} */}
              {/*   onClick={(e) => { */}
              {/*     e.preventDefault(); */}
              {/*     e.stopPropagation(); */}
              {/*     nodeFormat('paragraph'); */}
              {/*   }} */}
              {/* /> */}
            </div>
            <VerticalBar />
            <div class="flex h-full gap-1">
              <For each={['bold', 'italic', 'underline']}>
                {(format) => (
                  <InlineFormatButton
                    format={format as InlineFormat}
                    selection={selection}
                    onClick={(e) => {
                      e.preventDefault();
                      e.stopPropagation();
                      inlineFormat(format as InlineFormat);
                    }}
                    buttonIsDisabled={buttonIsDisabled}
                  />
                )}
              </For>
              <InlineFormatMenu
                excludes={['bold', 'italic', 'underline']}
                buttonIsDisabled={buttonIsDisabled}
              />
            </div>
          </div>

          {/* ------------ Medium width breakpoint ----------- */}
          <div class="hidden @xl:flex @4xl:hidden h-full">
            <div class="flex h-full gap-1">
              <ElementFormatMenu
                elements={['heading1', 'heading2', 'heading3']}
                icon={TextH}
                label="Headings"
                buttonIsDisabled={buttonIsDisabled}
              />
              <ElementFormatMenu
                elements={['list-bullet', 'list-number', 'list-check']}
                icon={ListBullets}
                label="Lists"
                buttonIsDisabled={buttonIsDisabled}
              />
              <ElementFormatButton
                format="code"
                selection={selection}
                onClick={(e) => {
                  e.preventDefault();
                  e.stopPropagation();
                  nodeFormat('code');
                }}
                buttonIsDisabled={buttonIsDisabled}
              />
              {/* <IconButton */}
              {/*   icon={TextSlash} */}
              {/*   theme="clear" */}
              {/*   tooltip={{ label: 'Clear Formatting' }} */}
              {/*   onClick={(e) => { */}
              {/*     e.preventDefault(); */}
              {/*     e.stopPropagation(); */}
              {/*     nodeFormat('paragraph'); */}
              {/*   }} */}
              {/* /> */}
            </div>
            <VerticalBar />
            <InlineFormatPopDown
              formats={[
                'bold',
                'italic',
                'underline',
                'strikethrough',
                'code',
                'superscript',
                'subscript',
              ]}
              buttonIsDisabled={buttonIsDisabled}
            />
          </div>

          {/* ------------ Small/mobile breakpoint ----------- */}
          <div class="flex h-full @xl:hidden">
            <FormatDropDown buttonIsDisabled={buttonIsDisabled} />
          </div>
          <VerticalBar />

          {/* ------------ Visible at all breakpoints ----------- */}
          <div class="flex gap-1 h-full">
            <Button
              variant="ghost"
              size="icon-sm"
              onPointerDown={(e: PointerEvent) => e.preventDefault()}
              onClick={handleLink}
              tooltip={selection()?.hasLinks ? 'Remove Link' : 'Insert Link'}
              disabled={buttonIsDisabled()}
            >
              <Dynamic
                component={selection()?.hasLinks ? BrokenLinkIcon : LinkIcon}
                class="size-4"
              />
            </Button>
            <MediaSelector buttonIsDisabled={buttonIsDisabled} />
            <Show when={ENABLE_MARKDOWN_COMMENTS}>
              <CommentButton
                onClick={handleInsertComment}
                disabled={commentButtonIsDisabled()}
              />
            </Show>
            <VerticalBar />
            <Dropdown
              open={moreOptionsOpen()}
              onOpenChange={setMoreOptionsOpen}
            >
              <Dropdown.Trigger
                variant="ghost"
                size="icon-sm"
                tooltip="More"
                disabled={buttonIsDisabled()}
                tabIndex={-1}
              >
                <PlusSquare class="size-3.5 touch:size-6 shrink-0 pointer-events-none" />
              </Dropdown.Trigger>
              <Show when={!buttonIsDisabled()}>
                <Dropdown.Content
                  onCloseAutoFocus={() => {
                    lastFocusedEditor()?.focus();
                  }}
                >
                  <Dropdown.Group>
                    <Dropdown.Item
                      onSelect={() => {
                        setMoreOptionsOpen(false);
                        nodeFormat('quote');
                      }}
                      disabled={buttonIsDisabled()}
                    >
                      <Quote class="size-4 shrink-0" />
                      <span class="flex-1 truncate">Block Quote</span>
                    </Dropdown.Item>
                  </Dropdown.Group>
                  <Dropdown.Group>
                    <Dropdown.Item
                      onSelect={() => {
                        setMoreOptionsOpen(false);
                        editor()?.dispatchCommand(
                          INSERT_HORIZONTAL_RULE_COMMAND,
                          undefined
                        );
                      }}
                      disabled={buttonIsDisabled()}
                    >
                      <Minus class="size-4 shrink-0" />
                      <span class="flex-1 truncate">Divider</span>
                    </Dropdown.Item>
                    <Dropdown.Item
                      onSelect={() => {
                        setMoreOptionsOpen(false);
                        handleInsertEquation();
                      }}
                      disabled={buttonIsDisabled()}
                    >
                      <MathIcon class="size-4 shrink-0" />
                      <span class="flex-1 truncate">Equation</span>
                    </Dropdown.Item>
                    <Dropdown.Sub>
                      <Dropdown.SubTrigger disabled={buttonIsDisabled()}>
                        <Grid class="size-4 shrink-0" />
                        <span class="flex-1 truncate">Table</span>
                        <CaretRight class="size-3.5" />
                      </Dropdown.SubTrigger>
                      <Dropdown.SubContent>
                        <Dropdown.Group>
                          <TableInsert
                            onMenuClose={() => setMoreOptionsOpen(false)}
                          />
                        </Dropdown.Group>
                      </Dropdown.SubContent>
                    </Dropdown.Sub>
                  </Dropdown.Group>
                </Dropdown.Content>
              </Show>
            </Dropdown>
          </div>

          {/* spacer before the AI button */}
          <div class="w-4"></div>
        </Show>
        <Show when={ENABLE_MARKDOWN_COMMENTS && canComment() && !canEdit()}>
          <CommentButton
            onClick={handleInsertComment}
            disabled={commentButtonIsDisabled()}
          />
        </Show>
      </>
    );
  }
}

// function ActionItem(props: {
//   text: string;
//   icon?: Component<any>;
//   onClick: () => void;
//   onClickNoBubble?: boolean;
//   shortcut?: string;
//   disabled?: boolean;
// }) {
//   return (
//     <MenuItem
//       text={props.text}
//       icon={props.icon}
//       onClick={props.onClick}
//       disabled={props.disabled}
//     />
//   );
// }

// function ActionItemWithShortcut(props: {
//   text: string;
//   icon?: Component<any>;
//   onClick: () => void;
//   onClickNoBubble?: boolean;
//   shortcut?: string;
//   disabled?: boolean;
// }) {
//   return (
//     <MenuItem
//       text={props.text}
//       icon={props.icon}
//       onClick={props.onClick}
//       disabled={props.disabled}
//     />
//   );
// }