@dxos/plugin-navtree 0.8.4-main.d05673bc65 → 0.8.4-main.d9fc60f731

package/src/components/Sidebar/L1Panel.tsx

@@ -2,26 +2,25 @@
 // Copyright 2025 DXOS.org
 //
 
-import * as Effect from 'effect/Effect';
 import * as Option from 'effect/Option';
 import React, { memo, useCallback, useMemo } from 'react';
 
 import { Node } from '@dxos/app-graph';
 import { isPinnedWorkspace } from '@dxos/app-toolkit';
 import { useAppGraph } from '@dxos/app-toolkit/ui';
-import { Graph, useActionRunner, useConnections, useEdges } from '@dxos/plugin-graph';
+import { Graph, useActionRunner, useEdges } from '@dxos/plugin-graph';
 import { DensityProvider, IconButton, ScrollArea, toLocalizedString, useTranslation } from '@dxos/react-ui';
-import { useAttended } from '@dxos/react-ui-attention';
 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/ui-theme';
 
-import { useActions, useIsAlternateTree, useLoadDescendents } from '../../hooks';
-import { meta } from '../../meta';
+import { getListActions, useActions, useLoadDescendents } from '#hooks';
+import { meta } from '#meta';
+
 import { NAV_TREE_ITEM } from '../NavTree';
 import { useNavTreeContext } from '../NavTreeContext';
-import { NavTreeItemAction, NavTreeItemColumns } from '../NavTreeItem';
+import { NavTreeItemColumns } from '../NavTreeItem/NavTreeItemColumns';
 
 export type L1PanelProps = {
   open?: boolean;
@@ -41,7 +40,7 @@ const L1Panel$ = ({ open, path, item, isCurrent, onBack }: L1PanelProps) => {
   const shouldRenderContent = isCurrent || isActivated;
 
   return (
-    <Tabs.Tabpanel
+    <Tabs.Panel
       key={item.id}
       value={item.id}
       classNames={[
@@ -56,7 +55,7 @@ const L1Panel$ = ({ open, path, item, isCurrent, onBack }: L1PanelProps) => {
       {...(!open && { inert: true })}
     >
       {shouldRenderContent && <L1PanelContent open={open} path={path} item={item} onBack={onBack} />}
-    </Tabs.Tabpanel>
+    </Tabs.Panel>
   );
 };
 
@@ -83,49 +82,28 @@ const useIsActivatedWorkspace = (item: Node.Node): boolean => {
 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'>
+    <DensityProvider density='md'>
       <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}
-            />
-          )}
+          <Tree
+            classNames='pt-[2px]'
+            model={navTreeContext.model}
+            id={item.id}
+            rootId={item.id}
+            path={path}
+            levelOffset={5}
+            draggable
+            gridTemplateColumns='[tree-row-start] minmax(0, 1fr) 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}
+          />
         </ScrollArea.Viewport>
       </ScrollArea.Root>
     </DensityProvider>
@@ -141,165 +119,111 @@ const L1PanelHeader = ({ item, path, onBack }: Pick<L1PanelProps, 'item' | 'path
   const title = toLocalizedString(item.properties.label, t);
   const backCapableWorkspace = isPinnedWorkspace(item.id);
 
-  const { primaryAction, groupedActions, menuActions, onAction } = useL1MenuActions({ item, path });
+  const { menuActions, onAction } = useL1MenuActions({ item, path });
   useLoadDescendents(item);
 
-  // TODO(wittjosiah): Hack to only show containsAttended when attended item is within alternate tree (e.g. settings).
-  //  Since every object in the space is a descendant of the space node, we'd otherwise always show containsAttended.
-  const alternateTree = useAlternateTreeItem(item);
-  const attended = useAttended();
-  const alternateTreeOpen = useMemo(() => {
-    if (!alternateTree) {
-      return true;
-    }
-    const hasAlternateAttended = attended.some(
-      (attendedId) => attendedId === alternateTree.id || attendedId.startsWith(alternateTree.id + '/'),
-    );
-    return !hasAlternateAttended;
-  }, [alternateTree, attended]);
-
   return (
-    <div className='flex w-full items-center border-b border-subdued-separator dx-app-drag dx-density-coarse pe-1'>
+    <div
+      data-tauri-drag-region
+      className='grid grid-cols-[28px_1fr_min-content_min-content] w-full items-center dx-app-drag dx-density-lg'
+    >
       {backCapableWorkspace ? (
         <IconButton
-          size={5}
-          density='coarse'
-          classNames={['shrink-0 px-2 pointer-fine:px-1', hoverableControlItem, hoverableOpenControlItem]}
+          classNames={[hoverableControlItem, hoverableOpenControlItem]}
           variant='ghost'
           icon='ph--caret-left--regular'
           iconOnly
-          label={t('button back')}
+          size={4}
+          label={t('button-back.button')}
           data-testid='treeView.primaryTreeButton'
           onClick={() => onBack?.()}
         />
       ) : (
-        <div className='w-6' />
+        <div />
       )}
-      <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}
-            path={path}
-            monolithic={Node.isAction(primaryAction)}
-            menuActions={Node.isAction(primaryAction) ? [primaryAction] : groupedActions[primaryAction?.id ?? '']}
-            menuType={primaryAction.properties?.menuType}
-            caller={NAV_TREE_ITEM}
-          />
-        )}
-        {menuActions.length === 1 && (
-          <IconButton
-            size={5}
-            density='coarse'
-            classNames={['shrink-0 px-2 pointer-fine:px-1', hoverableControlItem, hoverableOpenControlItem]}
-            variant='ghost'
-            icon={menuActions[0].properties?.icon ?? 'ph--placeholder--regular'}
-            iconOnly
-            label={toLocalizedString(menuActions[0].properties?.label, t)}
-            data-testid={menuActions[0].properties?.testId}
-            onClick={() => onAction(menuActions[0] as Node.Action)}
-          />
-        )}
-        {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={alternateTreeOpen} />}
+      <h2 data-tauri-drag-region className='flex-1 truncate min-w-0'>
+        {title}
+      </h2>
+      <div className='contents dx-app-no-drag'>
+        <MenuActions item={item} menuActions={menuActions} onAction={onAction} />
+        {ItemEnd && <ItemEnd node={item} open />}
       </div>
     </div>
   );
 };
 
+type L1MenuActions = {
+  menuActions: Node.Action[];
+  onAction: (action: Node.Action, params?: Node.InvokeProps) => void;
+};
+
 /**
- * Builds the menu actions for the L1 panel header, combining graph actions with a synthetic settings/back action.
+ * Header menu actions for an L1 workspace tab. Renders nothing for an empty
+ * `menuActions`, a single inline icon button for one action, and a
+ * `…`-menu trigger for multiple.
  */
-const useL1MenuActions = ({ item, path }: Pick<L1PanelProps, 'item' | 'path'>) => {
+const MenuActions = ({
+  item,
+  menuActions,
+  onAction,
+}: {
+  item: Node.Node;
+} & Pick<L1MenuActions, 'menuActions' | 'onAction'>) => {
   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);
+  if (menuActions.length === 0) {
+    return null;
+  }
+
+  if (menuActions.length === 1) {
+    return (
+      <IconButton
+        classNames={['shrink-0 px-2 pointer-fine:px-1', hoverableControlItem, hoverableOpenControlItem]}
+        variant='ghost'
+        icon={menuActions[0].properties?.icon ?? 'ph--circle-dashed--regular'}
+        iconOnly
+        size={4}
+        label={toLocalizedString(menuActions[0].properties?.label, t)}
+        data-testid={menuActions[0].properties?.testId}
+        onClick={() => onAction(menuActions[0] as Node.Action)}
+      />
+    );
+  }
 
-  // Graph actions.
-  const { actions: actionsProp, groupedActions } = useActions(item);
-  const [primaryAction, ...secondaryActions] = actionsProp.toSorted((a, _b) =>
-    a.properties?.disposition === 'list-item-primary' ? -1 : 1,
+  return (
+    <Menu.Root caller={NAV_TREE_ITEM} onAction={onAction}>
+      <Menu.Trigger asChild>
+        <IconButton
+          classNames={['shrink-0 px-2 pointer-fine:px-1', hoverableControlItem, hoverableOpenControlItem]}
+          variant='ghost'
+          icon='ph--dots-three-vertical--regular'
+          iconOnly
+          size={4}
+          label={t('tree-item-actions.label')}
+          data-testid='navtree.treeItem.actionsLevel0'
+        />
+      </Menu.Trigger>
+      <Menu.Content group={item} items={menuActions as MenuItem[]} />
+    </Menu.Root>
   );
+};
 
-  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]);
+/**
+ * Builds the menu actions for the L1 panel header.
+ */
+const useL1MenuActions = ({ item, path }: Pick<L1PanelProps, 'item' | 'path'>): L1MenuActions => {
+  const runAction = useActionRunner();
 
-  const menuActions = useMemo(
-    () => [...graphMenuActions, ...(settingsAction ? [settingsAction] : [])],
-    [graphMenuActions, settingsAction],
-  );
+  const menuActions = getListActions(useActions(item));
 
   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, path });
-      }
+      void runAction(action, { ...params, path });
     },
-    [settingsActionId, setAlternateTree, alternatePath, isAlternate, runAction, graph, alternateTree, path],
+    [runAction, path],
   );
 
-  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');
+  return { menuActions, onAction };
 };
 
 export const L1Panel = memo(L1Panel$);

package/src/components/Sidebar/L1Tabs.tsx

@@ -7,7 +7,6 @@ import React from 'react';
 import { type Node } from '@dxos/app-graph';
 
 import { l0ItemType } from '../../util';
-
 import { L1Panel, type L1PanelProps } from './L1Panel';
 
 export type L1TabsProps = Pick<L1PanelProps, 'open' | 'onBack'> & {

package/src/components/types.ts

@@ -8,7 +8,7 @@ import { type Node } from '@dxos/app-graph';
 import type { Density } from '@dxos/react-ui';
 import type { TreeModel, TreeProps } from '@dxos/react-ui-list';
 
-import type { NavTreeItemGraphNode } from '../types';
+import type { NavTreeItemGraphNode } from '#types';
 
 import type { L1PanelProps } from './Sidebar';
 
@@ -16,7 +16,6 @@ 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>,

package/src/containers/CommandsDialogContent/CommandsDialogContent.stories.tsx

@@ -0,0 +1,46 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import React from 'react';
+
+import { withPluginManager } from '@dxos/app-framework/testing';
+import { StorybookPlugin, corePlugins } from '@dxos/plugin-testing';
+import { Dialog } from '@dxos/react-ui';
+import { withLayout } from '@dxos/react-ui/testing';
+
+import { translations } from '#translations';
+
+import { NavTreePlugin } from '../../NavTreePlugin';
+import { CommandsDialogContent } from './CommandsDialogContent';
+
+const DefaultStory = () => (
+  <Dialog.Root defaultOpen>
+    <Dialog.Overlay>
+      <CommandsDialogContent />
+    </Dialog.Overlay>
+  </Dialog.Root>
+);
+
+const meta = {
+  title: 'plugins/plugin-navtree/containers/CommandsDialogContent',
+  component: CommandsDialogContent,
+  render: DefaultStory,
+  decorators: [
+    withLayout({ layout: 'fullscreen' }),
+    withPluginManager({
+      plugins: [...corePlugins(), StorybookPlugin({}), NavTreePlugin()],
+    }),
+  ],
+  parameters: {
+    layout: 'fullscreen',
+    translations,
+  },
+} satisfies Meta<typeof CommandsDialogContent>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {};

package/src/containers/CommandsDialogContent/CommandsDialogContent.tsx

@@ -11,11 +11,11 @@ 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 { SearchList, useSearchListResults } from '@dxos/react-ui-search';
 import { osTranslations } from '@dxos/ui-theme';
 import { getHostPlatform } from '@dxos/util';
 
-import { KEY_BINDING, meta } from '../../meta';
+import { KEY_BINDING, meta } from '#meta';
 
 export type CommandsDialogContentProps = {
   selected?: string;
@@ -25,7 +25,7 @@ export type CommandsDialogContentProps = {
 export const CommandsDialogContent = forwardRef<HTMLDivElement, CommandsDialogContentProps>(
   ({ selected: initial }, forwardedRef) => {
     const { t } = useTranslation(meta.id);
-    const { invokeSync } = useOperationInvoker();
+    const { invokePromise } = useOperationInvoker();
     const runAction = useActionRunner();
     const { graph } = useAppGraph();
     const [selected, setSelected] = useState<string | undefined>(initial);
@@ -40,11 +40,10 @@ export const CommandsDialogContent = forwardRef<HTMLDivElement, CommandsDialogCo
       Graph.traverse(graph, {
         relation: ['child', 'action'],
         visitor: (node, path) => {
-          if (
-            (Node.isAction(node) || Node.isActionGroup(node)) &&
-            !actionMap.has(node.id) &&
-            current.startsWith(path.slice(0, -1).join('/'))
-          ) {
+          const isActionLike = Node.isAction(node) || Node.isActionGroup(node);
+          const parentId = path.at(-2) ?? '';
+          const matches = current === parentId || current.startsWith(parentId + '/');
+          if (isActionLike && !actionMap.has(node.id) && matches) {
             actionMap.add(node.id);
             actions.push(node);
           }
@@ -71,62 +70,55 @@ export const CommandsDialogContent = forwardRef<HTMLDivElement, CommandsDialogCo
 
     return (
       <Dialog.Content ref={forwardedRef}>
-        <Dialog.Title srOnly>{t('commands dialog title', { ns: meta.id })}</Dialog.Title>
-        <Dialog.Body>
-          <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()];
+        <Dialog.Title srOnly>{t('commands-dialog.title', { ns: meta.id })}</Dialog.Title>
+        <SearchList.Root onSearch={handleSearch}>
+          <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;
-                        }
+              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;
-                        }
+                    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>
-        </Dialog.Body>
+                    void invokePromise(LayoutOperation.UpdateDialog, { state: false });
+                    setTimeout(() => {
+                      const lookupId = group?.id ?? action.id;
+                      const node = Graph.getConnections(graph, lookupId, Node.actionRelation('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.Root>
         <Dialog.ActionBar>
           <Dialog.Close asChild>
-            <Button classNames='w-full'>{t('close label', { ns: osTranslations })}</Button>
+            <Button classNames='w-full'>{t('close.label', { ns: osTranslations })}</Button>
           </Dialog.Close>
         </Dialog.ActionBar>
       </Dialog.Content>

package/src/containers/CommandsDialogContent/index.ts

@@ -2,6 +2,4 @@
 // Copyright 2023 DXOS.org
 //
 
-import { CommandsDialogContent } from './CommandsDialogContent';
-
-export default CommandsDialogContent;
+export { CommandsDialogContent as default } from './CommandsDialogContent';

package/src/containers/CommandsTrigger/CommandsTrigger.tsx

@@ -8,19 +8,21 @@ import { useOperationInvoker } from '@dxos/app-framework/ui';
 import { LayoutOperation } from '@dxos/app-toolkit';
 import { Button, Icon, useTranslation } from '@dxos/react-ui';
 
-import { COMMANDS_DIALOG, meta } from '../../meta';
+import { COMMANDS_DIALOG, meta } from '#meta';
 
 // TODO(thure): Refactor to be handled by a more appropriate plugin.
 export const CommandsTrigger = () => {
-  const { invokeSync } = useOperationInvoker();
+  const { invokePromise } = useOperationInvoker();
   const { t } = useTranslation(meta.id);
   return (
     <Button
       classNames='m-1 px-1 lg:px-2'
-      onClick={() => invokeSync(LayoutOperation.UpdateDialog, { subject: COMMANDS_DIALOG, blockAlign: 'start' })}
+      onClick={() =>
+        void invokePromise(LayoutOperation.UpdateDialog, { subject: COMMANDS_DIALOG, blockAlign: 'start' })
+      }
     >
-      <span className='text-description font-normal grow text-start'>{t('command list input placeholder')}</span>
-      <Icon icon='ph--magnifying-glass--regular' size={5} />
+      <span className='text-description font-normal grow text-start'>{t('command-list-input.placeholder')}</span>
+      <Icon icon='ph--magnifying-glass--regular' />
     </Button>
   );
 };

package/src/containers/CommandsTrigger/index.ts

@@ -2,6 +2,4 @@
 // Copyright 2024 DXOS.org
 //
 
-import { CommandsTrigger } from './CommandsTrigger';
-
-export default CommandsTrigger;
+export { CommandsTrigger as default } from './CommandsTrigger';