@dxos/react-ui-menu 0.8.4-main.84f28bd → 0.8.4-main.9735255

package/package.json

@@ -1,15 +1,20 @@
 {
   "name": "@dxos/react-ui-menu",
-  "version": "0.8.4-main.84f28bd",
+  "version": "0.8.4-main.9735255",
   "description": "Components for facilitating reactive and consistent menus.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dxos/dxos"
+  },
   "license": "MIT",
   "author": "DXOS.org",
-  "sideEffects": true,
+  "sideEffects": false,
   "type": "module",
   "exports": {
     ".": {
+      "source": "./src/index.ts",
       "types": "./dist/types/src/index.d.ts",
       "browser": "./dist/lib/browser/index.mjs",
       "node": "./dist/lib/node-esm/index.mjs"
@@ -24,39 +29,38 @@
     "src"
   ],
   "dependencies": {
-    "@preact-signals/safe-react": "^0.9.0",
-    "@preact/signals-react": "^3.2.0",
     "@radix-ui/react-context": "1.1.1",
     "@radix-ui/react-use-controllable-state": "1.1.0",
-    "@dxos/app-graph": "0.8.4-main.84f28bd",
-    "@dxos/invariant": "0.8.4-main.84f28bd",
-    "@dxos/keyboard": "0.8.4-main.84f28bd",
-    "@dxos/react-ui-attention": "0.8.4-main.84f28bd",
-    "@dxos/util": "0.8.4-main.84f28bd"
+    "@dxos/effect": "0.8.4-main.9735255",
+    "@dxos/app-graph": "0.8.4-main.9735255",
+    "@dxos/keyboard": "0.8.4-main.9735255",
+    "@dxos/invariant": "0.8.4-main.9735255",
+    "@dxos/react-ui-attention": "0.8.4-main.9735255",
+    "@dxos/ui-types": "0.8.4-main.9735255",
+    "@dxos/util": "0.8.4-main.9735255"
   },
   "devDependencies": {
-    "@effect-rx/rx-react": "0.38.0",
-    "@effect/platform": "0.88.0",
-    "@types/react": "~18.2.0",
-    "@types/react-dom": "~18.2.0",
-    "effect": "3.16.13",
-    "react": "~18.2.0",
-    "react-dom": "~18.2.0",
-    "vite": "5.4.7",
-    "@dxos/live-object": "0.8.4-main.84f28bd",
-    "@dxos/random": "0.8.4-main.84f28bd",
-    "@dxos/react-ui": "0.8.4-main.84f28bd",
-    "@dxos/react-ui-theme": "0.8.4-main.84f28bd",
-    "@dxos/storybook-utils": "0.8.4-main.84f28bd"
+    "@effect-atom/atom-react": "^0.4.6",
+    "@effect/platform": "0.93.6",
+    "@types/react": "~19.2.7",
+    "@types/react-dom": "~19.2.3",
+    "effect": "3.19.11",
+    "react": "~19.2.3",
+    "react-dom": "~19.2.3",
+    "vite": "7.1.9",
+    "@dxos/random": "0.8.4-main.9735255",
+    "@dxos/react-ui": "0.8.4-main.9735255",
+    "@dxos/storybook-utils": "0.8.4-main.9735255",
+    "@dxos/ui-theme": "0.8.4-main.9735255"
   },
   "peerDependencies": {
-    "@effect-rx/rx-react": "^0.34.1",
-    "@effect/platform": "^0.80.12",
-    "effect": "^3.13.3",
-    "react": "~18.2.0",
-    "react-dom": "~18.2.0",
-    "@dxos/react-ui": "0.8.4-main.84f28bd",
-    "@dxos/react-ui-theme": "0.8.4-main.84f28bd"
+    "@effect-atom/atom-react": "^0.4.6",
+    "@effect/platform": "0.93.6",
+    "effect": "3.19.11",
+    "react": "~19.2.3",
+    "react-dom": "~19.2.3",
+    "@dxos/react-ui": "0.8.4-main.9735255",
+    "@dxos/ui-theme": "0.8.4-main.9735255"
   },
   "publishConfig": {
     "access": "public"

package/src/builder.ts

@@ -3,16 +3,16 @@
 //
 
 import { invariant } from '@dxos/invariant';
+import type { MenuActionProperties, MenuItemGroupProperties } from '@dxos/ui-types';
 
 import type { ActionGraphProps } from './hooks';
-import type { MenuActionProperties, MenuItemGroupProperties } from './types';
 import { createMenuAction, createMenuItemGroup } from './util';
 
 export interface ActionGroupBuilder {
-  action<P extends {} = {}>(id: string, invoke: () => void, properties: P & MenuActionProperties): this;
+  action<P extends {} = {}>(id: string, props: P & MenuActionProperties, invoke: () => void): this;
   group<P extends {} = {}>(
     id: string,
-    properties: P & MenuItemGroupProperties,
+    props: P & MenuItemGroupProperties,
     cb: (builder: ActionGroupBuilder) => void,
   ): this;
 }
@@ -32,12 +32,6 @@ class MenuBuilderImpl implements MenuBuilder {
     private readonly _rootId: string,
   ) {}
 
-  action<P extends {} = {}>(id: string, invoke: () => void, properties: P & MenuActionProperties): this {
-    this._data.nodes.push(createMenuAction(id, invoke, properties));
-    this._data.edges.push({ source: this._rootId, target: id });
-    return this;
-  }
-
   root(props: MenuItemGroupProperties): this {
     invariant(this._rootId === 'root', 'Root group can only be at the top level');
     invariant(this._data.nodes.find((node) => node.id === 'root') === undefined, 'Root group can only be created once');
@@ -45,12 +39,18 @@ class MenuBuilderImpl implements MenuBuilder {
     return this;
   }
 
+  action<P extends {} = {}>(id: string, props: P & MenuActionProperties, invoke: () => void): this {
+    this._data.nodes.push(createMenuAction(id, invoke, props));
+    this._data.edges.push({ source: this._rootId, target: id });
+    return this;
+  }
+
   group<P extends {} = {}>(
     id: string,
-    properties: P & MenuItemGroupProperties,
+    props: P & MenuItemGroupProperties,
     cb: (builder: ActionGroupBuilder) => void,
   ): this {
-    this._data.nodes.push(createMenuItemGroup(id, properties));
+    this._data.nodes.push(createMenuItemGroup(id, props));
     this._data.edges.push({ source: this._rootId, target: id });
     cb(new MenuBuilderImpl(this._data, id));
     return this;

package/src/components/ActionLabel.tsx

@@ -4,16 +4,16 @@
 
 import React from 'react';
 
-import { type Action as GraphAction, type ActionGroup } from '@dxos/app-graph';
+import { type Node } from '@dxos/app-graph';
 import { keySymbols } from '@dxos/keyboard';
-import { toLocalizedString, useTranslation, type TFunction } from '@dxos/react-ui';
-import { mx, descriptionText } from '@dxos/react-ui-theme';
+import { type TFunction, toLocalizedString, useTranslation } from '@dxos/react-ui';
+import { descriptionText, mx } from '@dxos/ui-theme';
+import { type MenuActionProperties } from '@dxos/ui-types';
 
 import { translationKey } from '../translations';
-import { type MenuActionProperties } from '../types';
 import { getShortcut } from '../util';
 
-type Action = GraphAction<MenuActionProperties> | ActionGroup<Omit<MenuActionProperties, 'variant'>>;
+type Action = Node.Action<MenuActionProperties> | Node.ActionGroup<Omit<MenuActionProperties, 'variant'>>;
 
 export const ActionLabel = ({ action }: { action: Action }) => {
   const { t } = useTranslation(translationKey);

package/src/components/DropdownMenu.tsx

@@ -5,11 +5,13 @@
 import { useControllableState } from '@radix-ui/react-use-controllable-state';
 import React, { type MouseEvent, useCallback } from 'react';
 
-import { DropdownMenu as NaturalDropdownMenu, Icon, type DropdownMenuRootProps } from '@dxos/react-ui';
+import { type DropdownMenuRootProps, Icon, DropdownMenu as NaturalDropdownMenu } from '@dxos/react-ui';
+
+import { type MenuAction, type MenuItem, type MenuItemGroup } from '../types';
+import { executeMenuAction } from '../util';
 
 import { ActionLabel } from './ActionLabel';
 import { type MenuScopedProps, useMenu, useMenuItems } from './MenuContext';
-import { type MenuAction, type MenuItem, type MenuItemGroup } from '../types';
 
 export type DropdownMenuProps = DropdownMenuRootProps & {
   group?: MenuItemGroup;
@@ -59,17 +61,23 @@ const DropdownMenuRoot = ({
     onChange: onOpenChange,
   });
 
+  const { onAction } = useMenu('DropdownMenuRoot', __menuScope);
+
   const handleActionClick = useCallback(
     (action: MenuAction, event: MouseEvent) => {
       if (action.properties?.disabled) {
         return;
       }
       event.stopPropagation();
-      // TODO(thure): Why does Dialog’s modal-ness cause issues if we don’t explicitly close the menu here?
+      // TODO(thure): Why does Dialog's modal-ness cause issues if we don't explicitly close the menu here?
       setOptionsMenuOpen(false);
-      void action.data?.({ parent: group, caller });
+      if (onAction) {
+        onAction(action, { parent: group, caller });
+      } else {
+        void executeMenuAction(action, { parent: group, caller });
+      }
     },
-    [group, caller],
+    [group, caller, onAction],
   );
 
   const items = useMenuItems(group, propsItems);
@@ -80,7 +88,9 @@ const DropdownMenuRoot = ({
       <NaturalDropdownMenu.Portal>
         <NaturalDropdownMenu.Content>
           <NaturalDropdownMenu.Viewport>
-            {items?.map((item) => <DropdownMenuItem key={item.id} item={item} onClick={handleActionClick} />)}
+            {items?.map((item) => (
+              <DropdownMenuItem key={item.id} item={item} onClick={handleActionClick} />
+            ))}
           </NaturalDropdownMenu.Viewport>
           <NaturalDropdownMenu.Arrow />
         </NaturalDropdownMenu.Content>

package/src/components/MenuContext.tsx

@@ -2,14 +2,14 @@
 // Copyright 2025 DXOS.org
 //
 
-import { createContextScope, type Scope } from '@radix-ui/react-context';
+import { type Scope, createContextScope } from '@radix-ui/react-context';
 import React, { type PropsWithChildren, useMemo } from 'react';
 
 import { type MenuContextValue, type MenuItem, type MenuItemGroup } from '../types';
 
 export type MenuScopedProps<P> = P & { __menuScope?: Scope };
 
-const MENU_NAME = 'GraphMenu';
+const MENU_NAME = 'Menu';
 
 const [createMenuContext, createMenuScope] = createContextScope(MENU_NAME, []);
 
@@ -18,19 +18,29 @@ const [MenuContextProvider, useMenu] = createMenuContext<MenuContextValue>(MENU_
 export const menuContextDefaults: MenuContextValue = {
   iconSize: 5,
   useGroupItems: () => null,
+  onAction: undefined,
 };
 
 const useMenuScope = createMenuScope();
 
+type MenuProviderProps = PropsWithChildren<Partial<MenuContextValue>>;
+
 const MenuProvider = ({
   children,
   useGroupItems = menuContextDefaults.useGroupItems,
   iconSize = menuContextDefaults.iconSize,
   attendableId,
-}: PropsWithChildren<Partial<MenuContextValue>>) => {
+  onAction,
+}: MenuProviderProps) => {
   const { scope } = useMenuScope(undefined);
   return (
-    <MenuContextProvider useGroupItems={useGroupItems} iconSize={iconSize} attendableId={attendableId} scope={scope}>
+    <MenuContextProvider
+      useGroupItems={useGroupItems}
+      iconSize={iconSize}
+      attendableId={attendableId}
+      onAction={onAction}
+      scope={scope}
+    >
       {children}
     </MenuContextProvider>
   );
@@ -48,3 +58,5 @@ export const useMenuItems = (
 };
 
 export { useMenu, createMenuScope, MenuProvider };
+
+export type { MenuProviderProps };

package/src/components/ToolbarMenu.stories.tsx

@@ -0,0 +1,81 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { Atom } from '@effect-atom/atom-react';
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import React, { useMemo } from 'react';
+
+import { faker } from '@dxos/random';
+import { IconButton } from '@dxos/react-ui';
+import { withTheme } from '@dxos/react-ui/testing';
+import { withRegistry } from '@dxos/storybook-utils';
+
+import { MenuProvider, DropdownMenu as NaturalDropdownMenu, ToolbarMenu } from '../components';
+import { type ActionGraphProps, useMenuActions } from '../hooks';
+import { createActions, createNestedActions, createNestedActionsResolver, useMutateActions } from '../testing';
+import { translations } from '../translations';
+
+faker.seed(1234);
+
+const meta = {
+  title: 'ui/react-ui-menu/ToolbarMenu',
+  component: ToolbarMenu,
+  decorators: [withTheme, withRegistry],
+  parameters: {
+    translations,
+  },
+} satisfies Meta<typeof ToolbarMenu>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const DropdownMenu: Story = {
+  render: () => {
+    const actionsAtom = useMemo(() => {
+      const actions = createActions();
+      return Atom.make<ActionGraphProps>({
+        nodes: actions,
+        edges: actions.map((action) => ({ source: 'root', target: action.id })),
+      }).pipe(Atom.keepAlive);
+    }, []);
+    useMutateActions(actionsAtom);
+    const menu = useMenuActions(actionsAtom);
+
+    return (
+      <MenuProvider {...menu}>
+        <NaturalDropdownMenu.Root>
+          <NaturalDropdownMenu.Trigger asChild>
+            <IconButton icon='ph--list-checks--regular' label='Options' />
+          </NaturalDropdownMenu.Trigger>
+        </NaturalDropdownMenu.Root>
+      </MenuProvider>
+    );
+  },
+};
+
+export const Toolbar: Story = {
+  render: () => {
+    const nestedMenuActions = useMemo(() => createNestedActionsResolver(), []);
+
+    return (
+      <MenuProvider {...nestedMenuActions}>
+        <ToolbarMenu />
+      </MenuProvider>
+    );
+  },
+};
+
+export const UseMenuActionsToolbar: Story = {
+  render: () => {
+    useMutateActions(createNestedActions);
+    const menu = useMenuActions(createNestedActions);
+
+    return (
+      <MenuProvider {...menu}>
+        <ToolbarMenu />
+      </MenuProvider>
+    );
+  },
+};

package/src/components/ToolbarMenu.tsx

@@ -6,22 +6,24 @@ import React, { Fragment, useCallback } from 'react';
 
 import { Icon, Toolbar as NaturalToolbar, type ToolbarRootProps, useTranslation } from '@dxos/react-ui';
 import { useAttention } from '@dxos/react-ui-attention';
-import { mx, textBlockWidth, toolbarLayout } from '@dxos/react-ui-theme';
+import { mx, textBlockWidth, toolbarInactive, toolbarLayout } from '@dxos/ui-theme';
+import { type MenuActionProperties } from '@dxos/ui-types';
 
-import { actionLabel, ActionLabel } from './ActionLabel';
-import { DropdownMenu } from './DropdownMenu';
-import { type MenuScopedProps, useMenu, useMenuItems } from './MenuContext';
 import { translationKey } from '../translations';
 import {
   type MenuAction,
   type MenuItem,
-  isMenuGroup,
-  isSeparator,
   type MenuItemGroup,
-  type MenuActionProperties,
   type MenuMultipleSelectActionGroup,
   type MenuSingleSelectActionGroup,
+  isMenuGroup,
+  isSeparator,
 } from '../types';
+import { executeMenuAction } from '../util';
+
+import { ActionLabel, actionLabel } from './ActionLabel';
+import { DropdownMenu } from './DropdownMenu';
+import { type MenuScopedProps, useMenu, useMenuItems } from './MenuContext';
 
 export type ToolbarMenuDropdownMenuActionGroup = Omit<MenuActionProperties, 'variant' | 'icon'> & {
   variant: 'dropdownMenu';
@@ -52,14 +54,23 @@ export type ToolbarMenuActionProps = {
 };
 
 const ActionToolbarItem = ({ action, __menuScope }: MenuScopedProps<{ action: MenuAction }>) => {
-  const { iconSize } = useMenu('ActionToolbarItem', __menuScope);
+  const { iconSize, onAction } = useMenu('ActionToolbarItem', __menuScope);
   const { t } = useTranslation(translationKey);
-  const handleClick = useCallback(() => action.data?.(), [action]);
+
   const { icon, iconOnly = true, disabled, testId, hidden, classNames } = action.properties;
   const Root = icon ? NaturalToolbar.IconButton : NaturalToolbar.Button;
   const rootProps = icon
     ? { icon, size: iconSize, iconOnly, label: actionLabel(action, t) }
     : { children: <ActionLabel action={action} /> };
+
+  const handleClick = useCallback(() => {
+    if (onAction) {
+      onAction(action, {});
+    } else {
+      void executeMenuAction(action);
+    }
+  }, [action, onAction]);
+
   return hidden ? null : (
     <Root
       key={action.id}
@@ -91,7 +102,13 @@ const DropdownMenuToolbarItem = ({
   const Root = icon ? NaturalToolbar.IconButton : NaturalToolbar.Button;
   const labelAction = (group.properties as any).applyActive && activeItem ? (activeItem as MenuAction) : group;
   const rootProps = icon
-    ? { icon, size: iconSize, iconOnly, label: actionLabel(labelAction, t), caretDown: true }
+    ? {
+        icon,
+        size: iconSize,
+        iconOnly,
+        label: actionLabel(labelAction, t),
+        caretDown: true,
+      }
     : {
         children: (
           <>
@@ -100,6 +117,7 @@ const DropdownMenuToolbarItem = ({
           </>
         ),
       };
+
   return (
     <DropdownMenu.Root group={group} items={items}>
       <DropdownMenu.Trigger asChild>
@@ -110,14 +128,21 @@ const DropdownMenuToolbarItem = ({
 };
 
 const ToggleGroupItem = ({ group, action, __menuScope }: MenuScopedProps<ToolbarMenuActionProps>) => {
-  const { iconSize } = useMenu('ToggleGroupItem', __menuScope);
+  const { iconSize, onAction } = useMenu('ToggleGroupItem', __menuScope);
   const { t } = useTranslation(translationKey);
   const { icon, iconOnly = true, disabled, testId, hidden, classNames } = action.properties;
-  const handleClick = useCallback(() => action.data?.({ parent: group }), [action, group]);
+  const handleClick = useCallback(() => {
+    if (onAction) {
+      onAction(action, { parent: group });
+    } else {
+      void executeMenuAction(action, { parent: group });
+    }
+  }, [action, group, onAction]);
   const Root = icon ? NaturalToolbar.ToggleGroupIconItem : NaturalToolbar.ToggleGroupItem;
   const rootProps = icon
     ? { icon, size: iconSize, iconOnly, label: actionLabel(action, t) }
     : { children: <ActionLabel action={action} /> };
+
   return hidden ? null : (
     <Root
       key={action.id}
@@ -139,8 +164,9 @@ const ToggleGroupToolbarItem = ({
 }: MenuScopedProps<ToolbarMenuActionGroupProps>) => {
   const items = useMenuItems(group, propsItems, 'ToggleGroupToolbarItem', __menuScope);
   const { selectCardinality, value } = group.properties;
+
   return (
-    // TODO(thure): The type here is difficult to manage, what do?
+    // TODO(thure): Fix.
     // @ts-ignore
     <NaturalToolbar.ToggleGroup type={selectCardinality} value={value}>
       {
@@ -153,41 +179,49 @@ const ToggleGroupToolbarItem = ({
   );
 };
 
+// TODO(burdon): Reconcile with react-ui/Toolbar (incl. textBlockWidth)
 export const ToolbarMenu = ({
   __menuScope,
   classNames,
-  textBlockWidth: wrapContents,
+  textBlockWidth: textBlockWidthProp,
   ...props
 }: MenuScopedProps<ToolbarMenuProps>) => {
   const items = useMenuItems(undefined, undefined, 'ToolbarMenu', __menuScope);
   const { attendableId } = useMenu('ToolbarMenu', __menuScope);
   const { hasAttention } = useAttention(attendableId);
-  const InnerRoot = wrapContents ? 'div' : Fragment;
-  const innerRootProps = wrapContents ? { role: 'none', className: mx(textBlockWidth, toolbarLayout, 'bs-full') } : {};
+  const InnerRoot = textBlockWidthProp ? 'div' : Fragment;
+  const innerRootProps = textBlockWidthProp
+    ? { role: 'none', className: mx(textBlockWidth, toolbarLayout, 'bs-full') }
+    : {};
+
   return (
     <NaturalToolbar.Root
       {...props}
-      layoutManaged={wrapContents}
-      classNames={[attendableId && !hasAttention && '*:opacity-20 !bg-transparent', classNames]}
+      classNames={[attendableId && !hasAttention && toolbarInactive, classNames]}
+      layoutManaged={textBlockWidthProp}
     >
       <InnerRoot {...innerRootProps}>
-        {items?.map((item: MenuItem, i: number) =>
-          isSeparator(item) ? (
-            <NaturalToolbar.Separator key={i} variant={item.properties.variant} />
-          ) : isMenuGroup(item) ? (
-            item.properties.variant === 'dropdownMenu' ? (
-              // TODO(thure): Figure out type narrowing that doesn’t require so much use of `as`.
-              <DropdownMenuToolbarItem key={item.id} group={item as MenuItemGroup<ToolbarMenuActionGroupProperties>} />
-            ) : (
-              // TODO(thure): Figure out type narrowing that doesn’t require so much use of `as`.
-              <ToggleGroupToolbarItem key={item.id} group={item as MenuItemGroup<ToolbarMenuActionGroupProperties>} />
-            )
-          ) : (
-            // TODO(thure): Figure out type narrowing that doesn’t require so much use of `as`.
-            <ActionToolbarItem key={item.id} action={item as MenuAction} />
-          ),
-        )}
+        {items?.map((item: MenuItem, i: number) => (
+          <ToolbarMenuItem key={item.id ?? i} item={item} />
+        ))}
       </InnerRoot>
     </NaturalToolbar.Root>
   );
 };
+
+const ToolbarMenuItem = ({ item }: { item: MenuItem }) => {
+  if (isSeparator(item)) {
+    return <NaturalToolbar.Separator variant={item.properties.variant} />;
+  }
+
+  // TODO(thure): Figure out type narrowing that doesn’t require so much use of `as`.
+  if (isMenuGroup(item)) {
+    if (item.properties.variant === 'dropdownMenu') {
+      return <DropdownMenuToolbarItem group={item as MenuItemGroup<ToolbarMenuActionGroupProperties>} />;
+    } else {
+      return <ToggleGroupToolbarItem group={item as MenuItemGroup<ToolbarMenuActionGroupProperties>} />;
+    }
+  }
+
+  return <ActionToolbarItem action={item as MenuAction} />;
+};

package/src/hooks/useMenuActions.ts

@@ -2,14 +2,14 @@
 // Copyright 2025 DXOS.org
 //
 
-import { RegistryContext, type Rx, useRxValue } from '@effect-rx/rx-react';
-import { useCallback, useContext, useEffect, useState } from 'react';
+import { type Atom, RegistryContext, useAtomValue } from '@effect-atom/atom-react';
+import { useCallback, useContext, useEffect, useRef } from 'react';
 
-import { type Edge, type Edges, Graph, type NodeArg, type Node, ROOT_ID } from '@dxos/app-graph';
+import { Graph, Node } from '@dxos/app-graph';
 
 import { type MenuItem, type MenuItemGroup } from '../types';
 
-const edgesArrayToRecord = (edges: Edge[]): Record<string, Edges> => {
+const edgesArrayToRecord = (edges: Graph.Edge[]): Record<string, Graph.Edges> => {
   return Object.fromEntries(
     Object.entries(
       edges.reduce((acc: Record<string, { inbound: string[]; outbound: string[] }>, { source, target }) => {
@@ -36,30 +36,44 @@ const edgesArrayToRecord = (edges: Edge[]): Record<string, Edges> => {
   );
 };
 
-export type ActionGraphNodes = NodeArg<any>[];
-export type ActionGraphEdges = Edge[];
-export type ActionGraphProps = { nodes: ActionGraphNodes; edges: ActionGraphEdges };
+export type ActionGraphNodes = Node.NodeArg<any>[];
+export type ActionGraphEdges = Graph.Edge[];
+export type ActionGraphProps = {
+  nodes: ActionGraphNodes;
+  edges: ActionGraphEdges;
+};
+
+export type MenuActions = {
+  useGroupItems: (sourceNode?: MenuItemGroup) => MenuItem[];
+};
 
-export const useMenuActions = (props: Rx.Rx<ActionGraphProps>) => {
+export const useMenuActions = (props: Atom.Atom<ActionGraphProps>): MenuActions => {
   const registry = useContext(RegistryContext);
-  const menuGraphProps = useRxValue(props);
+  const menuGraphProps = useAtomValue(props);
 
-  const [graph] = useState(
-    new Graph({
+  // Create graph once, then update it when props change.
+  const graphRef = useRef<Graph.WritableGraph | null>(null);
+  if (!graphRef.current) {
+    graphRef.current = Graph.make({
       registry,
-      nodes: menuGraphProps.nodes as Node[],
+      nodes: menuGraphProps.nodes as Node.Node[],
       edges: edgesArrayToRecord(menuGraphProps.edges),
-    }),
-  );
+    });
+  }
+  const graph = graphRef.current;
 
+  // Update graph nodes when props change (after render completes).
+  const prevPropsRef = useRef(menuGraphProps);
   useEffect(() => {
-    graph.addNodes(menuGraphProps.nodes);
-    graph.addEdges(menuGraphProps.edges);
-  }, [menuGraphProps]);
+    if (prevPropsRef.current !== menuGraphProps) {
+      prevPropsRef.current = menuGraphProps;
+      graph.pipe(Graph.addNodes(menuGraphProps.nodes), Graph.addEdges(menuGraphProps.edges));
+    }
+  }, [graph, menuGraphProps]);
 
   const useGroupItems = useCallback(
     (sourceNode?: MenuItemGroup) => {
-      const items = useRxValue(graph.connections(sourceNode?.id || ROOT_ID)) as MenuItem[];
+      const items = useAtomValue(graph.connections(sourceNode?.id || Node.RootId)) as MenuItem[];
       return items;
     },
     [graph],

package/src/index.ts

@@ -2,8 +2,6 @@
 // Copyright 2024 DXOS.org
 //
 
-export { rxFromSignal } from '@dxos/app-graph';
-
 export * from './components';
 export * from './hooks';
 export * from './types';