@dxos/plugin-navtree 0.8.4-main.406dc2a → 0.8.4-main.52d7546f51

package/src/components/Sidebar/L1Panel.tsx

@@ -2,22 +2,27 @@
 // Copyright 2025 DXOS.org
 //
 
+import * as Effect from 'effect/Effect';
 import React, { 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 { useActionRunner } from '@dxos/plugin-graph';
+import { DensityProvider, IconButton, ScrollArea, toLocalizedString, useTranslation } from '@dxos/react-ui';
 import { Tree } from '@dxos/react-ui-list';
+import { DropdownMenu, type MenuItem, MenuProvider } 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 { 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>;
+  item: Node.Node;
   currentItemId: string;
   onBack?: () => void;
 };
@@ -27,16 +32,16 @@ export type L1PanelProps = {
  */
 export const L1Panel = ({ open, path, item, currentItemId, onBack }: L1PanelProps) => {
   const { t } = useTranslation(meta.id);
-  const { isAlternateTree, ...navTreeContext } = useNavTreeContext();
+  const 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 isAlternate = useIsAlternateTree(alternatePath, item);
   const useAlternateItems = useCallback(
-    (node?: Node, { disposition }: { disposition?: string } = {}) => {
+    (node?: 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 });
     },
@@ -60,31 +65,33 @@ export const L1Panel = ({ open, path, item, currentItemId, onBack }: L1PanelProp
       {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>
+          <ScrollArea.Root thin orientation='vertical'>
+            <ScrollArea.Viewport>
+              {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
+                />
+              )}
+            </ScrollArea.Viewport>
+          </ScrollArea.Root>
         </DensityProvider>
       )}
     </Tabs.Tabpanel>
@@ -96,56 +103,128 @@ export const L1Panel = ({ open, path, item, currentItemId, onBack }: L1PanelProp
  */
 const L1PanelHeader = ({ item, path, onBack }: L1PanelProps) => {
   const { t } = useTranslation(meta.id);
-  const { isAlternateTree, setAlternateTree, ...navTreeContext } = useNavTreeContext();
+  const { renderItemEnd: ItemEnd } = useNavTreeContext();
   const title = toLocalizedString(item.properties.label, t);
 
-  // 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 && (
-        <IconButton
-          variant='ghost'
-          icon='ph--arrow-u-down-left--regular'
-          iconOnly
-          size={5}
-          label={t('button back')}
-          classNames={[hoverableControlItem, hoverableOpenControlItem, 'pointer-fine:pli-1']}
-          onClick={handleBack}
-        />
-      )) ||
-        (alternateTree && !isAlternate && (
+      {/* TODO(wittjosiah): Reconcile with NavTreeItemColumns. */}
+      <div role='none' className='contents 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 pli-2 pointer-fine:pli-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 && (
+          <MenuProvider onAction={onAction}>
+            <DropdownMenu.Root group={item} items={menuActions as MenuItem[]} caller={NAV_TREE_ITEM}>
+              <DropdownMenu.Trigger asChild>
+                <IconButton
+                  size={5}
+                  density='coarse'
+                  classNames={['shrink-0 pli-2 pointer-fine:pli-1', hoverableControlItem, hoverableOpenControlItem]}
+                  variant='ghost'
+                  icon='ph--dots-three-vertical--regular'
+                  iconOnly
+                  label={t('tree item actions label')}
+                  data-testid='navtree.treeItem.actionsLevel0'
+                />
+              </DropdownMenu.Trigger>
+            </DropdownMenu.Root>
+          </MenuProvider>
+        )}
+        {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, useActions, ...navTreeContext } = useNavTreeContext();
+  const runAction = useActionRunner();
+
+  // 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 = useIsAlternateTree(alternatePath, item);
+
+  // Graph actions.
+  const { actions: _actions, groupedActions } = useActions(item);
+  const [primaryAction, ...secondaryActions] = _actions.toSorted((a, _b) =>
+    a.properties?.disposition === 'list-item-primary' ? -1 : 1,
+  );
+
+  const graphMenuActions = (
+    primaryAction?.properties?.disposition === 'list-item-primary' ? secondaryActions : _actions
+  )
+    .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) {
+        setAlternateTree?.(alternatePath, !isAlternate);
+      } else {
+        void runAction(action, params);
+      }
+    },
+    [settingsActionId, setAlternateTree, alternatePath, isAlternate, runAction],
+  );
+
+  return { primaryAction, groupedActions, menuActions, onAction };
+};

package/src/components/Sidebar/L1Tabs.tsx

@@ -2,57 +2,32 @@
 // 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'> & {
   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) => {
   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} {...props} onBack={onBack} />;
         }
+        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

@@ -11,7 +11,7 @@ import { UserAccountAvatar } from './UserAccountAvatar';
 const meta = {
   title: 'plugins/plugin-navtree/UserAccountAvatar',
 
-  decorators: [withTheme],
+  decorators: [withTheme()],
   component: UserAccountAvatar,
 } satisfies Meta<typeof UserAccountAvatar>;
 

package/src/components/index.ts

@@ -7,4 +7,5 @@ export * from './NavTree';
 export * from './NavTreeContainer';
 export * from './NavTreeContext';
 export * from './NavTreeDocumentTitle';
+
 export type * from './types';

package/src/components/types.ts

@@ -4,7 +4,7 @@
 
 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';
@@ -15,23 +15,23 @@ import type { L1PanelProps } from './Sidebar';
 
 export type NavTreeContextValue = Pick<
   TreeProps<NavTreeItemGraphNode, { disposition?: string; sort?: boolean }>,
-  'useItems' | 'getProps' | 'isCurrent' | 'isOpen' | 'canDrop' | 'onOpenChange' | 'onSelect'
+  'useItems' | 'getProps' | 'useIsCurrent' | 'useIsOpen' | 'blockInstruction' | 'canDrop' | 'onOpenChange' | 'onSelect'
 > &
   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;
+    renderItemEnd?: FC<{ node: Node.Node; open: boolean }>;
+    useActions: (node: Node.Node) => FlattenedActions;
+    loadDescendents?: (node: Node.Node) => MaybePromise<void>;
+    useIsAlternateTree?: (path: string[], item: NavTreeItemGraphNode) => boolean;
     setAlternateTree?: (path: string[], open: boolean) => void;
     onTabChange?: (node: NavTreeItemGraphNode) => void;
   };
 
 export type NavTreeItemColumnsProps = {
   path: string[];
-  item: Node;
+  item: Node.Node;
   open: boolean;
   density?: Density;
 };

package/src/experimental/Tree.stories.tsx

@@ -3,39 +3,17 @@
 //
 
 import { type Meta } from '@storybook/react-vite';
-import React, { type JSX, type PropsWithChildren, useEffect, useState } from 'react';
+import React, { useEffect, useState } from 'react';
 
 import { faker } from '@dxos/random';
-import { Icon, IconButton } from '@dxos/react-ui';
-import { withTheme } from '@dxos/react-ui/testing';
-import { mx } from '@dxos/react-ui-theme';
+import { Icon, IconButton, Layout, ScrollArea } from '@dxos/react-ui';
+import { withLayout, withTheme } from '@dxos/react-ui/testing';
+import { mx } from '@dxos/ui-theme';
 
 import { type ItemMap, Tree, type TreeNodeData, type TreeProps, visitNodes, visitor } from './Tree';
 
 faker.seed(1234);
 
-/**
- * Space:
- * - Space panels are separated from each other to give them more weight than folders.
- * - Private space isn't different (just first, different icon).
- * - Edit titles in place.
- *
- * Navigation:
- *  - up/down across spaces/folder peers
- *  - right to enter space/folder children
- *  - left to parent
- */
-const Container = ({ children, sidebar }: PropsWithChildren<{ sidebar: JSX.Element }>) => {
-  return (
-    <div className='flex'>
-      {/* TODO(burdon): Custom thin scrollbar. */}
-      {/* TODO(burdon): Horizontal scrolling within navtree? */}
-      <div className='flex flex-col overflow-y-auto w-[300px] bg-neutral-100 dark:bg-neutral-950'>{sidebar}</div>
-      <div className='flex flex-col grow overflow-hidden'>{children}</div>
-    </div>
-  );
-};
-
 // TODO(burdon): Generate.
 const data: TreeNodeData[] = [
   {
@@ -134,7 +112,7 @@ const Sidebar = ({ mutate }: { mutate?: boolean }) => {
     }
   }, []);
 
-  const handleCreateItem: TreeProps['onMenuAction'] = (id, action) => {
+  const handleCreateItem: TreeProps['onMenuAction'] = (id) => {
     setItems((items) => {
       let parent: TreeNodeData | undefined;
       visitNodes(root, (node) => {
@@ -167,52 +145,65 @@ const Sidebar = ({ mutate }: { mutate?: boolean }) => {
   };
 
   return (
-    <div className='flex flex-col overflow-hidden'>
-      <div className='flex flex-col overflow-y-auto'>
-        <Tree
-          className='p-0.5 gap-1'
-          node={root}
-          open={openItems}
-          selected={selectedItems}
-          active={activeItems}
-          onChangeOpen={(id, open) => setOpenItems((items) => ({ ...items, [id]: open }))}
-          onChangeSelected={(id, open) => setSelectedItems((items) => ({ ...items, [id]: open }))}
-          onMenuAction={handleCreateItem}
-          getSlots={(node, open, depth, ancestors) => {
-            if (depth === 1) {
-              return {
-                root: 'rounded bg-white dark:bg-neutral-850',
-                header: mx('rounded-t bg-neutral-50 dark:bg-neutral-900', !open && 'rounded-b'),
-              };
-            }
-          }}
-        />
-      </div>
-
-      <div className='flex items-center my-2 px-2 gap-2'>
+    <Layout.Main>
+      <ScrollArea.Root orientation='vertical' thin>
+        <ScrollArea.Viewport>
+          <Tree
+            className='p-0.5 gap-1'
+            node={root}
+            open={openItems}
+            selected={selectedItems}
+            active={activeItems}
+            onChangeOpen={(id, open) => setOpenItems((items) => ({ ...items, [id]: open }))}
+            onChangeSelected={(id, open) => setSelectedItems((items) => ({ ...items, [id]: open }))}
+            onMenuAction={handleCreateItem}
+            getSlots={(node, open, depth) => {
+              if (depth === 1) {
+                return {
+                  root: 'rounded bg-white dark:bg-neutral-850',
+                  header: mx('rounded-t bg-neutral-50 dark:bg-neutral-900', !open && 'rounded-b'),
+                };
+              }
+            }}
+          />
+        </ScrollArea.Viewport>
+      </ScrollArea.Root>
+
+      <div className='flex items-center my-2 pli-2 gap-2'>
         <IconButton icon='ph--plus-circle--regular' iconOnly label='Create space' onClick={handleCreateSpace} />
         <span className='grow text-sm' onClick={handleCreateSpace}>
           New space
         </span>
         <Icon icon='ph--list--regular' />
       </div>
-    </div>
+    </Layout.Main>
   );
 };
 
 const meta = {
   title: 'plugins/plugin-navtree/experimental/Tree',
   component: Tree,
-  decorators: [withTheme],
+  decorators: [withTheme(), withLayout({ layout: 'column', classNames: 'is-[20rem]' })],
   parameters: {
-    layout: 'column',
+    layout: 'fullscreen',
   },
 } satisfies Meta<typeof Tree>;
 
 export default meta;
 
+/**
+ * Space:
+ * - Space panels are separated from each other to give them more weight than folders.
+ * - Private space isn't different (just first, different icon).
+ * - Edit titles in place.
+ *
+ * Navigation:
+ *  - up/down across spaces/folder peers
+ *  - right to enter space/folder children
+ *  - left to parent
+ */
 export const Default = () => {
-  return <Container sidebar={<Sidebar mutate />} />;
+  return <Sidebar mutate />;
 };
 
 export const Visitor = () => {

package/src/experimental/Tree.tsx

@@ -5,7 +5,7 @@
 import React, { type HTMLAttributes, type PropsWithChildren } from 'react';
 
 import { type ClassNameValue, Icon, type Size } from '@dxos/react-ui';
-import { mx } from '@dxos/react-ui-theme';
+import { mx } from '@dxos/ui-theme';
 
 export const IconButton = ({
   iconName,
@@ -19,7 +19,7 @@ export const IconButton = ({
 } & Pick<HTMLAttributes<HTMLDivElement>, 'onClick'>) => {
   // TODO(burdon): Density aware.
   return (
-    <div className={mx('flex w-6 h-6 items-center justify-center select-none', classNames)} onClick={onClick}>
+    <div className={mx('flex is-6 bs-6 items-center justify-center select-none', classNames)} onClick={onClick}>
       <Icon icon={iconName} classNames='cursor-pointer' size={size} />
     </div>
   );
@@ -193,7 +193,7 @@ export const TreeNodeRow = (props: TreeNodeProps & { className?: string }) => {
     <Grid
       style={{ paddingLeft: `${(depth - 1) * 24}px` }}
       className={mx(
-        'group w-full items-center cursor-pointer bg-hoverSurface',
+        'group is-full items-center cursor-pointer bg-hoverSurface',
         // TODO(burdon): Use data-active.
         selected?.[id] && 'bg-activeSurface',
         className,

package/src/hooks.ts

@@ -2,13 +2,16 @@
 // Copyright 2025 DXOS.org
 //
 
-import { useEffect } from 'react';
+import { type Atom, useAtomValue } from '@effect-atom/atom-react';
+import { useEffect, useMemo } from 'react';
 
+import { useCapability } from '@dxos/app-framework/ui';
 import { type Node } from '@dxos/app-graph';
 
 import { useNavTreeContext } from './components';
+import { NavTreeCapabilities } from './types';
 
-export const useLoadDescendents = (root?: Node) => {
+export const useLoadDescendents = (root?: Node.Node) => {
   const { loadDescendents } = useNavTreeContext();
   useEffect(() => {
     const frame = requestAnimationFrame(() => {
@@ -19,3 +22,52 @@ export const useLoadDescendents = (root?: Node) => {
     return () => cancelAnimationFrame(frame);
   }, [root]);
 };
+
+export type UseNavTreeStateResult = {
+  getItem: (path: string[]) => NavTreeCapabilities.NavTreeItemState;
+  getItemAtom: (path: string[]) => Atom.Atom<NavTreeCapabilities.NavTreeItemState>;
+  setItem: (path: string[], key: 'open' | 'current' | 'alternateTree', next: boolean) => void;
+};
+
+/**
+ * Hook that provides access to navtree state functions.
+ * For reactive subscriptions, use `useNavTreeItemState` or `useAtomValue(getItemAtom(path))`.
+ */
+export const useNavTreeState = (): UseNavTreeStateResult => {
+  return useCapability(NavTreeCapabilities.State);
+};
+
+/**
+ * Hook that subscribes to a single navtree item's state.
+ * Use this for fine-grained reactivity.
+ */
+export const useNavTreeItemState = (path: string[]): NavTreeCapabilities.NavTreeItemState => {
+  const { getItemAtom } = useCapability(NavTreeCapabilities.State);
+  // Memoize the path to avoid creating new atoms on every render.
+  const pathKey = useMemo(() => path.join('~'), [path]);
+  const atom = useMemo(() => getItemAtom(path), [getItemAtom, pathKey]);
+  return useAtomValue(atom);
+};
+
+/**
+ * Hook that subscribes to the open state for a tree item.
+ * Designed to be passed to Tree component as useIsOpen prop.
+ */
+export const useIsOpen = (path: string[], _item?: any): boolean => {
+  return useNavTreeItemState(path).open;
+};
+
+/**
+ * Hook that subscribes to the current state for a tree item.
+ * Designed to be passed to Tree component as useIsCurrent prop.
+ */
+export const useIsCurrent = (path: string[], _item?: any): boolean => {
+  return useNavTreeItemState(path).current;
+};
+
+/**
+ * Hook that subscribes to the alternateTree state for a tree item.
+ */
+export const useIsAlternateTree = (path: string[], _item?: any): boolean => {
+  return useNavTreeItemState(path).alternateTree ?? false;
+};

package/src/index.ts

@@ -2,8 +2,7 @@
 // Copyright 2023 DXOS.org
 //
 
-export { NavTreeCapabilities } from './capabilities';
-export { NavTreeEvents } from './events';
+export { NavTreeCapabilities, NavTreeEvents } from './types';
 export * from './NavTreePlugin';
 export * from './meta';
 export * from './util';