@dxos/react-ui-editor 0.8.4-main.72ec0f3 → 0.8.4-main.765dc60934

package/src/components/EditorMenuProvider/EditorMenuProvider.tsx

@@ -13,6 +13,7 @@ import {
   type DxAnchorActivate,
   Icon,
   Popover,
+  ScrollArea,
   toLocalizedString,
   useDynamicRef,
   useThemeContext,
@@ -35,9 +36,7 @@ export type EditorMenuProviderProps = PropsWithChildren<{
 }>;
 
 /**
- * Implements the Popover and listens for the `dx-anchor-activate` event from the
- * `popover` extension's decoration.
- *
+ * 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).
  */
@@ -46,7 +45,7 @@ export const EditorMenuProvider = ({
   view,
   groups,
   currentItem,
-  open: openParam,
+  open: openProp,
   defaultOpen,
   numItems = 8,
   onOpenChange,
@@ -59,7 +58,7 @@ export const EditorMenuProvider = ({
 
   const viewRef = useDynamicRef(view);
   const [open, setOpen] = useControllableState({
-    prop: openParam,
+    prop: openProp,
     defaultProp: defaultOpen,
     onChange: (open) => {
       invariant(viewRef.current);
@@ -78,10 +77,8 @@ export const EditorMenuProvider = ({
       root,
       DX_ANCHOR_ACTIVATE as any,
       (event: DxAnchorActivate) => {
-        const { trigger, refId } = event;
-
-        // If this has a `refId`, then it’s probably a URL or DXN and out of scope for this component.
-        if (!refId) {
+        const { trigger, dxn } = event;
+        if (!dxn) {
           triggerRef.current = trigger as HTMLButtonElement;
           if (onActivate) {
             onActivate({ view: viewRef.current!, trigger: trigger.getAttribute('data-trigger') ?? undefined });
@@ -115,32 +112,32 @@ export const EditorMenuProvider = ({
       <Popover.Portal>
         <Popover.Content
           align='start'
-          classNames={tx('menu.content', 'menu--exotic-unfocusable', { elevation: 'positioned' }, [
-            'overflow-y-auto',
-            !menuGroups.length && 'hidden',
-          ])}
+          classNames={['flex flex-col', !menuGroups.length && 'hidden']}
           style={{
             maxBlockSize: 36 * numItems + 10,
           }}
-          /**
-           * NOTE: We keep the focus in the editor, but Radix routes escape key.
-           */
+          // 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! });
+            const currentView = viewRef.current;
+            if (currentView) {
+              onCancel?.({ view: currentView });
+            }
           }}
           onOpenAutoFocus={(event) => event.preventDefault()}
         >
-          <Popover.Viewport classNames={tx('menu.viewport', 'menu__viewport--exotic-unfocusable', {})}>
-            <Menu groups={menuGroups} currentItem={currentItem} onSelect={handleSelect} />
+          <Popover.Viewport asChild classNames='dx-container'>
+            <ScrollArea.Root thin>
+              <ScrollArea.Viewport>
+                <Menu groups={menuGroups} currentItem={currentItem} onSelect={handleSelect} />
+              </ScrollArea.Viewport>
+            </ScrollArea.Root>
           </Popover.Viewport>
           <Popover.Arrow />
         </Popover.Content>
       </Popover.Portal>
 
       {/* Content */}
-      <div ref={setRoot} role='none' className='contents'>
+      <div className='contents' ref={setRoot}>
         {children}
       </div>
     </Popover.Root>
@@ -162,7 +159,7 @@ const Menu = ({ groups, currentItem, onSelect }: MenuProps) => {
       {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', {})} />}
+          {index < groups.length - 1 && <div className={tx('menu.separator', {})} />}
         </Fragment>
       ))}
     </ul>
@@ -185,7 +182,7 @@ const MenuGroup = ({ group, currentItem, onSelect }: MenuGroupProps) => {
   return (
     <>
       {group.label && (
-        <div className={tx('menu.groupLabel', 'menu__group__label', {})}>
+        <div className={tx('menu.groupLabel', {})}>
           <span>{toLocalizedString(group.label, t)}</span>
         </div>
       )}
@@ -221,12 +218,8 @@ const MenuItem = ({ item, current, onSelect }: MenuItemProps) => {
   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} />}
+    <li ref={listRef} className={tx('menu.item', {}, [current && 'bg-hover-surface'])} onClick={handleSelect}>
+      {item.icon && <Icon icon={item.icon} />}
       <span className='grow truncate'>{toLocalizedString(item.label, t)}</span>
     </li>
   );

package/src/components/EditorMenuProvider/index.ts

@@ -5,7 +5,6 @@
 export * from './menu';
 export * from './menu-presets';
 export * from './popover';
-export * from './util';
 
 export * from './EditorMenuProvider';
 export * from './useEditorMenu';

package/src/components/EditorMenuProvider/menu-presets.ts

@@ -2,9 +2,10 @@
 // Copyright 2025 DXOS.org
 //
 
+import { insertAtLineStart } from '@dxos/ui-editor';
+
 import { type EditorMenuGroup } from './menu';
 import { popoverRangeEffect } from './popover';
-import { insertAtLineStart } from './util';
 
 export const formattingCommands: EditorMenuGroup = {
   id: 'markdown',
@@ -109,6 +110,7 @@ export const linkSlashCommands: EditorMenuGroup = {
       label: 'Block embed',
       icon: 'ph--lego--regular',
       onSelect: ({ view, head }) => {
+        // Seed the same query shape as typing "@@" manually.
         view.dispatch({
           changes: { from: head, insert: '@@' },
           selection: { anchor: head + 2, head: head + 2 },

package/src/components/EditorMenuProvider/menu.ts

@@ -5,10 +5,9 @@
 import { type EditorView } from '@codemirror/view';
 
 import { type Label } from '@dxos/react-ui';
+import { insertAtCursor } from '@dxos/ui-editor';
 import { type MaybePromise } from '@dxos/util';
 
-import { insertAtCursor } from './util';
-
 export type EditorMenuGroup = {
   id: string;
   label?: Label;

package/src/components/EditorMenuProvider/popover.ts

@@ -13,11 +13,10 @@ import {
   keymap,
 } from '@codemirror/view';
 
+import { type PlaceholderOptions, modalStateField, placeholder } from '@dxos/ui-editor';
+import { type Range } from '@dxos/ui-editor/types';
 import { isNonNullable, isTruthy } from '@dxos/util';
 
-import { type PlaceholderOptions, modalStateField, placeholder } from '../../extensions';
-import { type Range } from '../../types';
-
 const DELIMITERS = [' ', ':'];
 
 export type PopoverOptions = {
@@ -54,6 +53,7 @@ export const popover = (options: PopoverOptions = {}): Extension => {
       placeholder({
         // TODO(burdon): Translations.
         content: `Press '${Array.isArray(options.trigger) ? options.trigger[0] : options.trigger}' for commands`,
+        focusOnly: true,
         ...options.placeholder,
       }),
   ].filter(isTruthy);

package/src/components/EditorMenuProvider/useEditorMenu.ts

@@ -7,10 +7,9 @@ import { type EditorState } from '@codemirror/state';
 import { type RefObject, useCallback, useMemo, useRef, useState } from 'react';
 
 import { invariant } from '@dxos/invariant';
+import { modalStateEffect } from '@dxos/ui-editor';
 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';
@@ -63,7 +62,8 @@ export const useEditorMenu = ({
   const getMenuOptions = useCallback<NonNullable<UseEditorMenuProps['getMenu']>>(
     async ({ text, trigger, ...props }) => {
       const groups = (await getMenu?.({ text, trigger, ...props })) ?? [];
-      return filter
+      // The "@" menu can use "@@" as syntax for block embeds, so it owns its own query filtering.
+      return filter && trigger !== '@'
         ? filterMenuGroups(groups, (item) =>
             text ? (item.label as string).toLowerCase().startsWith(text.toLowerCase()) : true,
           )
@@ -74,7 +74,6 @@ export const useEditorMenu = ({
 
   const handleOpenChange = useCallback<NonNullable<UseEditorMenu['onOpenChange']>>(
     async ({ view, open }) => {
-      console.log(view, open);
       invariant(view);
       setOpen(open);
       if (!open) {
@@ -110,7 +109,13 @@ export const useEditorMenu = ({
   );
 
   const handleSelect = useCallback<NonNullable<UseEditorMenu['onSelect']>>(({ view, item }) => {
+    // Delete trigger range (e.g., "/" and any typed filter text).
+    const { range } = view.state.field(popoverStateField) ?? {};
+    if (range) {
+      view.dispatch({ changes: { from: range.from, to: range.to, insert: '' } });
+    }
     void item.onSelect?.({ view, head: view.state.selection.main.head });
+    view.focus();
   }, []);
 
   const handleCancel = useCallback<NonNullable<UseEditorMenu['onCancel']>>(({ view }) => {

package/src/components/EditorPreviewProvider/EditorPreviewProvider.tsx

@@ -7,8 +7,7 @@ import React, { type PropsWithChildren, type RefObject, useCallback, useEffect,
 
 import { addEventListener } from '@dxos/async';
 import { DX_ANCHOR_ACTIVATE, type DxAnchorActivate, Popover } from '@dxos/react-ui';
-
-import { type PreviewLinkRef, type PreviewLinkTarget } from '../../extensions';
+import { type PreviewLinkRef, type PreviewLinkTarget } from '@dxos/ui-editor';
 
 type EditorPreviewPopoverValue = Partial<{
   link: PreviewLinkRef;
@@ -33,16 +32,16 @@ export const EditorPreviewProvider = ({ children, onLookup }: EditorPreviewProvi
 
   const handleActivate = useCallback(
     (event: DxAnchorActivate) => {
-      const { refId, label, trigger: dxTrigger } = event;
+      const { dxn, label, trigger } = event;
       setValue((value) => ({
         ...value,
-        link: { label, ref: refId },
+        link: { label, dxn },
         pending: true,
       }));
 
-      triggerRef.current = dxTrigger;
+      triggerRef.current = trigger;
       queueMicrotask(() => setOpen(true));
-      void onLookup?.({ label, ref: refId }).then((target) =>
+      void onLookup?.({ label, dxn }).then((target) =>
         setValue((value) => ({
           ...value,
           target: target ?? undefined,
@@ -69,9 +68,7 @@ export const EditorPreviewProvider = ({ children, onLookup }: EditorPreviewProvi
     <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'>
+        <div className='contents' ref={setRoot}>
           {children}
         </div>
       </Popover.Root>

package/src/components/EditorToolbar/EditorToolbar.tsx

@@ -6,27 +6,21 @@ import { type EditorView } from '@codemirror/view';
 import { Atom } from '@effect-atom/atom-react';
 import React, { memo, useMemo } from 'react';
 
-import { atomFromSignal } from '@dxos/app-graph';
-import { type Live } from '@dxos/live-object';
+import { type Node } from '@dxos/app-graph';
 import { ElevationProvider, type ThemedClassName } from '@dxos/react-ui';
-import {
-  type ActionGraphProps,
-  MenuProvider,
-  ToolbarMenu,
-  createGapSeparator,
-  useMenuActions,
-} from '@dxos/react-ui-menu';
+import { type ActionGraphProps, Menu, type MenuAction, MenuBuilder, useMenuActions } from '@dxos/react-ui-menu';
+import { type EditorViewMode } from '@dxos/ui-editor/types';
 
-import { type EditorViewMode } from '../../types';
+import { addBlocks } from './blocks';
+import { addFormatting } from './formatting';
+import { addHeadings } from './headings';
+import { addImageUpload } from './image';
+import { addLists } from './lists';
+import { addSearch } from './search';
+import { type EditorToolbarState } from './types';
+import { addViewMode } from './view-mode';
 
-import { createLists } from './actions';
-import { createBlocks } from './blocks';
-import { createFormatting } from './formatting';
-import { createHeadings } from './headings';
-import { createImageUpload } from './image';
-import { createSearch } from './search';
-import { type EditorToolbarState } from './useEditorToolbar';
-import { createViewMode } from './view-mode';
+// TODO(burdon): Enable toolbar variants (e.g., markdown, code).
 
 export type EditorToolbarFeatureFlags = Partial<{
   showHeadings: boolean;
@@ -41,7 +35,7 @@ export type EditorToolbarFeatureFlags = Partial<{
 }>;
 
 export type EditorToolbarActionGraphProps = {
-  state: Live<EditorToolbarState>;
+  state: Atom.Atom<EditorToolbarState>;
   getView: () => EditorView;
   // TODO(wittjosiah): Control positioning.
   customActions?: Atom.Atom<ActionGraphProps>;
@@ -51,18 +45,19 @@ export type EditorToolbarProps = ThemedClassName<
   {
     role?: string;
     attendableId?: string;
+    /** Handler for executing actions. Required when customActions use Operation.invoke. */
+    onAction?: (action: MenuAction, params: Node.InvokeProps) => void;
   } & (EditorToolbarActionGraphProps & EditorToolbarFeatureFlags)
 >;
 
-// TODO(burdon): Remove role dependency.
-export const EditorToolbar = memo(({ classNames, role, attendableId, ...props }: EditorToolbarProps) => {
-  const menuProps = useEditorToolbarActionGraph(props);
+export const EditorToolbar = memo(({ classNames, role, attendableId, onAction, ...props }: EditorToolbarProps) => {
+  const menuActions = useMarkdownMenuActions(props);
 
   return (
     <ElevationProvider elevation={role === 'section' ? 'positioned' : 'base'}>
-      <MenuProvider {...menuProps} attendableId={attendableId}>
-        <ToolbarMenu classNames={classNames} textBlockWidth />
-      </MenuProvider>
+      <Menu.Root {...menuActions} attendableId={attendableId} onAction={onAction}>
+        <Menu.Toolbar classNames={classNames} />
+      </Menu.Root>
     </ElevationProvider>
   );
 });
@@ -70,12 +65,13 @@ export const EditorToolbar = memo(({ classNames, role, attendableId, ...props }:
 type ToolbarActionsProps = Pick<EditorToolbarActionGraphProps, 'state' | 'getView' | 'customActions'> &
   EditorToolbarFeatureFlags;
 
+// TODO(burdon): Some actions should toggle the state (e.g., toggle bullets on/off depending on the current state).
 // TODO(wittjosiah): Toolbar re-rendering is causing this graph to be recreated and breaking reactivity in some cases.
 //   E.g. for toolbar dropdowns which use active icon, the icon is not updated when the active item changes.
 //   This is currently only happening in the markdown plugin usage and should be reproduced in an editor story.
-const useEditorToolbarActionGraph = ({ state, getView, customActions, ...features }: ToolbarActionsProps) => {
+const useMarkdownMenuActions = ({ state, getView, customActions, ...features }: ToolbarActionsProps) => {
   const menuCreator = useMemo(
-    () => createToolbarActions({ state, getView, customActions, ...features }),
+    () => createMarkdownActions({ state, getView, customActions, ...features }),
     [
       state,
       getView,
@@ -93,52 +89,25 @@ const useEditorToolbarActionGraph = ({ state, getView, customActions, ...feature
   return useMenuActions(menuCreator);
 };
 
-const createToolbarActions = ({
+const createMarkdownActions = ({
   state,
   getView,
   customActions,
   ...features
 }: ToolbarActionsProps): Atom.Atom<ActionGraphProps> => {
   return Atom.make((get) => {
-    const graph: ActionGraphProps = {
-      nodes: [],
-      edges: [],
-    };
-
-    // TODO(burdon): Builder pattern?
-    const addSubGraph = (graph: ActionGraphProps, subGraph: ActionGraphProps) => {
-      graph.nodes.push(...subGraph.nodes);
-      graph.edges.push(...subGraph.edges);
-    };
-
-    if (features?.showHeadings ?? true) {
-      addSubGraph(graph, get(atomFromSignal(() => createHeadings(state, getView))));
-    }
-    if (features?.showFormatting ?? true) {
-      addSubGraph(graph, get(atomFromSignal(() => createFormatting(state, getView))));
-    }
-    if (features?.showLists ?? true) {
-      addSubGraph(graph, get(atomFromSignal(() => createLists(state, getView))));
-    }
-    if (features?.showBlocks ?? true) {
-      addSubGraph(graph, get(atomFromSignal(() => createBlocks(state, getView))));
-    }
-    if (features?.onImageUpload) {
-      addSubGraph(graph, get(atomFromSignal(() => createImageUpload(features.onImageUpload!))));
-    }
-
-    addSubGraph(graph, createGapSeparator());
-
-    if (customActions) {
-      addSubGraph(graph, get(customActions));
-    }
-    if (features?.showSearch ?? true) {
-      addSubGraph(graph, get(atomFromSignal(() => createSearch(getView))));
-    }
-    if (features?.onViewModeChange) {
-      addSubGraph(graph, get(atomFromSignal(() => createViewMode(state, features.onViewModeChange!))));
-    }
-
-    return graph;
+    // Subscribe to state changes.
+    const stateSnapshot = get(state);
+    return MenuBuilder.make()
+      .subgraph(features?.showHeadings !== false && addHeadings(stateSnapshot, getView))
+      .subgraph(features?.showFormatting !== false && addFormatting(stateSnapshot, getView))
+      .subgraph(features?.showLists !== false && addLists(stateSnapshot, getView))
+      .subgraph(features?.showBlocks !== false && addBlocks(stateSnapshot, getView))
+      .subgraph(features?.onImageUpload && addImageUpload(features.onImageUpload))
+      .separator('gap')
+      .subgraph(customActions && get(customActions))
+      .subgraph(features?.showSearch !== false && addSearch(getView))
+      .subgraph(features?.onViewModeChange && addViewMode(stateSnapshot, features.onViewModeChange))
+      .build();
   });
 };

package/src/components/EditorToolbar/blocks.ts

@@ -4,57 +4,64 @@
 
 import { type EditorView } from '@codemirror/view';
 
-import { type NodeArg } from '@dxos/app-graph';
-import { type ToolbarMenuActionGroupProperties } from '@dxos/react-ui-menu';
+import { type ActionGroupBuilderFn, type ToolbarMenuActionGroupProperties } from '@dxos/react-ui-menu';
+import { addBlockquote, addCodeblock, insertTable, removeBlockquote, removeCodeblock } from '@dxos/ui-editor';
 
-import { addBlockquote, addCodeblock, insertTable, removeBlockquote, removeCodeblock } from '../../extensions';
+import { translationKey } from '#translations';
 
-import { createEditorAction, createEditorActionGroup } from './actions';
-import { type EditorToolbarState } from './useEditorToolbar';
+import { type EditorToolbarState } from './types';
 
-const createBlockGroupAction = (value: string) =>
-  createEditorActionGroup('block', {
-    variant: 'toggleGroup',
-    selectCardinality: 'single',
-    value,
-  } as ToolbarMenuActionGroupProperties);
-
-const createBlockActions = (value: string, getView: () => EditorView, blankLine?: boolean) =>
-  Object.entries({
-    blockquote: 'ph--quotes--regular',
-    codeblock: 'ph--code-block--regular',
-    table: 'ph--table--regular',
-  }).map(([type, icon]) => {
-    const checked = type === value;
-    return createEditorAction(type, { checked, ...(type === 'table' && { disabled: !!blankLine }), icon }, () => {
-      const view = getView();
-      if (!view) {
-        return;
-      }
+const blockTypes = {
+  blockquote: 'ph--quotes--regular',
+  codeblock: 'ph--code-block--regular',
+  table: 'ph--table--regular',
+};
 
-      switch (type) {
-        case 'blockquote':
-          checked ? removeBlockquote(view) : addBlockquote(view);
-          break;
-        case 'codeblock':
-          checked ? removeCodeblock(view) : addCodeblock(view);
-          break;
-        case 'table':
-          insertTable(view);
-          break;
-      }
-    });
-  });
+/** Add block actions to the builder. */
+export const addBlocks =
+  (state: EditorToolbarState, getView: () => EditorView): ActionGroupBuilderFn =>
+  (builder) => {
+    const value = state?.blockQuote ? 'blockquote' : (state.blockType ?? '');
+    builder.group(
+      'block',
+      {
+        label: ['block.label', { ns: translationKey }],
+        iconOnly: true,
+        variant: 'toggleGroup',
+        selectCardinality: 'single',
+        value,
+      } as ToolbarMenuActionGroupProperties,
+      (group) => {
+        for (const [type, icon] of Object.entries(blockTypes)) {
+          const checked = type === value;
+          group.action(
+            type,
+            {
+              label: [`block.${type}.label`, { ns: translationKey }],
+              checked,
+              ...(type === 'table' && { disabled: !!state.blankLine }),
+              icon,
+            },
+            () => {
+              const view = getView();
+              if (!view) {
+                return;
+              }
 
-export const createBlocks = (state: EditorToolbarState, getView: () => EditorView) => {
-  const value = state?.blockQuote ? 'blockquote' : (state.blockType ?? '');
-  const blockGroupAction = createBlockGroupAction(value);
-  const blockActions = createBlockActions(value, getView, state.blankLine);
-  return {
-    nodes: [blockGroupAction as NodeArg<any>, ...blockActions],
-    edges: [
-      { source: 'root', target: 'block' },
-      ...blockActions.map(({ id }) => ({ source: blockGroupAction.id, target: id })),
-    ],
+              switch (type) {
+                case 'blockquote':
+                  checked ? removeBlockquote(view) : addBlockquote(view);
+                  break;
+                case 'codeblock':
+                  checked ? removeCodeblock(view) : addCodeblock(view);
+                  break;
+                case 'table':
+                  insertTable(view);
+                  break;
+              }
+            },
+          );
+        }
+      },
+    );
   };
-};

package/src/components/EditorToolbar/formatting.ts

@@ -4,13 +4,12 @@
 
 import { type EditorView } from '@codemirror/view';
 
-import { type NodeArg } from '@dxos/app-graph';
-import { type ToolbarMenuActionGroupProperties } from '@dxos/react-ui-menu';
+import { type ActionGroupBuilderFn, type ToolbarMenuActionGroupProperties } from '@dxos/react-ui-menu';
+import { type Formatting, Inline, addLink, removeLink, setStyle } from '@dxos/ui-editor';
 
-import { type Formatting, Inline, addLink, removeLink, setStyle } from '../../extensions';
+import { translationKey } from '#translations';
 
-import { createEditorAction, createEditorActionGroup } from './actions';
-import { type EditorToolbarState } from './useEditorToolbar';
+import { type EditorToolbarState } from './types';
 
 const formats = {
   strong: 'ph--text-b--regular',
@@ -20,47 +19,46 @@ const formats = {
   link: 'ph--link--regular',
 };
 
-const createFormattingGroup = (formatting: Formatting) =>
-  createEditorActionGroup('formatting', {
-    variant: 'toggleGroup',
-    selectCardinality: 'multiple',
-    value: Object.keys(formats).filter((key) => !!formatting[key as keyof Formatting]),
-  } as ToolbarMenuActionGroupProperties);
+/** Add formatting actions to the builder. */
+export const addFormatting =
+  (state: EditorToolbarState, getView: () => EditorView): ActionGroupBuilderFn =>
+  (builder) => {
+    const formatting: Formatting = state;
+    builder.group(
+      'formatting',
+      {
+        label: ['formatting.label', { ns: translationKey }],
+        iconOnly: true,
+        variant: 'toggleGroup',
+        selectCardinality: 'multiple',
+        value: Object.keys(formats).filter((key) => !!formatting[key as keyof Formatting]),
+      } as ToolbarMenuActionGroupProperties,
+      (group) => {
+        for (const [type, icon] of Object.entries(formats)) {
+          const checked = !!formatting[type as keyof Formatting];
+          group.action(type, { label: [`formatting.${type}.label`, { ns: translationKey }], checked, icon }, () => {
+            const view = getView();
+            if (!view) {
+              return;
+            }
 
-const createFormattingActions = (formatting: Formatting, getView: () => EditorView) =>
-  Object.entries(formats).map(([type, icon]) => {
-    const checked = !!formatting[type as keyof Formatting];
-    return createEditorAction(type, { checked, icon }, () => {
-      const view = getView();
-      if (!view) {
-        return;
-      }
+            if (type === 'link') {
+              checked ? removeLink(view) : addLink()(view);
+              return;
+            }
 
-      if (type === 'link') {
-        checked ? removeLink(view) : addLink()(view);
-        return;
-      }
-
-      const inlineType =
-        type === 'strong'
-          ? Inline.Strong
-          : type === 'emphasis'
-            ? Inline.Emphasis
-            : type === 'strikethrough'
-              ? Inline.Strikethrough
-              : Inline.Code;
-      setStyle(inlineType, !checked)(view);
-    });
-  });
-
-export const createFormatting = (state: EditorToolbarState, getView: () => EditorView) => {
-  const formattingGroupAction = createFormattingGroup(state);
-  const formattingActions = createFormattingActions(state, getView);
-  return {
-    nodes: [formattingGroupAction as NodeArg<any>, ...formattingActions],
-    edges: [
-      { source: 'root', target: 'formatting' },
-      ...formattingActions.map(({ id }) => ({ source: formattingGroupAction.id, target: id })),
-    ],
+            setStyle(
+              type === 'strong'
+                ? Inline.Strong
+                : type === 'emphasis'
+                  ? Inline.Emphasis
+                  : type === 'strikethrough'
+                    ? Inline.Strikethrough
+                    : Inline.Code,
+              !checked,
+            )(view);
+          });
+        }
+      },
+    );
   };
-};