@dxos/react-ui-editor 0.8.4-main.5ad4a44 → 0.8.4-main.66e292d

package/src/components/EditorMenuProvider/popover.ts

@@ -0,0 +1,287 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { type Extension, Prec, RangeSetBuilder, StateEffect, StateField } from '@codemirror/state';
+import {
+  Decoration,
+  type DecorationSet,
+  EditorView,
+  type KeyBinding,
+  ViewPlugin,
+  type ViewUpdate,
+  keymap,
+} from '@codemirror/view';
+
+import { isNonNullable, isTruthy } from '@dxos/util';
+
+import { type PlaceholderOptions, modalStateField, placeholder } from '../../extensions';
+import { type Range } from '../../types';
+
+const DELIMITERS = [' ', ':'];
+
+export type PopoverOptions = {
+  trigger?: string | string[];
+  triggerKey?: string;
+  placeholder?: Partial<PlaceholderOptions>;
+  delimiters?: string[];
+
+  // TODO(burdon): Auto.
+  // activateOnTyping?: boolean;
+
+  // Trigger update.
+  onTextChange?: (event: { view: EditorView; pos: number; text: string; trigger?: string }) => void;
+  onClose?: (event: { view: EditorView }) => void;
+
+  // Menu specific.
+  onEnter?: (event: { view: EditorView }) => void;
+  onArrowUp?: (event: { view: EditorView }) => void;
+  onArrowDown?: (event: { view: EditorView }) => void;
+};
+
+/**
+ * Creates a popover that appears when the trigger character is inserted.
+ * This can be used for context menus or autocompletion.
+ */
+export const popover = (options: PopoverOptions = {}): Extension => {
+  return [
+    Prec.highest(popoverKeymap(options)),
+    popoverStateField,
+    popoverTriggerListener(options),
+    popoverAnchorDecoration(options),
+    modalStateField,
+    options.trigger &&
+      placeholder({
+        // TODO(burdon): Translations.
+        content: `Press '${Array.isArray(options.trigger) ? options.trigger[0] : options.trigger}' for commands`,
+        ...options.placeholder,
+      }),
+  ].filter(isTruthy);
+};
+
+/**
+ * Listen for selection and document changes.
+ */
+const popoverTriggerListener = (options: PopoverOptions) =>
+  EditorView.updateListener.of(({ view, docChanged }) => {
+    const { range: activeRange, trigger } = view.state.field(popoverStateField) ?? {};
+    if (!activeRange) {
+      return;
+    }
+
+    const text = view.state.doc.sliceString(activeRange.from, activeRange.to);
+    const selection = view.state.selection.main;
+    const shouldClose =
+      // Trigger deleted.
+      (trigger ? trigger !== text[0] : false) ||
+      // Whitespace in text.
+      /\s/.test(trigger ? text.slice(1) : text) ||
+      // Cursor moved before the range.
+      selection.head < activeRange.from ||
+      // Cursor moved after the range (+1 to handle selection changing before doc).
+      selection.head > activeRange.to + 1;
+
+    const nextRange = shouldClose ? null : docChanged ? { from: activeRange.from, to: selection.head } : activeRange;
+    if (nextRange !== activeRange) {
+      view.dispatch({
+        effects: popoverRangeEffect.of(nextRange ? { range: nextRange, trigger } : null),
+      });
+    }
+
+    if (shouldClose) {
+      options.onClose?.({ view });
+    }
+  });
+
+/**
+ * Popover navigation.
+ */
+const popoverKeymap = (options: PopoverOptions) => {
+  const triggers = Array.isArray(options.trigger) ? options.trigger : [options.trigger];
+  return keymap.of(
+    [
+      // Prefix triggers.
+      ...triggers.filter(isNonNullable).map((trigger) => ({
+        key: trigger,
+        run: (view: EditorView) => {
+          // Determine if we should trigger the popover:
+          // 1. Empty lines or at the beginning of a line.
+          // 2. When there's a preceding space.
+          const selection = view.state.selection.main;
+          const line = view.state.doc.lineAt(selection.head);
+          if (
+            line.text.trim() === '' ||
+            selection.head === line.from ||
+            (selection.head > line.from && line.text[selection.head - line.from - 1] === ' ')
+          ) {
+            // Insert and select the trigger.
+            view.dispatch({
+              changes: { from: selection.head, insert: trigger },
+              selection: { anchor: selection.head + 1, head: selection.head + 1 },
+              effects: popoverRangeEffect.of({ trigger, range: { from: selection.head, to: selection.head + 1 } }),
+            });
+
+            return true;
+          }
+
+          return false;
+        },
+      })),
+
+      //
+      // Custom trigger.
+      //
+      options.triggerKey &&
+        ({
+          key: options.triggerKey,
+          run: (view: EditorView) => {
+            const selection = view.state.selection.main;
+            const line = view.state.doc.lineAt(selection.head);
+
+            // Get last word.
+            let str = line.text.slice(0, selection.head - line.from);
+            const idx = getLastIndexOf(str, options.delimiters ?? DELIMITERS);
+            if (idx !== -1) {
+              str = str.slice(idx + 1);
+            }
+
+            // Create anchor even if zero length (append space).
+            const from = line.from + idx;
+            view.dispatch({
+              effects: popoverRangeEffect.of({ range: { from: from + 1, to: selection.head } }),
+              changes:
+                selection.head === view.state.doc.length
+                  ? { from: from + 1, to: selection.head, insert: ' ' }
+                  : undefined,
+            });
+            return true;
+          },
+        } satisfies KeyBinding),
+
+      //
+      // Nav keys.
+      //
+      {
+        key: 'ArrowUp',
+        run: (view: EditorView) => {
+          const range = view.state.field(popoverStateField)?.range;
+          if (range) {
+            options.onArrowUp?.({ view });
+            return true;
+          }
+
+          return false;
+        },
+      },
+      {
+        key: 'ArrowDown',
+        run: (view: EditorView) => {
+          const range = view.state.field(popoverStateField)?.range;
+          if (range) {
+            options.onArrowDown?.({ view });
+            return true;
+          }
+
+          return false;
+        },
+      },
+      {
+        key: 'Enter',
+        run: (view: EditorView) => {
+          const range = view.state.field(popoverStateField)?.range;
+          if (range) {
+            view.dispatch({ changes: { from: range.from, to: range.to, insert: '' } });
+            options.onEnter?.({ view });
+            return true;
+          }
+
+          return false;
+        },
+      },
+    ].filter(isTruthy),
+  );
+};
+
+/**
+ * Creates a <dx-anchor> tag, which is used to anchor the Popver.
+ */
+const popoverAnchorDecoration = (options: PopoverOptions) => {
+  return ViewPlugin.fromClass(
+    class {
+      _decorations: DecorationSet = Decoration.none;
+
+      constructor(readonly view: EditorView) {}
+
+      // TODO(wittjosiah): The decorations are repainted on every update, this occasionally causes menu to flicker.
+      update({ view, transactions }: ViewUpdate) {
+        const builder = new RangeSetBuilder<Decoration>();
+        const { range, trigger } = view.state.field(popoverStateField) ?? {};
+        if (range) {
+          // Check if we should show the widget (only if cursor is within the active command range).
+          const selection = view.state.selection.main;
+          const showWidget = selection.head >= range.from && selection.head <= range.to;
+          if (showWidget) {
+            builder.add(
+              range.from,
+              range.to + 1,
+              Decoration.mark({
+                tagName: 'dx-anchor',
+                class: 'cm-popover-trigger',
+                attributes: {
+                  'data-visible-focus': 'false',
+                  'data-auto-trigger': 'true',
+                  'data-trigger': trigger ?? options.triggerKey ?? '',
+                },
+              }),
+            );
+          }
+
+          const rangeChanged = transactions.some((tr) => tr.effects.some((effect) => effect.is(popoverRangeEffect)));
+          if (rangeChanged) {
+            // NOTE: Content skips the trigger character.
+            const content = view.state.sliceDoc(range.from + (trigger ? trigger.length : 0), range.to);
+            options.onTextChange?.({ view, pos: selection.head, text: content, trigger });
+          }
+        }
+
+        this._decorations = builder.finish();
+      }
+    },
+    {
+      decorations: (v) => v._decorations,
+    },
+  );
+};
+
+type PopoverState = {
+  /**
+   * Trigger prefix (in document).
+   */
+  trigger?: string;
+
+  /**
+   * Current document completion range.
+   */
+  range: Range;
+};
+
+// State effects for managing popover state.
+export const popoverRangeEffect = StateEffect.define<PopoverState | null>();
+
+// State field to track the active popover trigger range.
+export const popoverStateField = StateField.define<PopoverState | null>({
+  create: () => null,
+  update: (value, tr) => {
+    let newValue = value;
+    for (const effect of tr.effects) {
+      if (effect.is(popoverRangeEffect)) {
+        newValue = effect.value;
+      }
+    }
+
+    return newValue;
+  },
+});
+
+const getLastIndexOf = (str: string, delimiters: string[]) =>
+  Math.max(...delimiters.map((delim) => str.lastIndexOf(delim)));

package/src/components/EditorMenuProvider/useEditorMenu.ts

@@ -0,0 +1,175 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { type Extension } from '@codemirror/state';
+import { type EditorState } from '@codemirror/state';
+import { type RefObject, useCallback, useMemo, useRef, useState } from 'react';
+
+import { invariant } from '@dxos/invariant';
+import { type MaybePromise } from '@dxos/util';
+
+import { modalStateEffect } from '../../extensions';
+
+import { type EditorMenuProviderProps } from './EditorMenuProvider';
+import { type EditorMenuGroup, type EditorMenuItem } from './menu';
+import { filterMenuGroups, getMenuItem, getNextMenuItem, getPreviousMenuItem } from './menu';
+import { type PopoverOptions, popover, popoverRangeEffect, popoverStateField } from './popover';
+
+export type GetMenuContext = {
+  state: EditorState;
+  pos: number;
+  text: string;
+  trigger?: string;
+};
+
+export type UseEditorMenuProps = {
+  filter?: boolean;
+  getMenu?: (context: GetMenuContext) => MaybePromise<EditorMenuGroup[]>;
+} & Pick<PopoverOptions, 'trigger' | 'triggerKey' | 'placeholder'>;
+
+export type UseEditorMenu = {
+  groupsRef: RefObject<EditorMenuGroup[]>;
+  extension: Extension;
+} & Pick<EditorMenuProviderProps, 'currentItem' | 'open' | 'onOpenChange' | 'onActivate' | 'onSelect' | 'onCancel'>;
+
+/**
+ * ```tsx
+ * const { groupsRef, extension, ...menuProps } = useEditorMenu();
+ * const { parentRef, viewRef } = useTextEditor({ extensions: [extension] });
+ * return (
+ *   <EditorMenuProvider view={viewRef.current} groups={groupsRef.current} {...menuProps}>
+ *     <div ref={parentRef} />
+ *   </EditorMenuProvider>
+ * );
+ * ```
+ */
+export const useEditorMenu = ({
+  trigger,
+  triggerKey,
+  placeholder,
+  filter = true,
+  getMenu,
+}: UseEditorMenuProps): UseEditorMenu => {
+  const groupsRef = useRef<EditorMenuGroup[]>([]);
+  const currentRef = useRef<EditorMenuItem | null>(null);
+  const [currentItem, setCurrentItem] = useState<string>();
+  const [open, setOpen] = useState(false);
+  const [_, refresh] = useState({});
+
+  /**
+   * Get filtered options.
+   */
+  const getMenuOptions = useCallback<NonNullable<UseEditorMenuProps['getMenu']>>(
+    async ({ text, trigger, ...props }) => {
+      const groups = (await getMenu?.({ text, trigger, ...props })) ?? [];
+      return filter
+        ? filterMenuGroups(groups, (item) =>
+            text ? (item.label as string).toLowerCase().startsWith(text.toLowerCase()) : true,
+          )
+        : groups;
+    },
+    [getMenu, filter],
+  );
+
+  const handleOpenChange = useCallback<NonNullable<UseEditorMenu['onOpenChange']>>(
+    async ({ view, open }) => {
+      console.log(view, open);
+      invariant(view);
+      setOpen(open);
+      if (!open) {
+        setCurrentItem(undefined);
+        view.dispatch({
+          effects: [popoverRangeEffect.of(null)],
+        });
+      }
+
+      // TODO(burdon): Possible race condition.
+      //  useTextEditor.handleKeyDown will get called after this handler completes.
+      requestAnimationFrame(() => {
+        view.dispatch({
+          effects: [modalStateEffect.of(open)],
+        });
+      });
+    },
+    [getMenuOptions],
+  );
+
+  const handleActivate = useCallback<NonNullable<UseEditorMenu['onActivate']>>(
+    async ({ view, trigger }) => {
+      const item = getMenuItem(groupsRef.current, currentItem);
+      if (item) {
+        currentRef.current = item;
+      }
+
+      if (!open) {
+        handleOpenChange({ view, open: true, trigger });
+      }
+    },
+    [open, handleOpenChange],
+  );
+
+  const handleSelect = useCallback<NonNullable<UseEditorMenu['onSelect']>>(({ view, item }) => {
+    void item.onSelect?.({ view, head: view.state.selection.main.head });
+  }, []);
+
+  const handleCancel = useCallback<NonNullable<UseEditorMenu['onCancel']>>(({ view }) => {
+    // Delete trigger.
+    const { range, trigger } = view.state.field(popoverStateField) ?? {};
+    if (range && trigger) {
+      view.dispatch({
+        changes: { ...range, insert: '' },
+      });
+    }
+  }, []);
+
+  const serializedTrigger = Array.isArray(trigger) ? trigger.join(',') : trigger;
+  const extension = useMemo<Extension>(() => {
+    return popover({
+      trigger,
+      triggerKey,
+      placeholder,
+      onClose: ({ view }) => handleOpenChange({ view, open: false }),
+      onEnter: ({ view }) => {
+        if (currentRef.current) {
+          handleSelect({ view, item: currentRef.current });
+        }
+      },
+      onArrowUp: () => {
+        setCurrentItem((currentItem) => {
+          const previous = getPreviousMenuItem(groupsRef.current, currentItem);
+          currentRef.current = previous;
+          return previous.id;
+        });
+      },
+      onArrowDown: () => {
+        setCurrentItem((currentItem) => {
+          const next = getNextMenuItem(groupsRef.current, currentItem);
+          currentRef.current = next;
+          return next.id;
+        });
+      },
+      onTextChange: async ({ view, pos, text, trigger }) => {
+        groupsRef.current = (await getMenuOptions({ state: view.state, pos, text, trigger })) ?? [];
+        const firstItem = groupsRef.current.filter((group) => group.items.length > 0)[0]?.items[0];
+        if (firstItem) {
+          setCurrentItem(firstItem.id);
+          currentRef.current = firstItem;
+        }
+
+        refresh({});
+      },
+    });
+  }, [handleOpenChange, getMenuOptions, serializedTrigger, placeholder]);
+
+  return {
+    groupsRef,
+    extension,
+    currentItem,
+    open,
+    onOpenChange: handleOpenChange,
+    onActivate: handleActivate,
+    onSelect: handleSelect,
+    onCancel: handleCancel,
+  };
+};

package/src/components/EditorMenuProvider/util.ts

@@ -0,0 +1,31 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type EditorView } from '@codemirror/view';
+
+// TODO(burdon): Factor out.
+
+export const insertAtCursor = (view: EditorView, from: number, insert: string) => {
+  view.dispatch({
+    changes: { from, to: from, insert },
+    selection: { anchor: from + insert.length, head: from + insert.length },
+  });
+};
+
+/**
+ * If the cursor is at the start of a line, insert the text at the cursor.
+ * Otherwise, insert the text on a new line.
+ */
+export const insertAtLineStart = (view: EditorView, from: number, insert: string) => {
+  const line = view.state.doc.lineAt(from);
+  if (line.from === from) {
+    insertAtCursor(view, from, insert);
+  } else {
+    insert = '\n' + insert;
+    view.dispatch({
+      changes: { from: line.to, to: line.to, insert },
+      selection: { anchor: line.to + insert.length, head: line.to + insert.length },
+    });
+  }
+};

package/src/components/EditorPreviewProvider/EditorPreviewProvider.tsx

@@ -0,0 +1,82 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { createContext } from '@radix-ui/react-context';
+import React, { type PropsWithChildren, type RefObject, useCallback, useEffect, useRef, useState } from 'react';
+
+import { addEventListener } from '@dxos/async';
+import { DX_ANCHOR_ACTIVATE, type DxAnchorActivate, Popover } from '@dxos/react-ui';
+
+import { type PreviewLinkRef, type PreviewLinkTarget } from '../../extensions';
+
+type EditorPreviewPopoverValue = Partial<{
+  link: PreviewLinkRef;
+  target: PreviewLinkTarget;
+  pending: boolean;
+}>;
+
+const [EditorPreviewContextProvider, useEditorPreview] = createContext<EditorPreviewPopoverValue>('PreviewPopover', {});
+
+export type EditorPreviewProviderProps = PropsWithChildren<{
+  onLookup?: (link: PreviewLinkRef) => Promise<PreviewLinkTarget | null | undefined>;
+}>;
+
+/**
+ * NOTE: In Composer, the DeckPlugin provides the Popover.Root as part of the DeckLayout.
+ */
+// TOOD(burdon): Reconcile with PreviewPlugin.
+export const EditorPreviewProvider = ({ children, onLookup }: EditorPreviewProviderProps) => {
+  const triggerRef = useRef<HTMLElement | null>(null);
+  const [value, setValue] = useState<EditorPreviewPopoverValue>({});
+  const [open, setOpen] = useState(false);
+
+  const handleActivate = useCallback(
+    (event: DxAnchorActivate) => {
+      const { refId, label, trigger: dxTrigger } = event;
+      setValue((value) => ({
+        ...value,
+        link: { label, ref: refId },
+        pending: true,
+      }));
+
+      triggerRef.current = dxTrigger;
+      queueMicrotask(() => setOpen(true));
+      void onLookup?.({ label, ref: refId }).then((target) =>
+        setValue((value) => ({
+          ...value,
+          target: target ?? undefined,
+          pending: false,
+        })),
+      );
+    },
+    [onLookup],
+  );
+
+  const [root, setRoot] = useState<HTMLDivElement | null>(null);
+  useEffect(() => {
+    if (!root || !handleActivate) {
+      return;
+    }
+
+    return addEventListener(root, DX_ANCHOR_ACTIVATE as any, handleActivate, {
+      capture: true,
+      passive: false,
+    });
+  }, [root, handleActivate]);
+
+  return (
+    <EditorPreviewContextProvider pending={value.pending} link={value.link} target={value.target}>
+      <Popover.Root open={open} onOpenChange={setOpen}>
+        <Popover.VirtualTrigger virtualRef={triggerRef as unknown as RefObject<HTMLButtonElement>} />
+
+        {/* Content */}
+        <div ref={setRoot} role='none' className='contents'>
+          {children}
+        </div>
+      </Popover.Root>
+    </EditorPreviewContextProvider>
+  );
+};
+
+export { useEditorPreview };

package/src/components/EditorPreviewProvider/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './EditorPreviewProvider';