@dxos/plugin-simple-layout 0.8.4-main.bc674ce → 0.8.4-main.c85a9c8dae

package/src/hooks/useDrawerActions.ts

@@ -0,0 +1,98 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Atom } from '@effect-atom/atom-react';
+import * as Effect from 'effect/Effect';
+import { useMemo } from 'react';
+
+import { useCapability, useOperationInvoker } from '@dxos/app-framework/ui';
+import { useAppGraph } from '@dxos/app-toolkit/ui';
+import { Node, useActionRunner } from '@dxos/plugin-graph';
+import { useTranslation } from '@dxos/react-ui';
+import { type ActionExecutor, type ActionGraphProps, createGapSeparator } from '@dxos/react-ui-menu';
+
+import { useMobileLayout } from '../components';
+import { meta } from '../meta';
+import { SimpleLayoutState as SimpleLayoutStateCapability } from '../types';
+
+import { createCompanionActions } from './actions';
+import { useSimpleLayoutState } from './useSimpleLayoutState';
+
+export type DrawerActions = {
+  /** Action graph atom for the drawer. */
+  actions: Atom.Atom<ActionGraphProps>;
+  /** Action executor callback. */
+  onAction: ActionExecutor;
+};
+
+/**
+ * Builds the drawer actions including companion tabs and toolbar buttons.
+ */
+export const useDrawerActions = (consumerName: string): DrawerActions => {
+  const { t } = useTranslation(meta.id);
+  const stateAtom = useCapability(SimpleLayoutStateCapability);
+  const { graph } = useAppGraph();
+  const runAction = useActionRunner();
+  const { invokeSync } = useOperationInvoker();
+  const { updateState } = useSimpleLayoutState();
+  const { keyboardOpen } = useMobileLayout(consumerName);
+
+  // Create a computed atom that derives everything from graph connections and state.
+  const actionsAtom = useMemo(
+    () =>
+      Atom.make((get): ActionGraphProps => {
+        // Derive drawer state from state atom.
+        const state = get(stateAtom);
+
+        // Add companion tab actions.
+        const { nodes, edges } = createCompanionActions(graph, stateAtom, get, {
+          idPrefix: 'drawer',
+          selectedVariant: state.companionVariant,
+          invokeSync,
+        });
+
+        // Add gap separator before toolbar buttons.
+        const gapSeparator = createGapSeparator('drawer-gap');
+        nodes.push(...gapSeparator.nodes);
+        edges.push(...gapSeparator.edges);
+
+        // Add expand/collapse toggle button (hidden when keyboard is open).
+        if (!keyboardOpen) {
+          const isExpanded = state.drawerState === 'expanded';
+          const toggleExpandAction = {
+            id: 'drawer-toggle-expand',
+            type: Node.ActionType,
+            properties: {
+              icon: isExpanded ? 'ph--arrow-down--regular' : 'ph--arrow-up--regular',
+              label: isExpanded ? t('collapse drawer label') : t('expand drawer label'),
+              iconOnly: true,
+            },
+            data: () =>
+              Effect.sync(() => updateState((state) => ({ ...state, drawerState: isExpanded ? 'open' : 'expanded' }))),
+          };
+          nodes.push(toggleExpandAction);
+          edges.push({ source: 'root', target: toggleExpandAction.id, relation: 'child' });
+        }
+
+        // Add close button.
+        const closeAction = {
+          id: 'drawer-close',
+          type: Node.ActionType,
+          properties: {
+            icon: 'ph--x--regular',
+            label: t('close drawer label'),
+            iconOnly: true,
+          },
+          data: () => Effect.sync(() => updateState((state) => ({ ...state, drawerState: 'closed' }))),
+        };
+        nodes.push(closeAction);
+        edges.push({ source: 'root', target: closeAction.id, relation: 'child' });
+
+        return { nodes, edges };
+      }),
+    [graph, stateAtom, invokeSync, updateState, keyboardOpen, t],
+  );
+
+  return { actions: actionsAtom, onAction: runAction };
+};

package/src/hooks/useNavbarActions.ts

@@ -0,0 +1,86 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Atom } from '@effect-atom/atom-react';
+import { useMemo } from 'react';
+
+import { useCapability, useOperationInvoker } from '@dxos/app-framework/ui';
+import { useAppGraph } from '@dxos/app-toolkit/ui';
+import { Node, useActionRunner } from '@dxos/plugin-graph';
+import { useTranslation } from '@dxos/react-ui';
+import {
+  type ActionExecutor,
+  type ActionGraphProps,
+  createGapSeparator,
+  createMenuItemGroup,
+} from '@dxos/react-ui-menu';
+
+import { meta } from '../meta';
+import { SimpleLayoutState } from '../types';
+
+import { createCompanionActions } from './actions';
+
+const MAIN_MENU_GROUP_ID = 'navbar-main-menu';
+
+export type NavbarActions = {
+  /** Action graph atom for the navbar. */
+  actions: Atom.Atom<ActionGraphProps>;
+  /** Action executor callback. */
+  onAction: ActionExecutor;
+};
+
+/**
+ * Builds the navbar actions including companion icons, separator, and main menu dropdown.
+ * Derives everything from graph connection atoms for proper reactivity.
+ */
+export const useNavbarActions = (): NavbarActions => {
+  const { t } = useTranslation(meta.id);
+  const { graph } = useAppGraph();
+  const runAction = useActionRunner();
+  const { invokeSync } = useOperationInvoker();
+  const stateAtom = useCapability(SimpleLayoutState);
+
+  // Create a computed atom that derives everything from graph connections and state.
+  const actionsAtom = useMemo(
+    () =>
+      Atom.make((get): ActionGraphProps => {
+        // Add companion actions.
+        const { nodes, edges } = createCompanionActions(graph, stateAtom, get, {
+          idPrefix: 'navbar',
+          invokeSync,
+        });
+
+        // Add gap separator.
+        const gapSeparator = createGapSeparator('navbar-gap');
+        nodes.push(...gapSeparator.nodes);
+        edges.push(...gapSeparator.edges);
+
+        // Add main menu dropdown group.
+        const mainMenuGroup = createMenuItemGroup(MAIN_MENU_GROUP_ID, {
+          variant: 'dropdownMenu',
+          icon: 'ph--list--regular',
+          iconOnly: true,
+          label: t('main menu label'),
+          testId: 'simpleLayoutPlugin.addSpace',
+        });
+        nodes.push(mainMenuGroup);
+        edges.push({ source: 'root', target: mainMenuGroup.id, relation: 'child' });
+
+        // Get menu actions from root actions (on 'action' edge relation).
+        const rootActions = get(graph.actions(Node.RootId));
+        const menuActions = rootActions.filter((node) => node.properties.disposition === 'menu');
+
+        // Add menu actions as children of the dropdown group.
+        menuActions.forEach((menuAction) => {
+          nodes.push(menuAction as ActionGraphProps['nodes'][number]);
+          edges.push({ source: MAIN_MENU_GROUP_ID, target: menuAction.id, relation: 'child' });
+        });
+
+        return { nodes, edges };
+      }),
+    [graph, stateAtom, invokeSync, t],
+  );
+
+  return { actions: actionsAtom, onAction: runAction };
+};

package/src/hooks/useSimpleLayoutState.ts

@@ -5,18 +5,18 @@
 import { RegistryContext, useAtomValue } from '@effect-atom/atom-react';
 import { useCallback, useContext } from 'react';
 
-import { useCapability } from '@dxos/app-framework/react';
+import { useCapability } from '@dxos/app-framework/ui';
 
-import { type SimpleLayoutState, SimpleLayoutState as SimpleLayoutStateCapability } from '../types';
+import { SimpleLayoutState } from '../types';
 
-export type SimpleLayoutStateHook = {
+export type UseSimpleLayoutState = {
   state: SimpleLayoutState;
   updateState: (fn: (current: SimpleLayoutState) => SimpleLayoutState) => void;
 };
 
-export const useSimpleLayoutState = (): SimpleLayoutStateHook => {
+export const useSimpleLayoutState = (): UseSimpleLayoutState => {
   const registry = useContext(RegistryContext);
-  const stateAtom = useCapability(SimpleLayoutStateCapability);
+  const stateAtom = useCapability(SimpleLayoutState);
   const state = useAtomValue(stateAtom);
 
   const updateState = useCallback(

package/src/types/capabilities.ts

@@ -5,15 +5,21 @@
 import { type Atom } from '@effect-atom/atom-react';
 
 import { Capability } from '@dxos/app-framework';
-import { type DrawerState, type Label } from '@dxos/react-ui';
+import { type Label } from '@dxos/react-ui';
 
 import { meta } from '../meta';
 
+export type DrawerState = 'closed' | 'open' | 'expanded';
+
 // TODO(wittjosiah): Handle toasts.
 export type SimpleLayoutState = {
   /** Data to be passed to the main content Surface. */
   content?: any;
 
+  previousWorkspace: string;
+  workspace: string;
+  active?: string;
+
   dialogOpen: boolean;
   dialogType?: 'default' | 'alert';
   dialogBlockAlign?: 'start' | 'center' | 'end';
@@ -31,9 +37,9 @@ export type SimpleLayoutState = {
   popoverTitle?: Label;
   popoverContent?: any;
 
-  workspace: string;
-  previousWorkspace: string;
-  active?: string;
+  /** Bottom drawer state. */
+  drawerState: DrawerState;
+
   /** Stack of previously active item IDs for back navigation. */
   history: string[];
 
@@ -42,8 +48,6 @@ export type SimpleLayoutState = {
 
   /** Variant of the companion to display in the drawer (e.g., "comments", "assistant-chat"). */
   companionVariant?: string;
-  /** State of the companion drawer. */
-  drawerState?: DrawerState;
 };
 
 export const SimpleLayoutState = Capability.make<Atom.Writable<SimpleLayoutState>>(`${meta.id}/state`);

package/src/types/events.ts

@@ -2,13 +2,14 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type ActivationEvent, Common } from '@dxos/app-framework';
+import { type ActivationEvent } from '@dxos/app-framework';
+import { AppActivationEvents } from '@dxos/app-toolkit';
 
 import { SimpleLayoutState } from './capabilities';
 
 export namespace SimpleLayoutEvents {
   /** Fired when SimpleLayoutState capability is ready. */
-  export const StateReady: ActivationEvent.ActivationEvent = Common.ActivationEvent.createStateEvent(
+  export const StateReady: ActivationEvent.ActivationEvent = AppActivationEvents.createStateEvent(
     SimpleLayoutState.identifier,
   );
 }