@dxos/react-ui-editor 0.8.4-main.dedc0f3 → 0.8.4-main.ead640a

package/src/extensions/outliner/outliner.ts

@@ -7,11 +7,11 @@ import { Decoration, type DecorationSet, EditorView, ViewPlugin, type ViewUpdate
 
 import { mx } from '@dxos/react-ui-theme';
 
-import { floatingMenu } from '../command';
 import { decorateMarkdown } from '../markdown';
 
 import { commands } from './commands';
 import { editor } from './editor';
+import { menu } from './menu';
 import { selectionCompartment, selectionEquals, selectionFacet } from './selection';
 import { outlinerTree, treeFacet } from './tree';
 
@@ -52,7 +52,7 @@ export const outliner = (_options: OutlinerProps = {}): Extension => [
   editor(),
 
   // Floating menu.
-  floatingMenu(),
+  menu(),
 
   // Line decorations.
   decorations(),
@@ -159,7 +159,7 @@ const decorations = () => [
       '.cm-list-item-focused': {
         borderColor: 'var(--dx-accentFocusIndicator)',
       },
-      '[data-has-focus] & .cm-list-item-selected': {
+      '&:focus-within .cm-list-item-selected': {
         borderColor: 'var(--dx-separator)',
       },
     }),

package/src/extensions/popover/PopoverMenuProvider.tsx

@@ -0,0 +1,221 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type EditorView } from '@codemirror/view';
+import { useControllableState } from '@radix-ui/react-use-controllable-state';
+import React, { Fragment, type PropsWithChildren, useCallback, useEffect, useRef, useState } from 'react';
+
+import { addEventListener } from '@dxos/async';
+import { invariant } from '@dxos/invariant';
+import {
+  type DxAnchorActivate,
+  Icon,
+  Popover,
+  toLocalizedString,
+  useDynamicRef,
+  useThemeContext,
+  useTranslation,
+} from '@dxos/react-ui';
+
+import { type PopoverMenuGroup, type PopoverMenuItem } from './menu';
+
+export type PopoverMenuProviderProps = PropsWithChildren<{
+  view?: EditorView | null;
+  groups: PopoverMenuGroup[];
+  currentItem?: string;
+  open?: boolean;
+  defaultOpen?: boolean;
+  numItems?: number;
+  onOpenChange?: (event: { view: EditorView; open: boolean; trigger?: string }) => void;
+  onActivate?: (event: { view: EditorView; trigger?: string }) => void;
+  onSelect?: (event: { view: EditorView; item: PopoverMenuItem }) => void;
+  onCancel?: (event: { view: EditorView }) => void;
+}>;
+
+/**
+ * Implements the Popover and listens for the `dx-anchor-activate` event from the
+ * `popover` extension's decoration.
+ *
+ * NOTE: We don't use DropdownMenu because the command menu needs to manage focus explicitly.
+ * I.e., focus must remain in the editor while displaying the menu (for type-ahead).
+ */
+export const PopoverMenuProvider = ({
+  children,
+  view,
+  groups,
+  currentItem,
+  open: openParam,
+  defaultOpen,
+  numItems = 8,
+  onOpenChange,
+  onActivate,
+  onSelect,
+  onCancel,
+}: PopoverMenuProviderProps) => {
+  const { tx } = useThemeContext();
+  const triggerRef = useRef<HTMLButtonElement | null>(null);
+  const [root, setRoot] = useState<HTMLDivElement | null>(null);
+  const viewRef = useDynamicRef(view);
+  const [open, setOpen] = useControllableState({
+    prop: openParam,
+    defaultProp: defaultOpen,
+    onChange: (open) => {
+      invariant(viewRef.current);
+      onOpenChange?.({ view: viewRef.current, open });
+    },
+  });
+
+  useEffect(() => {
+    if (!root) {
+      return;
+    }
+
+    // Listen for trigger.
+    return addEventListener(
+      root,
+      'dx-anchor-activate' as any,
+      (event: DxAnchorActivate) => {
+        const { trigger, refId } = event;
+        console.log('update', trigger, refId);
+
+        // If this has a `refId`, then it’s probably a URL or DXN and out of scope for this component.
+        if (!refId) {
+          triggerRef.current = trigger as HTMLButtonElement;
+          if (onActivate) {
+            onActivate({ view: viewRef.current!, trigger: trigger.getAttribute('data-trigger') ?? undefined });
+          } else {
+            requestAnimationFrame(() => setOpen(true));
+          }
+        }
+      },
+      {
+        capture: true,
+        passive: false,
+      },
+    );
+  }, [root, onActivate]);
+
+  const handleSelect = useCallback<NonNullable<MenuProps['onSelect']>>(
+    (item) => {
+      invariant(viewRef.current);
+      onSelect?.({ view: viewRef.current, item });
+    },
+    [viewRef, onSelect],
+  );
+
+  const menuGroups = groups.filter((group) => group.items.length > 0);
+
+  return (
+    <Popover.Root modal={false} open={open} onOpenChange={setOpen}>
+      <Popover.VirtualTrigger virtualRef={triggerRef} />
+      <Popover.Portal>
+        <Popover.Content
+          align='start'
+          classNames={tx('menu.content', 'menu--exotic-unfocusable', { elevation: 'positioned' }, [
+            'overflow-y-auto',
+            !menuGroups.length && 'hidden',
+          ])}
+          style={{
+            maxBlockSize: 36 * numItems + 10,
+          }}
+          /**
+           * NOTE: We keep the focus in the editor, but Radix routes escape key.
+           */
+          onEscapeKeyDown={() => {
+            // NOTE: Able to cancel if not in valid state.
+            // event.preventDefault();
+            onCancel?.({ view: view! });
+          }}
+          onOpenAutoFocus={(event) => event.preventDefault()}
+        >
+          <Popover.Viewport classNames={tx('menu.viewport', 'menu__viewport--exotic-unfocusable', {})}>
+            <Menu groups={menuGroups} currentItem={currentItem} onSelect={handleSelect} />
+          </Popover.Viewport>
+          <Popover.Arrow />
+        </Popover.Content>
+      </Popover.Portal>
+
+      <div ref={setRoot} role='none' className='contents'>
+        {children}
+      </div>
+    </Popover.Root>
+  );
+};
+
+//
+// Menu
+//
+
+type MenuProps = {
+  groups: PopoverMenuGroup[];
+} & Pick<MenuGroupProps, 'currentItem' | 'onSelect'>;
+
+const Menu = ({ groups, currentItem, onSelect }: MenuProps) => {
+  const { tx } = useThemeContext();
+  return (
+    <ul>
+      {groups.map((group, index) => (
+        <Fragment key={group.id}>
+          <MenuGroup group={group} currentItem={currentItem} onSelect={onSelect} />
+          {index < groups.length - 1 && <div className={tx('menu.separator', 'menu__item', {})} />}
+        </Fragment>
+      ))}
+    </ul>
+  );
+};
+
+type MenuGroupProps = {
+  group: PopoverMenuGroup;
+  currentItem?: string;
+} & Pick<MenuItemProps, 'onSelect'>;
+
+const MenuGroup = ({ group, currentItem, onSelect }: MenuGroupProps) => {
+  const { tx } = useThemeContext();
+  const { t } = useTranslation();
+
+  return (
+    <>
+      {group.label && (
+        <div className={tx('menu.groupLabel', 'menu__group__label', {})}>
+          <span>{toLocalizedString(group.label, t)}</span>
+        </div>
+      )}
+
+      {group.items.map((item) => (
+        <MenuItem key={item.id} item={item} current={currentItem === item.id} onSelect={onSelect} />
+      ))}
+    </>
+  );
+};
+
+type MenuItemProps = {
+  item: PopoverMenuItem;
+  current: boolean;
+  onSelect?: (item: PopoverMenuItem) => void;
+};
+
+const MenuItem = ({ item, current, onSelect }: MenuItemProps) => {
+  const { tx } = useThemeContext();
+  const { t } = useTranslation();
+
+  const listRef = useRef<HTMLLIElement>(null);
+  useEffect(() => {
+    if (current && listRef.current) {
+      listRef.current.scrollIntoView({ behavior: 'smooth', block: 'nearest' });
+    }
+  }, [current]);
+
+  const handleSelect = useCallback(() => onSelect?.(item), [item, onSelect]);
+
+  return (
+    <li
+      ref={listRef}
+      className={tx('menu.item', 'menu__item--exotic-unfocusable', {}, [current && 'bg-hoverSurface'])}
+      onClick={handleSelect}
+    >
+      {item.icon && <Icon icon={item.icon} size={5} />}
+      <span className='grow truncate'>{toLocalizedString(item.label, t)}</span>
+    </li>
+  );
+};

package/src/extensions/popover/index.ts

@@ -0,0 +1,12 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './menu';
+export * from './menu-presets';
+export * from './modal';
+export * from './popover';
+export * from './util';
+
+export * from './PopoverMenuProvider';
+export * from './usePopoverMenu';

package/src/extensions/popover/menu-presets.ts

@@ -0,0 +1,124 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { popoverRangeEffect } from '../../extensions';
+
+import { type PopoverMenuGroup } from './menu';
+import { insertAtLineStart } from './util';
+
+export const formattingCommands: PopoverMenuGroup = {
+  id: 'markdown',
+  label: 'Markdown',
+  items: [
+    {
+      id: 'heading-1',
+      label: 'Heading 1',
+      icon: 'ph--text-h-one--regular',
+      onSelect: (view, head) => insertAtLineStart(view, head, '# '),
+    },
+    {
+      id: 'heading-2',
+      label: 'Heading 2',
+      icon: 'ph--text-h-two--regular',
+      onSelect: (view, head) => insertAtLineStart(view, head, '## '),
+    },
+    {
+      id: 'heading-3',
+      label: 'Heading 3',
+      icon: 'ph--text-h-three--regular',
+      onSelect: (view, head) => insertAtLineStart(view, head, '### '),
+    },
+    {
+      id: 'heading-4',
+      label: 'Heading 4',
+      icon: 'ph--text-h-four--regular',
+      onSelect: (view, head) => insertAtLineStart(view, head, '#### '),
+    },
+    {
+      id: 'heading-5',
+      label: 'Heading 5',
+      icon: 'ph--text-h-five--regular',
+      onSelect: (view, head) => insertAtLineStart(view, head, '##### '),
+    },
+    {
+      id: 'heading-6',
+      label: 'Heading 6',
+      icon: 'ph--text-h-six--regular',
+      onSelect: (view, head) => insertAtLineStart(view, head, '###### '),
+    },
+    {
+      id: 'bullet-list',
+      label: 'Bullet List',
+      icon: 'ph--list-bullets--regular',
+      onSelect: (view, head) => insertAtLineStart(view, head, '- '),
+    },
+    {
+      id: 'numbered-list',
+      label: 'Numbered List',
+      icon: 'ph--list-numbers--regular',
+      onSelect: (view, head) => insertAtLineStart(view, head, '1. '),
+    },
+    {
+      id: 'task-list',
+      label: 'Task List',
+      icon: 'ph--list-checks--regular',
+      onSelect: (view, head) => insertAtLineStart(view, head, '- [ ] '),
+    },
+    {
+      id: 'quote',
+      label: 'Quote',
+      icon: 'ph--quotes--regular',
+      onSelect: (view, head) => insertAtLineStart(view, head, '> '),
+    },
+    {
+      id: 'code-block',
+      label: 'Code Block',
+      icon: 'ph--code-block--regular',
+      onSelect: (view, head) => insertAtLineStart(view, head, '```\n\n```'),
+    },
+    {
+      id: 'table',
+      label: 'Table',
+      icon: 'ph--table--regular',
+      onSelect: (view, head) => insertAtLineStart(view, head, '| | | |\n|---|---|---|\n| | | |'),
+    },
+  ],
+};
+
+export const linkSlashCommands: PopoverMenuGroup = {
+  id: 'link',
+  label: 'Link',
+  items: [
+    {
+      id: 'inline-link',
+      label: 'Inline link',
+      icon: 'ph--link--regular',
+      onSelect: (view, head) => {
+        view.dispatch({
+          changes: { from: head, insert: '@' },
+          selection: { anchor: head + 1, head: head + 1 },
+          effects: popoverRangeEffect.of({
+            trigger: '@',
+            range: { from: head, to: head + 1 },
+          }),
+        });
+      },
+    },
+    {
+      id: 'block-embed',
+      label: 'Block embed',
+      icon: 'ph--lego--regular',
+      onSelect: (view, head) => {
+        view.dispatch({
+          changes: { from: head, insert: '@@' },
+          selection: { anchor: head + 2, head: head + 2 },
+          effects: popoverRangeEffect.of({
+            trigger: '@',
+            range: { from: head, to: head + 2 },
+          }),
+        });
+      },
+    },
+  ],
+};

package/src/extensions/popover/menu.ts

@@ -0,0 +1,67 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type EditorView } from '@codemirror/view';
+
+import { type Label } from '@dxos/react-ui';
+import { type MaybePromise } from '@dxos/util';
+
+import { insertAtCursor } from './util';
+
+export type PopoverMenuGroup = {
+  id: string;
+  label?: Label;
+  items: PopoverMenuItem[];
+};
+
+export type PopoverMenuItem = {
+  id: string;
+  label: Label;
+  icon?: string;
+  onSelect?: (view: EditorView, head: number) => MaybePromise<void>;
+};
+
+export const getMenuItem = (groups: PopoverMenuGroup[], id?: string): PopoverMenuItem | undefined => {
+  return groups.flatMap((group) => group.items).find((item) => item.id === id);
+};
+
+export const getNextMenuItem = (groups: PopoverMenuGroup[], id?: string): PopoverMenuItem => {
+  const items = groups.flatMap((group) => group.items);
+  const index = items.findIndex((item) => item.id === id);
+  return index < items.length - 1 ? items[index + 1] : items[index];
+};
+
+export const getPreviousMenuItem = (groups: PopoverMenuGroup[], id?: string): PopoverMenuItem => {
+  const items = groups.flatMap((group) => group.items);
+  const index = items.findIndex((item) => item.id === id);
+  return index > 0 ? items[index - 1] : items[index];
+};
+
+export const createMenuGroup = ({
+  id = 'menu',
+  label,
+  items,
+}: {
+  id?: string;
+  label?: Label;
+  items: string[];
+}): PopoverMenuGroup => ({
+  id,
+  label,
+  items: items.map((item, i) => ({
+    id: `${id}-${i}`,
+    label: item,
+    onSelect: (view, head) => insertAtCursor(view, head, item),
+  })),
+});
+
+export const filterMenuGroups = (
+  groups: PopoverMenuGroup[],
+  filter: (item: PopoverMenuItem) => boolean,
+): PopoverMenuGroup[] => {
+  return groups.map((group) => ({
+    ...group,
+    items: group.items.filter(filter),
+  }));
+};

package/src/extensions/popover/modal.ts

@@ -0,0 +1,24 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { StateEffect, StateField } from '@codemirror/state';
+
+export const modalStateEffect = StateEffect.define<boolean>();
+
+/**
+ * Determines if a modal dialog (e.g., popover) is active.
+ */
+export const modalStateField = StateField.define<boolean>({
+  create: () => false,
+  update: (value, tr) => {
+    let newValue = value;
+    for (const effect of tr.effects) {
+      if (effect.is(modalStateEffect)) {
+        newValue = effect.value;
+      }
+    }
+
+    return newValue;
+  },
+});