@dxos/plugin-navtree 0.8.4-main.69d29f4 → 0.8.4-main.6fa680abb7

package/src/{components → containers/NavTreeContainer}/NavTreeContainer.tsx

@@ -4,165 +4,107 @@
 
 import { monitorForElements } from '@atlaskit/pragmatic-drag-and-drop/element/adapter';
 import { type Instruction, extractInstruction } from '@atlaskit/pragmatic-drag-and-drop-hitbox/tree-item';
-import React, { forwardRef, memo, useCallback, useEffect, useMemo } from 'react';
+import React, { forwardRef, memo, useCallback, useEffect, useMemo, useRef } from 'react';
 
-import { Common } from '@dxos/app-framework';
-import { Surface, useAppGraph, useLayout, useOperationInvoker } from '@dxos/app-framework/react';
-import { PLANK_COMPANION_TYPE } from '@dxos/plugin-deck/types';
+import { Surface, useOperationInvoker } from '@dxos/app-framework/ui';
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { useAppGraph, useLayout } from '@dxos/app-toolkit/ui';
 import { Graph, Node, useActionRunner } from '@dxos/plugin-graph';
-import { useConnections, useActions as useGraphActions } from '@dxos/plugin-graph';
 import { useMediaQuery, useSidebars } from '@dxos/react-ui';
-import { type TreeData, type TreeItemDataProps, isTreeData } from '@dxos/react-ui-list';
-import { mx } from '@dxos/ui-theme';
-import { arrayMove, byPosition } from '@dxos/util';
+import { type TreeData, isTreeData } from '@dxos/react-ui-list';
+import { arrayMove } from '@dxos/util';
 
-import { useIsAlternateTree, useIsCurrent, useIsOpen, useNavTreeState } from '../hooks';
-import { meta } from '../meta';
-import { type FlattenedActions, type NavTreeItemGraphNode } from '../types';
-import { getChildren, getParent, resolveMigrationOperation } from '../util';
-
-import { NAV_TREE_ITEM, NavTree } from './NavTree';
-import { NavTreeContext } from './NavTreeContext';
-import { type NavTreeContextValue } from './types';
+import { NAV_TREE_ITEM, NavTree, NavTreeContext } from '../../components';
+import { useNavTreeModel, useNavTreeState } from '../../hooks';
+import { meta } from '../../meta';
+import { type NavTreeItemGraphNode } from '../../types';
+import { filterItems, getParent, resolveMigrationOperation } from '../../util';
 
 // TODO(thure): Is NavTree truly authoritative in this regard?
 export const NODE_TYPE = 'dxos/app-graph/node';
 
-const renderItemEnd = ({ node, open }: { node: Node.Node; open: boolean }) => (
-  <Surface role='navtree-item-end' data={{ id: node.id, subject: node.data, open }} limit={1} />
-);
-
-const getChildrenFilter = (node: Node.Node): node is Node.Node =>
-  !Node.isActionLike(node) && node.type !== PLANK_COMPANION_TYPE && node.properties.disposition !== 'hidden';
-
-const filterItems = (node: Node.Node, disposition?: string) => {
-  if (!disposition && (node.properties.disposition === 'hidden' || node.properties.disposition === 'alternate-tree')) {
-    return false;
-  } else if (!disposition) {
-    const action = Node.isAction(node);
-    return !action || node.properties.disposition === 'item';
-  } else {
-    return node.properties.disposition === disposition;
-  }
+// TODO(wittjosiah): Avoid using Surface within the navtree, prefer declarative data flow.
+const NavTreeItemEnd = ({ node, open }: { node: Node.Node; open: boolean }) => {
+  const data = useMemo(() => ({ id: node.id, subject: node.data, open }), [node.id, node.data, open]);
+  return <Surface.Surface role='navtree-item-end' data={data} limit={1} />;
 };
 
 const getItems = (graph: Graph.ReadableGraph, node?: Node.Node, disposition?: string) => {
-  return Graph.getConnections(graph, node?.id ?? Node.RootId, 'outbound').filter((node) =>
-    filterItems(node, disposition),
-  );
-};
-
-const useItems = (node?: Node.Node, options?: { disposition?: string; sort?: boolean }) => {
-  const { graph } = useAppGraph();
-  const connections = useConnections(graph, node?.id ?? Node.RootId);
-  const filtered = connections.filter((node) => filterItems(node, options?.disposition));
-  return options?.sort ? filtered.toSorted((a, b) => byPosition(a.properties, b.properties)) : filtered;
-};
-
-const useActions = (node: Node.Node): FlattenedActions => {
-  const { graph } = useAppGraph();
-  const actions = useGraphActions(graph, node.id);
-
-  return useMemo(
-    () =>
-      actions.reduce(
-        (acc: FlattenedActions, arg) => {
-          if (arg.properties.disposition === 'item') {
-            return acc;
-          }
-
-          acc.actions.push(arg);
-          if (!Node.isAction(arg)) {
-            const actionGroup = Graph.getActions(graph, arg.id);
-            acc.groupedActions[arg.id] = actionGroup;
-          }
-          return acc;
-        },
-        { actions: [], groupedActions: {} },
-      ),
-    [actions],
-  );
+  return Graph.getConnections(graph, node?.id ?? Node.RootId, 'child').filter((node) => filterItems(node, disposition));
 };
 
 export type NavTreeContainerProps = {
   popoverAnchorId?: string;
-  topbar?: boolean;
-} & Pick<NavTreeContextValue, 'tab'>;
+  tab: string;
+};
 
 export const NavTreeContainer$ = forwardRef<HTMLDivElement, NavTreeContainerProps>(
-  ({ tab, popoverAnchorId, topbar }, forwardedRef) => {
+  ({ tab, popoverAnchorId }, forwardedRef) => {
     const [isLg] = useMediaQuery('lg');
     const { invokeSync, invokePromise } = useOperationInvoker();
     const runAction = useActionRunner();
     const { graph } = useAppGraph();
     const { getItem, setItem } = useNavTreeState();
     const layout = useLayout();
+    const model = useNavTreeModel(Node.RootId);
     const { navigationSidebarState } = useSidebars(meta.id);
+    const latestRef = useRef({
+      tab,
+      activeItems: layout.active,
+      navigationSidebarState,
+      isLg,
+    });
 
-    const getProps = useCallback(
-      (node: Node.Node, path: string[]): TreeItemDataProps => {
-        const children = getChildren(graph, node, path).filter(getChildrenFilter);
-        const parentOf =
-          children.length > 0 ? children.map(({ id }) => id) : node.properties.role === 'branch' ? [] : undefined;
-        return {
-          id: node.id,
-          parentOf,
-          disabled: node.properties.disabled,
-          label: node.properties.label ?? node.id,
-          className: mx(node.properties.className, node.properties.modified && 'italic'), // TODO(burdon): Italic?
-          headingClassName: node.properties.headingClassName,
-          icon: node.properties.icon,
-          iconHue: node.properties.iconHue,
-          testId: node.properties.testId,
-        };
-      },
-      [graph],
-    );
-
-    const loadDescendents = useCallback(
-      (node: Node.Node) => {
-        Graph.expand(graph, node.id, 'outbound');
-        // Load one level deeper, which resolves some juddering observed on open/close.
-        Graph.getConnections(graph, node.id, 'outbound').forEach((child) => {
-          Graph.expand(graph, child.id, 'outbound');
-        });
-      },
-      [graph],
-    );
+    useEffect(() => {
+      latestRef.current = {
+        tab,
+        activeItems: layout.active,
+        navigationSidebarState,
+        isLg,
+      };
+    }, [tab, layout.active, navigationSidebarState, isLg]);
 
     const handleOpenChange = useCallback(
       ({ item: { id }, path, open }: { item: Node.Node; path: string[]; open: boolean }) => {
         // TODO(thure): This might become a localstorage leak; openItemIds that no longer exist should be removed from this map.
         setItem(path, 'open', open);
-        Graph.expand(graph, id, 'outbound');
+        Graph.expand(graph, id, 'child');
       },
-      [graph],
+      [graph, setItem],
     );
 
     const handleTabChange = useCallback(
       (node: NavTreeItemGraphNode) => {
-        invokeSync(Common.LayoutOperation.UpdateSidebar, {
+        Graph.expand(graph, node.id, 'child');
+
+        const {
+          tab: activeTab,
+          activeItems,
+          navigationSidebarState: currentSidebarState,
+          isLg: latestIsLg,
+        } = latestRef.current;
+        invokeSync(LayoutOperation.UpdateSidebar, {
           state:
-            node.id === tab
-              ? navigationSidebarState === 'expanded'
-                ? isLg
+            node.id === activeTab
+              ? currentSidebarState === 'expanded'
+                ? latestIsLg
                   ? 'collapsed'
                   : 'closed'
                 : 'expanded'
               : 'expanded',
         });
 
-        invokeSync(Common.LayoutOperation.SwitchWorkspace, { subject: node.id });
+        invokeSync(LayoutOperation.SwitchWorkspace, { subject: node.id });
 
         // Open the first item if the workspace is empty.
-        if (layout.active.length === 0) {
+        if (activeItems.length === 0) {
           const [item] = getItems(graph, node).filter((node) => !Node.isActionLike(node));
           if (item && item.data) {
-            invokeSync(Common.LayoutOperation.Open, { subject: [item.id] });
+            invokeSync(LayoutOperation.Open, { subject: [item.id] });
           }
         }
       },
-      [invokeSync, layout.active, tab, navigationSidebarState, isLg],
+      [invokeSync, graph],
     );
 
     const blockInstruction = useCallback(
@@ -187,20 +129,20 @@ export const NavTreeContainer$ = forwardRef<HTMLDivElement, NavTreeContainerProp
         }
 
         if (Node.isAction(node)) {
-          const [parent] = Graph.getConnections(graph, node.id, 'inbound');
+          const [parent] = Graph.getConnections(graph, node.id, Node.childRelation('inbound'));
           if (parent) {
-            void runAction(node, { parent, caller: NAV_TREE_ITEM });
+            void runAction(node, { parent, path, caller: NAV_TREE_ITEM });
           }
           return;
         }
 
         const current = getItem(path).current;
         if (!current) {
-          invokeSync(Common.LayoutOperation.Open, { subject: [node.id], key: node.properties.key });
+          invokeSync(LayoutOperation.Open, { subject: [node.id], key: node.properties.key });
         } else if (option) {
-          invokeSync(Common.LayoutOperation.Close, { subject: [node.id] });
+          invokeSync(LayoutOperation.Close, { subject: [node.id] });
         } else {
-          void invokePromise(Common.LayoutOperation.ScrollIntoView, { subject: node.id });
+          void invokePromise(LayoutOperation.ScrollIntoView, { subject: node.id });
         }
 
         const defaultAction = Graph.getActions(graph, node.id).find(
@@ -211,13 +153,13 @@ export const NavTreeContainer$ = forwardRef<HTMLDivElement, NavTreeContainerProp
         }
 
         if (!isLg) {
-          invokeSync(Common.LayoutOperation.UpdateSidebar, { state: 'closed' });
+          invokeSync(LayoutOperation.UpdateSidebar, { state: 'closed' });
         }
       },
-      [graph, invokeSync, invokePromise, getItem, isLg, runAction],
+      [graph, invokeSync, invokePromise, getItem, runAction, isLg],
     );
 
-    const handleBack = useCallback(() => invokeSync(Common.LayoutOperation.RevertWorkspace), [invokeSync]);
+    const handleBack = useCallback(() => invokeSync(LayoutOperation.RevertWorkspace), [invokeSync]);
 
     // TODO(wittjosiah): Factor out hook.
     useEffect(() => {
@@ -235,8 +177,9 @@ export const NavTreeContainer$ = forwardRef<HTMLDivElement, NavTreeContainerProp
             const targetNode = target.data.item as NavTreeItemGraphNode;
             const sourcePath = source.data.path as string[];
             const targetPath = target.data.path as string[];
+            const sameParent = sourcePath.slice(0, -1).join() === targetPath.slice(0, -1).join();
             const operation =
-              sourcePath.slice(0, -1).join() === targetPath.slice(0, -1).join() && instruction.type !== 'make-child'
+              sameParent && instruction.type !== 'make-child'
                 ? 'rearrange'
                 : resolveMigrationOperation(graph, sourceNode, targetPath, targetNode);
             const sourceParent = getParent(graph, sourceNode, sourcePath);
@@ -265,7 +208,7 @@ export const NavTreeContainer$ = forwardRef<HTMLDivElement, NavTreeContainerProp
               }
               case 'transfer': {
                 const target = instruction.type === 'make-child' ? targetNode : targetParent;
-                if (!target?.properties.onTransferStart || !sourceParent?.properties.onTransferEnd) {
+                if (!target?.properties.onTransferStart || target?.id === sourceParent?.id) {
                   break;
                 }
                 void target?.properties.onTransferStart(sourceNode, migrationIndex);
@@ -285,50 +228,41 @@ export const NavTreeContainer$ = forwardRef<HTMLDivElement, NavTreeContainerProp
       [setItem],
     );
 
+    const onItemHover = useCallback(({ item }: { item: Node.Node }) => Graph.expand(graph, item.id, 'child'), [graph]);
+
     const navTreeContextValue = useMemo(
       () => ({
+        model,
+        popoverAnchorId,
+        renderItemEnd: NavTreeItemEnd,
         blockInstruction,
         canDrop,
         canSelect,
-        getProps,
-        useIsAlternateTree,
-        useIsCurrent,
-        useIsOpen,
-        loadDescendents,
+        setAlternateTree,
         onBack: handleBack,
         onOpenChange: handleOpenChange,
         onSelect: handleSelect,
         onTabChange: handleTabChange,
-        popoverAnchorId,
-        renderItemEnd,
-        setAlternateTree,
-        tab,
-        topbar,
-        useActions,
-        useItems,
+        onItemHover,
       }),
       [
+        model,
+        popoverAnchorId,
         blockInstruction,
         canDrop,
         canSelect,
-        getProps,
+        setAlternateTree,
         handleBack,
         handleOpenChange,
         handleSelect,
         handleTabChange,
-        loadDescendents,
-        popoverAnchorId,
-        renderItemEnd,
-        setAlternateTree,
-        tab,
-        topbar,
-        useActions,
+        onItemHover,
       ],
     );
 
     return (
       <NavTreeContext.Provider value={navTreeContextValue}>
-        <NavTree id={Node.RootId} root={Graph.getRoot(graph)} open={layout.sidebarOpen} ref={forwardedRef} />
+        <NavTree id={Node.RootId} root={Graph.getRoot(graph)} tab={tab} open={layout.sidebarOpen} ref={forwardedRef} />
       </NavTreeContext.Provider>
     );
   },

package/src/containers/NavTreeContainer/index.ts

@@ -0,0 +1,6 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+export { NavTreeContainer, NODE_TYPE } from './NavTreeContainer';
+export { NavTreeContainer as default } from './NavTreeContainer';

package/src/{components → containers/NavTreeDocumentTitle}/NavTreeDocumentTitle.tsx

@@ -7,7 +7,7 @@ import { type Node } from '@dxos/app-graph';
 import { toLocalizedString, useTranslation } from '@dxos/react-ui';
 import { osTranslations } from '@dxos/ui-theme';
 
-import { meta } from '../meta';
+import { meta } from '../../meta';
 
 export const NavTreeDocumentTitle = ({ node }: { node?: Node.Node }) => {
   const { t } = useTranslation(meta.id);

package/src/containers/NavTreeDocumentTitle/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { NavTreeDocumentTitle } from './NavTreeDocumentTitle';
+
+export default NavTreeDocumentTitle;

package/src/containers/index.ts

@@ -0,0 +1,12 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { type ComponentType, lazy } from 'react';
+
+export { NODE_TYPE } from './NavTreeContainer';
+
+export const CommandsDialogContent: ComponentType<any> = lazy(() => import('./CommandsDialogContent'));
+export const CommandsTrigger: ComponentType<any> = lazy(() => import('./CommandsTrigger'));
+export const NavTreeContainer: ComponentType<any> = lazy(() => import('./NavTreeContainer'));
+export const NavTreeDocumentTitle: ComponentType<any> = lazy(() => import('./NavTreeDocumentTitle'));

package/src/experimental/Tree.stories.tsx

@@ -3,10 +3,10 @@
 //
 
 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 { Icon, IconButton, Panel, ScrollArea } from '@dxos/react-ui';
 import { withLayout, withTheme } from '@dxos/react-ui/testing';
 import { mx } from '@dxos/ui-theme';
 
@@ -14,28 +14,6 @@ import { type ItemMap, Tree, type TreeNodeData, type TreeProps, visitNodes, visi
 
 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 is-[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,49 +145,68 @@ 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 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>
+    <Panel.Root>
+      <Panel.Content asChild>
+        <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-sm bg-white dark:bg-neutral-850',
+                    header: mx('rounded-t bg-neutral-50 dark:bg-neutral-900', !open && 'rounded-b'),
+                  };
+                }
+              }}
+            />
+          </ScrollArea.Viewport>
+        </ScrollArea.Root>
+      </Panel.Content>
+      <Panel.Statusbar>
+        <div className='flex items-center my-2 px-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>
+      </Panel.Statusbar>
+    </Panel.Root>
   );
 };
 
 const meta = {
   title: 'plugins/plugin-navtree/experimental/Tree',
   component: Tree,
-  decorators: [withTheme, withLayout({ layout: 'column' })],
+  decorators: [withTheme(), withLayout({ layout: 'column', classNames: 'w-[20rem]' })],
+  parameters: {
+    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

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

package/src/hooks/index.ts

@@ -0,0 +1,8 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './useActions';
+export * from './useLoadDescendents';
+export * from './useNavTreeModel';
+export * from './useNavTreeState';

package/src/hooks/useActions.ts

@@ -0,0 +1,34 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useMemo } from 'react';
+
+import { useAppGraph } from '@dxos/app-toolkit/ui';
+import { Graph, Node, useActions as useGraphActions } from '@dxos/plugin-graph';
+
+import { type FlattenedActions } from '../types';
+
+/** Returns flattened actions and grouped sub-actions for a given graph node. */
+export const useActions = (node: Node.Node): FlattenedActions => {
+  const { graph } = useAppGraph();
+  const actions = useGraphActions(graph, node.id);
+
+  return useMemo(() => {
+    return actions.reduce(
+      (acc: FlattenedActions, arg) => {
+        if (arg.properties.disposition === 'item') {
+          return acc;
+        }
+
+        acc.actions.push(arg);
+        if (!Node.isAction(arg)) {
+          const actionGroup = Graph.getActions(graph, arg.id);
+          acc.groupedActions[arg.id] = actionGroup;
+        }
+        return acc;
+      },
+      { actions: [], groupedActions: {} },
+    );
+  }, [actions]);
+};

package/src/hooks/useLoadDescendents.ts

@@ -0,0 +1,23 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useEffect } from 'react';
+
+import { type Node } from '@dxos/app-graph';
+import { useAppGraph } from '@dxos/app-toolkit/ui';
+import { Graph } from '@dxos/plugin-graph';
+
+/**
+ * Expands a root node in the app graph.
+ */
+export const useLoadDescendents = (root?: Node.Node) => {
+  const { graph } = useAppGraph();
+  useEffect(() => {
+    if (!root) {
+      return;
+    }
+
+    Graph.expand(graph, root.id, 'child');
+  }, [graph, root]);
+};