@dxos/plugin-navtree 0.8.4-main.c4373fc → 0.8.4-main.c85a9c8dae

package/src/components/Sidebar/L1Panel.tsx

@@ -2,150 +2,287 @@
 // Copyright 2025 DXOS.org
 //
 
-import React, { useCallback, useMemo } from 'react';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+import React, { memo, useCallback, useMemo } from 'react';
 
-import { type Node } from '@dxos/app-graph';
-import { DensityProvider, IconButton, toLocalizedString, useTranslation } from '@dxos/react-ui';
+import { Node } from '@dxos/app-graph';
+import { useAppGraph } from '@dxos/app-toolkit/ui';
+import { Graph, useActionRunner, useConnections, useEdges } from '@dxos/plugin-graph';
+import { DensityProvider, IconButton, ScrollArea, toLocalizedString, useTranslation } from '@dxos/react-ui';
 import { Tree } from '@dxos/react-ui-list';
+import { Menu, type MenuItem } from '@dxos/react-ui-menu';
 import { Tabs } from '@dxos/react-ui-tabs';
-import { hoverableControlItem, hoverableOpenControlItem } from '@dxos/react-ui-theme';
+import { hoverableControlItem, hoverableOpenControlItem } from '@dxos/ui-theme';
 
+import { useActions, useIsAlternateTree, useLoadDescendents } from '../../hooks';
 import { meta } from '../../meta';
+import { NAV_TREE_ITEM } from '../NavTree';
 import { useNavTreeContext } from '../NavTreeContext';
-import { NavTreeItemColumns } from '../NavTreeItem';
+import { NavTreeItemAction, NavTreeItemColumns } from '../NavTreeItem';
 
 export type L1PanelProps = {
   open?: boolean;
   path: string[];
-  item: Node<any>;
-  currentItemId: string;
+  item: Node.Node;
+  isCurrent: boolean;
   onBack?: () => void;
 };
 
 /**
  * Space or settings panel.
  */
-export const L1Panel = ({ open, path, item, currentItemId, onBack }: L1PanelProps) => {
+const L1Panel$ = ({ open, path, item, isCurrent, onBack }: L1PanelProps) => {
   const { t } = useTranslation(meta.id);
-  const { isAlternateTree, ...navTreeContext } = useNavTreeContext();
   const title = toLocalizedString(item.properties.label, t);
-
-  // TODO(wittjosiah): Support multiple alternate trees.
-  const { useItems } = navTreeContext;
-  const alternateTree = useItems(item, { disposition: 'alternate-tree' })[0];
-  const alternatePath = useMemo(() => [...path, item.id], [item.id, path]);
-  const isAlternate = isAlternateTree?.(alternatePath, item) ?? false;
-  const useAlternateItems = useCallback(
-    (node?: Node, { disposition }: { disposition?: string } = {}) => {
-      // TODO(wittjosiah): Sorting is expensive, limit to necessary items for now.
-      return useItems(node, { disposition, sort: node?.id === alternateTree.id });
-    },
-    [alternateTree, useItems],
-  );
+  const isActivated = useIsActivatedWorkspace(item);
+  const shouldRenderContent = isCurrent || isActivated;
 
   return (
     <Tabs.Tabpanel
       key={item.id}
       value={item.id}
       classNames={[
-        'absolute inset-block-0 inline-end-0',
-        'is-[calc(100%-var(--l0-size))] lg:is-[--l1-size] grid-cols-1 grid-rows-[var(--rail-size)_1fr]',
-        'pbs-[env(safe-area-inset-top)]',
-        item.id === currentItemId && 'grid',
+        'absolute inset-y-0 end-0',
+        'w-[calc(100%-var(--dx-l0-size))] lg:w-(--dx-l1-size) grid-cols-1 grid-rows-[var(--dx-rail-size)_1fr]',
+        'py-[env(safe-area-inset-top)]',
+        isCurrent && 'grid',
       ]}
       tabIndex={-1}
       aria-label={title}
+      {...(isCurrent && { 'data-testid': 'navtree.workspace.visible' })}
       {...(!open && { inert: true })}
     >
-      {item.id === currentItemId && (
-        <DensityProvider density='fine'>
-          <L1PanelHeader path={path} item={item} currentItemId={currentItemId} onBack={onBack} />
-          <div role='none' className='overflow-y-auto'>
-            {isAlternate ? (
-              <Tree
-                {...navTreeContext}
-                id={alternateTree.id}
-                root={alternateTree}
-                path={alternatePath}
-                levelOffset={5}
-                gridTemplateColumns='[tree-row-start] 1fr min-content min-content min-content [tree-row-end]'
-                renderColumns={NavTreeItemColumns}
-                useItems={useAlternateItems}
-              />
-            ) : (
-              <Tree
-                {...navTreeContext}
-                id={item.id}
-                root={item}
-                path={path}
-                levelOffset={5}
-                gridTemplateColumns='[tree-row-start] 1fr min-content min-content min-content [tree-row-end]'
-                renderColumns={NavTreeItemColumns}
-                draggable
-              />
-            )}
-          </div>
-        </DensityProvider>
-      )}
+      {shouldRenderContent && <L1PanelContent open={open} path={path} item={item} onBack={onBack} />}
     </Tabs.Tabpanel>
   );
 };
 
+/** Determines whether a workspace tab has been populated with real child content (i.e. expanded at least once). */
+const useIsActivatedWorkspace = (item: Node.Node): boolean => {
+  const { graph } = useAppGraph();
+  const edges = useEdges(graph, item.id);
+
+  return useMemo(() => {
+    const childIds = edges[Graph.relationKey('child')] ?? [];
+    return childIds.some((childId) => {
+      const child = Graph.getNode(graph, childId);
+      if (Option.isNone(child)) {
+        return false;
+      }
+      return child.value.properties.disposition === undefined;
+    });
+  }, [edges, graph]);
+};
+
+/**
+ * Mounted panel content for active or previously-visited tabs.
+ */
+const L1PanelContent = ({ path, item, onBack }: Pick<L1PanelProps, 'open' | 'path' | 'item' | 'onBack'>) => {
+  const navTreeContext = useNavTreeContext();
+
+  const alternateTree = useAlternateTreeItem(item);
+  const alternatePath = useMemo(() => [...path, item.id], [item.id, path]);
+  const isAlternate = useIsAlternateTree(alternatePath, item);
+
+  return (
+    <DensityProvider density='fine'>
+      <L1PanelHeader path={path} item={item} onBack={onBack} />
+      <ScrollArea.Root thin orientation='vertical'>
+        <ScrollArea.Viewport>
+          {isAlternate && alternateTree ? (
+            <Tree
+              model={navTreeContext.model}
+              id={alternateTree.id}
+              rootId={alternateTree.id}
+              path={alternatePath}
+              levelOffset={5}
+              gridTemplateColumns='[tree-row-start] 1fr min-content min-content min-content [tree-row-end]'
+              renderColumns={NavTreeItemColumns}
+              blockInstruction={navTreeContext.blockInstruction}
+              canDrop={navTreeContext.canDrop}
+              canSelect={navTreeContext.canSelect}
+              onOpenChange={navTreeContext.onOpenChange}
+              onSelect={navTreeContext.onSelect}
+              onItemHover={navTreeContext.onItemHover}
+            />
+          ) : (
+            <Tree
+              model={navTreeContext.model}
+              id={item.id}
+              rootId={item.id}
+              path={path}
+              levelOffset={5}
+              gridTemplateColumns='[tree-row-start] 1fr min-content min-content min-content [tree-row-end]'
+              draggable
+              renderColumns={NavTreeItemColumns}
+              blockInstruction={navTreeContext.blockInstruction}
+              canDrop={navTreeContext.canDrop}
+              canSelect={navTreeContext.canSelect}
+              onOpenChange={navTreeContext.onOpenChange}
+              onSelect={navTreeContext.onSelect}
+              onItemHover={navTreeContext.onItemHover}
+            />
+          )}
+        </ScrollArea.Viewport>
+      </ScrollArea.Root>
+    </DensityProvider>
+  );
+};
+
 /**
  * Header row.
  */
-const L1PanelHeader = ({ item, path, onBack }: L1PanelProps) => {
+const L1PanelHeader = ({ item, path, onBack }: Pick<L1PanelProps, 'item' | 'path' | 'onBack'>) => {
   const { t } = useTranslation(meta.id);
-  const { isAlternateTree, setAlternateTree, ...navTreeContext } = useNavTreeContext();
+  const { renderItemEnd: ItemEnd } = useNavTreeContext();
   const title = toLocalizedString(item.properties.label, t);
+  const backCapableWorkspace = item.id.startsWith('!');
 
-  // TODO(wittjosiah): Support multiple alternate trees.
-  const alternateTree = navTreeContext.useItems(item, { disposition: 'alternate-tree' })[0];
-  const alternatePath = useMemo(() => [...path, item.id], [item.id, path]);
-  const isAlternate = isAlternateTree?.(alternatePath, item) ?? false;
-  const backCapable = item.id.startsWith('!') || isAlternate;
-
-  const handleOpen = useCallback(() => {
-    setAlternateTree?.(alternatePath, true);
-  }, [alternatePath, setAlternateTree]);
-
-  const handleBack = useCallback(() => {
-    if (isAlternate) {
-      setAlternateTree?.(alternatePath, false);
-    } else {
-      onBack?.();
-    }
-  }, [isAlternate, alternatePath, setAlternateTree, onBack]);
+  const { primaryAction, groupedActions, menuActions, onAction } = useL1MenuActions({ item, path });
+  useLoadDescendents(item);
 
-  // TODO(burdon): Reuse same grid as tree?
   return (
-    <div className='flex is-full items-center border-be border-subduedSeparator app-drag density-coarse'>
-      <div className='is-6' />
-      <h2 className='flex-1 truncate min-is-0'>{title}</h2>
-      {(backCapable && (
+    <div className='flex w-full items-center border-b border-subdued-separator dx-app-drag dx-density-coarse pe-1'>
+      {backCapableWorkspace ? (
         <IconButton
+          size={5}
+          density='coarse'
+          classNames={['shrink-0 px-2 pointer-fine:px-1', hoverableControlItem, hoverableOpenControlItem]}
           variant='ghost'
-          icon='ph--arrow-u-down-left--regular'
+          icon='ph--caret-left--regular'
           iconOnly
-          size={5}
           label={t('button back')}
-          classNames={[hoverableControlItem, hoverableOpenControlItem, 'pointer-fine:pli-1']}
-          onClick={handleBack}
+          data-testid='treeView.primaryTreeButton'
+          onClick={() => onBack?.()}
         />
-      )) ||
-        (alternateTree && !isAlternate && (
+      ) : (
+        <div className='w-6' />
+      )}
+      <h2 className='flex-1 truncate min-w-0'>{title}</h2>
+      {/* TODO(wittjosiah): Reconcile with NavTreeItemColumns. */}
+      <div role='none' className='contents dx-app-no-drag'>
+        {primaryAction?.properties?.disposition === 'list-item-primary' && !primaryAction?.properties?.disabled && (
+          <NavTreeItemAction
+            testId={primaryAction.properties?.testId}
+            label={toLocalizedString(primaryAction.properties?.label, t)}
+            icon={primaryAction.properties?.icon ?? 'ph--placeholder--regular'}
+            parent={item}
+            monolithic={Node.isAction(primaryAction)}
+            menuActions={Node.isAction(primaryAction) ? [primaryAction] : groupedActions[primaryAction?.id ?? '']}
+            menuType={primaryAction.properties?.menuType}
+            caller={NAV_TREE_ITEM}
+          />
+        )}
+        {menuActions.length === 1 && (
           <IconButton
-            data-testid='treeView.alternateTreeButton'
+            size={5}
+            density='coarse'
+            classNames={['shrink-0 px-2 pointer-fine:px-1', hoverableControlItem, hoverableOpenControlItem]}
             variant='ghost'
-            icon={alternateTree.properties.icon ?? 'ph--placeholder--regular'}
+            icon={menuActions[0].properties?.icon ?? 'ph--placeholder--regular'}
             iconOnly
-            size={5}
-            label={toLocalizedString(alternateTree.properties.label ?? alternateTree.id, t)}
-            classNames={[hoverableControlItem, hoverableOpenControlItem, 'pointer-fine:pli-1']}
-            onClick={handleOpen}
+            label={toLocalizedString(menuActions[0].properties?.label, t)}
+            data-testid={menuActions[0].properties?.testId}
+            onClick={() => onAction(menuActions[0] as Node.Action)}
           />
-        ))}
-      <NavTreeItemColumns open path={path} item={item} density='coarse' />
+        )}
+        {menuActions.length > 1 && (
+          <Menu.Root caller={NAV_TREE_ITEM} onAction={onAction}>
+            <Menu.Trigger asChild>
+              <IconButton
+                size={5}
+                density='coarse'
+                classNames={['shrink-0 px-2 pointer-fine:px-1', hoverableControlItem, hoverableOpenControlItem]}
+                variant='ghost'
+                icon='ph--dots-three-vertical--regular'
+                iconOnly
+                label={t('tree item actions label')}
+                data-testid='navtree.treeItem.actionsLevel0'
+              />
+            </Menu.Trigger>
+            <Menu.Content group={item} items={menuActions as MenuItem[]} />
+          </Menu.Root>
+        )}
+        {ItemEnd && <ItemEnd node={item} open />}
+      </div>
     </div>
   );
 };
+
+/**
+ * Builds the menu actions for the L1 panel header, combining graph actions with a synthetic settings/back action.
+ */
+const useL1MenuActions = ({ item, path }: Pick<L1PanelProps, 'item' | 'path'>) => {
+  const { t } = useTranslation(meta.id);
+  const { setAlternateTree } = useNavTreeContext();
+  const { graph } = useAppGraph();
+  const runAction = useActionRunner();
+
+  const alternateTree = useAlternateTreeItem(item);
+  const alternatePath = useMemo(() => [...path, item.id], [item.id, path]);
+  const isAlternate = useIsAlternateTree(alternatePath, item);
+
+  // Graph actions.
+  const { actions: actionsProp, groupedActions } = useActions(item);
+  const [primaryAction, ...secondaryActions] = actionsProp.toSorted((a, _b) =>
+    a.properties?.disposition === 'list-item-primary' ? -1 : 1,
+  );
+
+  const graphMenuActions = (
+    primaryAction?.properties?.disposition === 'list-item-primary' ? secondaryActions : actionsProp
+  )
+    .flatMap((action) => (Node.isAction(action) ? [action] : []))
+    .filter((a) => ['list-item', 'list-item-primary'].includes(a.properties?.disposition));
+
+  // Synthetic settings/back action.
+  const settingsActionId = `${item.id}~settings`;
+  const settingsAction = useMemo((): Node.Action | undefined => {
+    if (!alternateTree) {
+      return undefined;
+    }
+    return {
+      id: settingsActionId,
+      type: Node.ActionType,
+      data: () => Effect.void,
+      properties: {
+        label: isAlternate ? ['button back', { ns: meta.id }] : (alternateTree.properties.label ?? alternateTree.id),
+        icon: isAlternate
+          ? 'ph--arrow-u-down-left--regular'
+          : (alternateTree.properties.icon ?? 'ph--placeholder--regular'),
+        disposition: 'list-item',
+        testId: isAlternate ? 'navtree.backToSpace' : 'navtree.spaceSettings',
+      },
+    } as Node.Action;
+  }, [alternateTree, isAlternate, settingsActionId, t]);
+
+  const menuActions = useMemo(
+    () => [...graphMenuActions, ...(settingsAction ? [settingsAction] : [])],
+    [graphMenuActions, settingsAction],
+  );
+
+  const onAction = useCallback(
+    (action: Node.Action, params?: Node.InvokeProps) => {
+      if (action.id === settingsActionId) {
+        if (alternateTree && !isAlternate) {
+          Graph.expand(graph, alternateTree.id, 'child');
+        }
+        setAlternateTree?.(alternatePath, !isAlternate);
+      } else {
+        void runAction(action, params);
+      }
+    },
+    [settingsActionId, setAlternateTree, alternatePath, isAlternate, runAction, graph, alternateTree],
+  );
+
+  return { primaryAction, groupedActions, menuActions, onAction };
+};
+
+/** Finds the first child with disposition 'alternate-tree' using graph connections directly. */
+const useAlternateTreeItem = (item: Node.Node): Node.Node | undefined => {
+  const { graph } = useAppGraph();
+  const connections = useConnections(graph, item.id, 'child');
+  return connections.find((node) => node.properties.disposition === 'alternate-tree');
+};
+
+export const L1Panel = memo(L1Panel$);

package/src/components/Sidebar/L1Tabs.tsx

@@ -2,57 +2,42 @@
 // Copyright 2025 DXOS.org
 //
 
-import React, { useMemo } from 'react';
+import React from 'react';
 
 import { type Node } from '@dxos/app-graph';
 
-import { useLoadDescendents } from '../../hooks';
 import { l0ItemType } from '../../util';
-import { useNavTreeContext } from '../NavTreeContext';
 
 import { L1Panel, type L1PanelProps } from './L1Panel';
 
-export type L1TabsProps = Pick<L1PanelProps, 'open' | 'currentItemId' | 'onBack'> & {
+export type L1TabsProps = Pick<L1PanelProps, 'open' | 'onBack'> & {
+  currentItemId: string;
   path: string[];
-  topLevelItems: Node<any>[];
+  topLevelItems: Node.Node[];
 };
 
 /**
- * Each space is an L1 tab.
+ * Each workspace is an L1 tab.
  */
-export const L1Tabs = ({ topLevelItems, onBack, ...props }: L1TabsProps) => {
+export const L1Tabs = ({ topLevelItems, currentItemId, onBack, open, path }: L1TabsProps) => {
   return (
     <>
       {topLevelItems.map((item) => {
         const type = l0ItemType(item);
-        switch (type) {
-          case 'tab':
-            return <L1Panel key={item.id} item={item} {...props} onBack={onBack} />;
-          case 'collection':
-            return <L1PanelCollection key={item.id} item={item} {...props} />;
-          default:
-            return null;
+        if (type === 'tab') {
+          return (
+            <L1Panel
+              key={item.id}
+              item={item}
+              path={path}
+              open={open}
+              onBack={onBack}
+              isCurrent={item.id === currentItemId}
+            />
+          );
         }
+        return null;
       })}
     </>
   );
 };
-
-/**
- *
- */
-const L1PanelCollection = ({ item, path, ...props }: L1PanelProps) => {
-  const { useItems } = useNavTreeContext();
-  useLoadDescendents(item);
-  const collectionItems = useItems(item);
-  const groupPath = useMemo(() => [...path, item.id], [item.id, path]);
-  return (
-    <>
-      {collectionItems
-        .filter((item) => l0ItemType(item) === 'tab')
-        .map((item) => (
-          <L1Panel key={item.id} item={item} path={groupPath} {...props} />
-        ))}
-    </>
-  );
-};

package/src/components/UserAccountAvatar/UserAccountAvatar.stories.tsx

@@ -9,9 +9,8 @@ import { withTheme } from '@dxos/react-ui/testing';
 import { UserAccountAvatar } from './UserAccountAvatar';
 
 const meta = {
-  title: 'plugins/plugin-navtree/UserAccountAvatar',
-
-  decorators: [withTheme],
+  title: 'plugins/plugin-navtree/components/UserAccountAvatar',
+  decorators: [withTheme()],
   component: UserAccountAvatar,
 } satisfies Meta<typeof UserAccountAvatar>;
 

package/src/components/UserAccountAvatar/UserAccountAvatar.tsx

@@ -22,7 +22,7 @@ export const UserAccountAvatar = ({ size, userId, hue, emoji, status }: UserAcco
 
   return (
     <>
-      <L0ItemActiveTabIndicator classNames='inset-block-6' />
+      <L0ItemActiveTabIndicator classNames='inset-y-6' />
       <div
         className='grid place-items-center dx-focus-ring-group-indicator rounded-full'
         data-joyride='welcome/account'

package/src/components/index.ts

@@ -2,9 +2,7 @@
 // Copyright 2023 DXOS.org
 //
 
-export * from './CommandsDialog';
 export * from './NavTree';
-export * from './NavTreeContainer';
 export * from './NavTreeContext';
-export * from './NavTreeDocumentTitle';
+
 export type * from './types';

package/src/components/types.ts

@@ -4,34 +4,29 @@
 
 import type { FC } from 'react';
 
-import type { Node } from '@dxos/app-graph';
+import { type Node } from '@dxos/app-graph';
 import type { Density } from '@dxos/react-ui';
-import type { TreeProps } from '@dxos/react-ui-list';
-import type { MaybePromise } from '@dxos/util';
+import type { TreeModel, TreeProps } from '@dxos/react-ui-list';
 
-import type { FlattenedActions, NavTreeItemGraphNode } from '../types';
+import type { NavTreeItemGraphNode } from '../types';
 
 import type { L1PanelProps } from './Sidebar';
 
-export type NavTreeContextValue = Pick<
-  TreeProps<NavTreeItemGraphNode, { disposition?: string; sort?: boolean }>,
-  'useItems' | 'getProps' | 'isCurrent' | 'isOpen' | 'canDrop' | 'onOpenChange' | 'onSelect'
+export type NavTreeContextValue = {
+  model: TreeModel<NavTreeItemGraphNode>;
+  popoverAnchorId?: string;
+  renderItemEnd?: FC<{ node: Node.Node; open: boolean }>;
+  setAlternateTree?: (path: string[], open: boolean) => void;
+  onTabChange?: (node: NavTreeItemGraphNode) => void;
+} & Pick<
+  TreeProps<NavTreeItemGraphNode>,
+  'blockInstruction' | 'canDrop' | 'canSelect' | 'onOpenChange' | 'onSelect' | 'onItemHover'
 > &
-  Pick<L1PanelProps, 'onBack'> & {
-    tab: string;
-    topbar?: boolean;
-    popoverAnchorId?: string;
-    renderItemEnd?: FC<{ node: Node; open: boolean }>;
-    useActions: (node: Node) => FlattenedActions;
-    loadDescendents?: (node: Node) => MaybePromise<void>;
-    isAlternateTree?: (path: string[], item: NavTreeItemGraphNode) => boolean;
-    setAlternateTree?: (path: string[], open: boolean) => void;
-    onTabChange?: (node: NavTreeItemGraphNode) => void;
-  };
+  Pick<L1PanelProps, 'onBack'>;
 
 export type NavTreeItemColumnsProps = {
   path: string[];
-  item: Node;
+  item: Node.Node;
   open: boolean;
   density?: Density;
 };

package/src/containers/CommandsDialogContent/CommandsDialogContent.tsx

@@ -0,0 +1,133 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import React, { forwardRef, useMemo, useState } from 'react';
+
+import { useOperationInvoker } from '@dxos/app-framework/ui';
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { useAppGraph } from '@dxos/app-toolkit/ui';
+import { Keyboard, keySymbols } from '@dxos/keyboard';
+import { Graph, Node, useActionRunner } from '@dxos/plugin-graph';
+import { useActions } from '@dxos/plugin-graph';
+import { Button, Dialog, toLocalizedString, useTranslation } from '@dxos/react-ui';
+import { SearchList, useSearchListResults } from '@dxos/react-ui-searchlist';
+import { osTranslations } from '@dxos/ui-theme';
+import { getHostPlatform } from '@dxos/util';
+
+import { KEY_BINDING, meta } from '../../meta';
+
+export type CommandsDialogContentProps = {
+  selected?: string;
+};
+
+// TODO(wittjosiah): This probably deserves its own plugin but for now it lives here w/ other navigation UI.
+export const CommandsDialogContent = forwardRef<HTMLDivElement, CommandsDialogContentProps>(
+  ({ selected: initial }, forwardedRef) => {
+    const { t } = useTranslation(meta.id);
+    const { invokeSync } = useOperationInvoker();
+    const runAction = useActionRunner();
+    const { graph } = useAppGraph();
+    const [selected, setSelected] = useState<string | undefined>(initial);
+
+    // Traverse graph.
+    // TODO(burdon): Factor out commonality with shortcut dialog.
+    const allActions = useMemo(() => {
+      // TODO(burdon): Get from navtree (not keyboard).
+      const current = Keyboard.singleton.getCurrentContext();
+      const actionMap = new Set<string>();
+      const actions: Node.ActionLike[] = [];
+      Graph.traverse(graph, {
+        relation: 'child',
+        visitor: (node, path) => {
+          if (
+            (Node.isAction(node) || Node.isActionGroup(node)) &&
+            !actionMap.has(node.id) &&
+            current.startsWith(path.slice(0, -1).join('/'))
+          ) {
+            actionMap.add(node.id);
+            actions.push(node);
+          }
+        },
+      });
+
+      actions.sort((a, b) => {
+        return toLocalizedString(a.properties.label, t)
+          ?.toLowerCase()
+          .localeCompare(toLocalizedString(b.properties.label, t)?.toLowerCase());
+      });
+
+      return actions;
+    }, [graph]);
+
+    const group = allActions.find(({ id }) => id === selected);
+    const groupActions = useActions(graph, group?.id);
+    const actions = Node.isActionGroup(group) ? groupActions : allActions;
+
+    const { results, handleSearch } = useSearchListResults({
+      items: actions,
+      extract: (action) => toLocalizedString(action.properties.label, t),
+    });
+
+    return (
+      <Dialog.Content ref={forwardedRef}>
+        <Dialog.Title>{t('commands dialog title', { ns: meta.id })}</Dialog.Title>
+        <SearchList.Root onSearch={handleSearch}>
+          <SearchList.Content>
+            <SearchList.Input placeholder={t('command list input placeholder')} />
+            <SearchList.Viewport>
+              {results.map((action) => {
+                const shortcut =
+                  typeof action.properties.keyBinding === 'string'
+                    ? action.properties.keyBinding
+                    : action.properties.keyBinding?.[getHostPlatform()];
+
+                return (
+                  <SearchList.Item
+                    value={action.id}
+                    key={action.id}
+                    label={toLocalizedString(action.properties.label, t)}
+                    icon={action.properties.icon}
+                    suffix={shortcut ? keySymbols(shortcut).join('') : undefined}
+                    onSelect={() => {
+                      if (action.properties.disabled) {
+                        return;
+                      }
+
+                      if (Node.isActionGroup(action)) {
+                        setSelected(action.id);
+                        return;
+                      }
+
+                      invokeSync(LayoutOperation.UpdateDialog, { state: false });
+                      setTimeout(() => {
+                        const node = Graph.getConnections(
+                          graph,
+                          group?.id ?? action.id,
+                          Node.childRelation('inbound'),
+                        )[0];
+                        if (node && Node.isAction(action)) {
+                          void runAction(action, { parent: node, caller: KEY_BINDING });
+                        }
+                      });
+                    }}
+                    classNames='flex items-center gap-2'
+                    disabled={action.properties.disabled}
+                    {...(action.properties?.testId && {
+                      'data-testid': action.properties.testId,
+                    })}
+                  />
+                );
+              })}
+            </SearchList.Viewport>
+          </SearchList.Content>
+        </SearchList.Root>
+        <div role='none' className='p-form-padding'>
+          <Dialog.Close asChild>
+            <Button classNames='w-full'>{t('close label', { ns: osTranslations })}</Button>
+          </Dialog.Close>
+        </div>
+      </Dialog.Content>
+    );
+  },
+);