@dxos/plugin-sheet 0.7.5-main.9d26e3a → 0.7.5-main.9d2a38b

package/src/capabilities/index.ts

@@ -0,0 +1,14 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { lazy } from '@dxos/app-framework';
+
+export const ComputeGraphRegistry = lazy(() => import('./compute-graph-registry'));
+export const IntentResolver = lazy(() => import('./intent-resolver'));
+export const Markdown = lazy(() => import('./markdown'));
+export const ReactContext = lazy(() => import('./react-context'));
+export const ReactSurface = lazy(() => import('./react-surface'));
+export const Thread = lazy(() => import('./thread'));
+
+export * from './capabilities';

package/src/capabilities/intent-resolver.ts

@@ -0,0 +1,29 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { contributes, Capabilities, createResolver } from '@dxos/app-framework';
+
+import { SHEET_PLUGIN } from '../meta';
+import { createSheet, SheetAction } from '../types';
+
+export default () =>
+  contributes(Capabilities.IntentResolver, [
+    createResolver(SheetAction.Create, ({ name }) => ({ data: { object: createSheet({ name }) } })),
+    createResolver(SheetAction.InsertAxis, ({ model, axis, index, count }) => {
+      const _indices = model[axis === 'col' ? 'insertColumns' : 'insertRows'](index, count);
+    }),
+    createResolver(SheetAction.DropAxis, ({ model, axis, axisIndex, deletionData }, undo) => {
+      if (!undo) {
+        const undoData = model[axis === 'col' ? 'dropColumn' : 'dropRow'](axisIndex);
+        return {
+          undoable: {
+            message: [`${axis} dropped label`, { ns: SHEET_PLUGIN }],
+            data: { ...undoData, model },
+          },
+        };
+      } else if (undo && deletionData) {
+        model[deletionData.axis === 'col' ? 'restoreColumn' : 'restoreRow'](deletionData);
+      }
+    }),
+  ]);

package/src/capabilities/markdown.ts

@@ -0,0 +1,22 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { contributes, type PluginsContext } from '@dxos/app-framework';
+import { getSpace } from '@dxos/client/echo';
+import { MarkdownCapabilities } from '@dxos/plugin-markdown';
+
+import { SheetCapabilities } from './capabilities';
+import { computeGraphFacet } from '../extensions';
+
+export default (context: PluginsContext) =>
+  contributes(MarkdownCapabilities.Extensions, [
+    ({ document: doc }) => {
+      const computeGraphRegistry = context.requestCapability(SheetCapabilities.ComputeGraphRegistry);
+      const space = getSpace(doc);
+      if (space) {
+        const computeGraph = computeGraphRegistry.getOrCreateGraph(space);
+        return computeGraphFacet.of(computeGraph);
+      }
+    },
+  ]);

package/src/capabilities/react-context.tsx

@@ -0,0 +1,20 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React from 'react';
+
+import { Capabilities, contributes, useCapability } from '@dxos/app-framework';
+
+import { SheetCapabilities } from './capabilities';
+import { ComputeGraphContextProvider } from '../components';
+import { SHEET_PLUGIN } from '../meta';
+
+export default () =>
+  contributes(Capabilities.ReactContext, {
+    id: SHEET_PLUGIN,
+    context: ({ children }) => {
+      const computeGraphRegistry = useCapability(SheetCapabilities.ComputeGraphRegistry);
+      return <ComputeGraphContextProvider registry={computeGraphRegistry}>{children}</ComputeGraphContextProvider>;
+    },
+  });

package/src/capabilities/react-surface.tsx

@@ -0,0 +1,30 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React from 'react';
+
+import { Capabilities, contributes, createSurface } from '@dxos/app-framework';
+import { getSpace } from '@dxos/react-client/echo';
+
+import { RangeList, SheetContainer } from '../components';
+import { SHEET_PLUGIN } from '../meta';
+import { SheetType } from '../types';
+
+export default () =>
+  contributes(Capabilities.ReactSurface, [
+    createSurface({
+      id: `${SHEET_PLUGIN}/sheet`,
+      role: ['article', 'section'],
+      filter: (data): data is { subject: SheetType } => data.subject instanceof SheetType && !!getSpace(data.subject),
+      component: ({ data, role }) => (
+        <SheetContainer space={getSpace(data.subject)!} sheet={data.subject} role={role} />
+      ),
+    }),
+    createSurface({
+      id: `${SHEET_PLUGIN}/settings`,
+      role: 'complementary--settings',
+      filter: (data): data is { subject: SheetType } => data.subject instanceof SheetType,
+      component: ({ data }) => <RangeList sheet={data.subject} />,
+    }),
+  ]);

package/src/capabilities/thread.ts

@@ -0,0 +1,14 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { contributes } from '@dxos/app-framework';
+import { ThreadCapabilities } from '@dxos/plugin-space';
+
+import { compareIndexPositions, SheetType } from '../types';
+
+export default () =>
+  contributes(ThreadCapabilities.Thread, {
+    predicate: (data) => data instanceof SheetType,
+    createSort: (sheet) => (indexA, indexB) => (!indexA || !indexB ? 0 : compareIndexPositions(sheet, indexA, indexB)),
+  });

package/src/components/GridSheet/GridSheet.stories.tsx

@@ -7,6 +7,7 @@ import '@dxos-theme';
 import { type Meta } from '@storybook/react';
 import React from 'react';
 
+import { withPluginManager } from '@dxos/app-framework/testing';
 import { useSpace } from '@dxos/react-client/echo';
 import { withClientProvider } from '@dxos/react-client/testing';
 import { withTheme, withLayout } from '@dxos/storybook-utils';
@@ -41,6 +42,7 @@ const meta: Meta = {
     withComputeGraphDecorator(),
     withTheme,
     withLayout({ fullscreen: true, tooltips: true, classNames: 'grid' }),
+    withPluginManager(),
   ],
   parameters: { translations },
 };

package/src/components/SheetContainer/SheetContainer.stories.tsx

@@ -7,10 +7,12 @@ import '@dxos-theme';
 import { type Meta } from '@storybook/react';
 import React from 'react';
 
-import { type AnyIntentChain, type IntentContext, IntentProvider } from '@dxos/app-framework';
-import { todo } from '@dxos/debug';
-import { useSpace, create } from '@dxos/react-client/echo';
+import { Capabilities, contributes, createResolver, IntentPlugin } from '@dxos/app-framework';
+import { withPluginManager } from '@dxos/app-framework/testing';
+import { fullyQualifiedId, useSpace } from '@dxos/react-client/echo';
 import { withClientProvider } from '@dxos/react-client/testing';
+import { AttendableContainer } from '@dxos/react-ui-attention';
+import { withAttention } from '@dxos/react-ui-attention/testing';
 import { withTheme, withLayout } from '@dxos/storybook-utils';
 
 import { SheetContainer } from './SheetContainer';
@@ -20,22 +22,6 @@ import { SheetAction, SheetType } from '../../types';
 import { useComputeGraph } from '../ComputeGraph';
 import { RangeList } from '../RangeList';
 
-// TODO(thure via wittjosiah):  stories/components should be written such that the dependency on intents is external and provided via callback and then the story can implement it differently.
-const storybookIntentValue = create<IntentContext>({
-  dispatch: () => todo(),
-  dispatchPromise: async (intentChain: AnyIntentChain): Promise<any> => {
-    switch (intentChain.first.action) {
-      case SheetAction.DropAxis._tag: {
-        const { model, axis, axisIndex } = intentChain.first.data as SheetAction.DropAxis['input'];
-        model[axis === 'col' ? 'dropColumn' : 'dropRow'](axisIndex);
-      }
-    }
-  },
-  undo: () => todo(),
-  undoPromise: () => todo(),
-  registerResolver: () => () => {},
-});
-
 export const Basic = () => {
   const space = useSpace();
   const graph = useComputeGraph(space);
@@ -44,7 +30,11 @@ export const Basic = () => {
     return null;
   }
 
-  return <SheetContainer space={space} sheet={sheet} role='article' ignoreAttention />;
+  return (
+    <AttendableContainer id={fullyQualifiedId(sheet)} classNames='contents'>
+      <SheetContainer space={space} sheet={sheet} role='article' ignoreAttention />
+    </AttendableContainer>
+  );
 };
 
 export const Spec = () => {
@@ -56,14 +46,14 @@ export const Spec = () => {
   }
 
   return (
-    <IntentProvider value={storybookIntentValue}>
+    <AttendableContainer id={fullyQualifiedId(sheet)} classNames='contents'>
       <div role='none' className='grid grid-rows-[66%_33%] grid-cols-1'>
         <SheetContainer space={space} sheet={sheet} role='article' ignoreAttention />
         <div role='none' data-testid='grid.range-list'>
           <RangeList sheet={sheet} />
         </div>
       </div>
-    </IntentProvider>
+    </AttendableContainer>
   );
 };
 
@@ -79,6 +69,19 @@ const meta: Meta = {
       tooltips: true,
       classNames: 'grid',
     }),
+    withAttention,
+    // TODO(wittjosiah): Consider whether we should refactor component so story doesn't need to depend on intents.
+    withPluginManager({
+      plugins: [IntentPlugin()],
+      capabilities: [
+        contributes(
+          Capabilities.IntentResolver,
+          createResolver(SheetAction.DropAxis, ({ model, axis, axisIndex }) => {
+            model[axis === 'col' ? 'dropColumn' : 'dropRow'](axisIndex);
+          }),
+        ),
+      ],
+    }),
   ],
   parameters: { translations },
 };

package/src/components/SheetContainer/SheetContainer.tsx

@@ -4,7 +4,7 @@
 
 import React from 'react';
 
-import { type Space } from '@dxos/react-client/echo';
+import { fullyQualifiedId, type Space } from '@dxos/react-client/echo';
 import { StackItem } from '@dxos/react-ui-stack';
 
 import { type SheetType } from '../../types';
@@ -12,7 +12,7 @@ import { useComputeGraph } from '../ComputeGraph';
 import { FunctionEditor } from '../FunctionEditor';
 import { GridSheet } from '../GridSheet';
 import { SheetProvider } from '../SheetContext';
-import { Toolbar } from '../Toolbar';
+import { SheetToolbar } from '../SheetToolbar';
 
 export const SheetContainer = ({
   space,
@@ -30,12 +30,7 @@ export const SheetContainer = ({
   return graph ? (
     <SheetProvider sheet={sheet} graph={graph} ignoreAttention={ignoreAttention}>
       <StackItem.Content toolbar statusbar {...(role === 'section' && { classNames: 'aspect-video' })}>
-        <Toolbar.Root role={role}>
-          <Toolbar.Styles />
-          <Toolbar.Alignment />
-          <Toolbar.Separator />
-          <Toolbar.Actions />
-        </Toolbar.Root>
+        <SheetToolbar attendableId={fullyQualifiedId(sheet)} />
         <GridSheet />
         <FunctionEditor />
       </StackItem.Content>

package/src/components/{Toolbar/Toolbar.stories.tsx → SheetToolbar/SheetToolbar.stories.tsx}

@@ -10,22 +10,18 @@ import React from 'react';
 import { textBlockWidth } from '@dxos/react-ui-theme';
 import { withLayout, withTheme } from '@dxos/storybook-utils';
 
-import { Toolbar } from './Toolbar';
+import { SheetToolbar } from './SheetToolbar';
 import translations from '../../translations';
 
 const DefaultStory = () => {
-  return (
-    <Toolbar.Root classNames={textBlockWidth}>
-      <Toolbar.Alignment />
-    </Toolbar.Root>
-  );
+  return <SheetToolbar classNames={textBlockWidth} />;
 };
 
 export const Default = {};
 
-const meta: Meta<typeof Toolbar.Root> = {
+const meta: Meta = {
   title: 'plugins/plugin-sheet/Toolbar',
-  component: Toolbar.Root,
+  component: SheetToolbar,
   render: DefaultStory,
   decorators: [withTheme, withLayout({ tooltips: true })],
   parameters: { translations, layout: 'fullscreen' },

package/src/components/SheetToolbar/SheetToolbar.tsx

@@ -0,0 +1,48 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import React, { type PropsWithChildren, useCallback } from 'react';
+
+import { type ThemedClassName } from '@dxos/react-ui';
+import { createGapSeparator, MenuProvider, ToolbarMenu, useMenuActions } from '@dxos/react-ui-menu';
+
+import { createAlign, useAlignState } from './align';
+import { createComment, useCommentState } from './comment';
+import { createStyle, useStyleState } from './style';
+import { useToolbarAction } from './useToolbarAction';
+import { type ToolbarState, useToolbarState } from './useToolbarState';
+
+//
+// Root
+//
+
+export type SheetToolbarProps = ThemedClassName<PropsWithChildren<{ attendableId?: string }>>;
+
+const createToolbarActions = (state: ToolbarState) => {
+  const align = createAlign(state);
+  const style = createStyle(state);
+  const gap = createGapSeparator();
+  const comment = createComment(state);
+  return {
+    nodes: [...align.nodes, ...style.nodes, ...gap.nodes, ...comment.nodes],
+    edges: [...align.edges, ...style.edges, ...gap.edges, ...comment.edges],
+  };
+};
+
+export const SheetToolbar = ({ attendableId, classNames }: SheetToolbarProps) => {
+  const state = useToolbarState({});
+  useAlignState(state);
+  useStyleState(state);
+  useCommentState(state);
+
+  const actionsCreator = useCallback(() => createToolbarActions(state), [state]);
+  const menu = useMenuActions(actionsCreator);
+  const handleAction = useToolbarAction(state);
+
+  return (
+    <MenuProvider {...menu} attendableId={attendableId} onAction={handleAction}>
+      <ToolbarMenu classNames={classNames} />
+    </MenuProvider>
+  );
+};

package/src/components/SheetToolbar/align.ts

@@ -0,0 +1,68 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useEffect } from 'react';
+
+import { inRange } from '@dxos/compute';
+import { createMenuAction, createMenuItemGroup, type ToolbarMenuActionGroupProperties } from '@dxos/react-ui-menu';
+
+import { SHEET_PLUGIN } from '../../meta';
+import { type AlignKey, alignKey, type AlignValue, rangeFromIndex } from '../../types';
+import { useSheetContext } from '../SheetContext';
+
+export type AlignAction = { key: AlignKey; value: AlignValue };
+
+export type AlignState = { [alignKey]: AlignValue | undefined };
+
+const aligns: Record<AlignValue, string> = {
+  start: 'ph--text-align-left--regular',
+  center: 'ph--text-align-center--regular',
+  end: 'ph--text-align-right--regular',
+};
+
+export const useAlignState = (state: Partial<AlignState>) => {
+  const { cursor, model } = useSheetContext();
+  useEffect(() => {
+    // TODO(thure): Can this O(n) call be memoized?
+    state[alignKey] = (
+      cursor
+        ? model.sheet.ranges?.findLast(
+            ({ range, key }) => key === alignKey && inRange(rangeFromIndex(model.sheet, range), cursor),
+          )?.value
+        : undefined
+    ) as AlignValue | undefined;
+  }, [cursor, model.sheet]);
+};
+
+const createAlignGroupAction = (value?: AlignValue) =>
+  createMenuItemGroup('align', {
+    label: ['align label', { ns: SHEET_PLUGIN }],
+    variant: 'toggleGroup',
+    selectCardinality: 'single',
+    value: `${alignKey}--${value}`,
+  } as ToolbarMenuActionGroupProperties);
+
+const createAlignActions = (value?: AlignValue) =>
+  Object.entries(aligns).map(([alignValue, icon]) => {
+    return createMenuAction<AlignAction>(`${alignKey}--${alignValue}`, {
+      key: alignKey,
+      value: alignValue as AlignValue,
+      checked: value === alignValue,
+      label: [`range value ${alignValue} label`, { ns: SHEET_PLUGIN }],
+      icon,
+      testId: `grid.toolbar.${alignKey}.${alignValue}`,
+    });
+  });
+
+export const createAlign = ({ [alignKey]: alignValue }: Partial<AlignState>) => {
+  const alignGroup = createAlignGroupAction(alignValue);
+  const alignActions = createAlignActions(alignValue);
+  return {
+    nodes: [alignGroup, ...alignActions],
+    edges: [
+      { source: 'root', target: 'align' },
+      ...alignActions.map(({ id }) => ({ source: alignGroup.id, target: id })),
+    ],
+  };
+};

package/src/components/SheetToolbar/comment.ts

@@ -0,0 +1,56 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useEffect, useMemo } from 'react';
+
+import { RefArray } from '@dxos/live-object';
+import { createMenuAction } from '@dxos/react-ui-menu';
+
+import { SHEET_PLUGIN } from '../../meta';
+import { commentKey, type CommentKey, type CommentValue, rangeToIndex } from '../../types';
+import { useSheetContext } from '../SheetContext';
+
+export type CommentAction = { key: CommentKey; value: CommentValue; cellContent?: string };
+
+export type CommentState = { commentEnabled: 'comment' | 'no cursor' | 'selection overlaps existing comment' };
+
+export const useCommentState = (state: Partial<CommentState>) => {
+  const { cursorFallbackRange, model } = useSheetContext();
+
+  // TODO(thure): Can this O(n) call be memoized?
+  const overlapsCommentAnchor = useMemo(
+    () =>
+      RefArray.allResolvedTargets(model.sheet.threads ?? [])
+        .filter((thread) => thread.status !== 'resolved')
+        .some((thread) => {
+          if (!cursorFallbackRange) {
+            return false;
+          }
+          return rangeToIndex(model.sheet, cursorFallbackRange) === thread.anchor;
+        }),
+    [cursorFallbackRange, model.sheet],
+  );
+
+  useEffect(() => {
+    state.commentEnabled = !cursorFallbackRange
+      ? 'no cursor'
+      : overlapsCommentAnchor
+        ? 'selection overlaps existing comment'
+        : 'comment';
+  }, [overlapsCommentAnchor, cursorFallbackRange]);
+};
+
+const createCommentAction = (state: Partial<CommentState>) =>
+  createMenuAction<Pick<CommentAction, 'key'>>('comment', {
+    key: commentKey,
+    testId: 'editor.toolbar.comment',
+    icon: 'ph--chat-text--regular',
+    label: [`${state.commentEnabled} label`, { ns: SHEET_PLUGIN }],
+    disabled: state.commentEnabled !== 'comment',
+  });
+
+export const createComment = (state: Partial<CommentState>) => ({
+  nodes: [createCommentAction(state)],
+  edges: [{ source: 'root', target: 'comment' }],
+});

package/src/components/{Toolbar → SheetToolbar}/index.ts

@@ -2,4 +2,4 @@
 // Copyright 2024 DXOS.org
 //
 
-export * from './Toolbar';
+export * from './SheetToolbar';

package/src/components/SheetToolbar/style.ts

@@ -0,0 +1,72 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useEffect } from 'react';
+
+import { inRange } from '@dxos/compute';
+import { createMenuAction, createMenuItemGroup, type ToolbarMenuActionGroupProperties } from '@dxos/react-ui-menu';
+
+import { SHEET_PLUGIN } from '../../meta';
+import { rangeFromIndex, type StyleKey, type StyleValue } from '../../types';
+import { useSheetContext } from '../SheetContext';
+
+export type StyleState = Partial<Record<StyleValue, boolean>>;
+
+export type StyleAction = { key: StyleKey; value: StyleValue };
+
+const styles: Record<StyleValue, string> = {
+  highlight: 'ph--highlighter--regular',
+  softwrap: 'ph--paragraph--regular',
+};
+
+export const useStyleState = (state: StyleState) => {
+  const { cursorFallbackRange, model } = useSheetContext();
+
+  useEffect(() => {
+    state.highlight = false;
+    state.softwrap = false;
+    if (cursorFallbackRange && model.sheet.ranges) {
+      model.sheet.ranges
+        .filter(
+          ({ range, key }) => key === 'style' && inRange(rangeFromIndex(model.sheet, range), cursorFallbackRange.from),
+        )
+        .forEach(({ value }) => {
+          state[value as StyleValue] = true;
+        });
+    }
+  }, [cursorFallbackRange, model.sheet]);
+};
+
+const createStyleGroup = (state: StyleState) => {
+  return createMenuItemGroup('style', {
+    variant: 'toggleGroup',
+    selectCardinality: 'multiple',
+    value: Object.keys(styles)
+      .filter((key) => !!state[key as StyleValue])
+      .map((styleValue) => `style--${styleValue}`),
+  } as ToolbarMenuActionGroupProperties);
+};
+
+const createStyleActions = (state: StyleState) =>
+  Object.entries(styles).map(([styleValue, icon]) => {
+    return createMenuAction<StyleAction>(`style--${styleValue}`, {
+      key: 'style',
+      value: styleValue as StyleValue,
+      icon,
+      label: [`range value ${styleValue} label`, { ns: SHEET_PLUGIN }],
+      checked: !!state[styleValue as StyleValue],
+    });
+  });
+
+export const createStyle = (state: StyleState) => {
+  const styleGroupAction = createStyleGroup(state);
+  const styleActions = createStyleActions(state);
+  return {
+    nodes: [styleGroupAction, ...styleActions],
+    edges: [
+      { source: 'root', target: 'style' },
+      ...styleActions.map(({ id }) => ({ source: styleGroupAction.id, target: id })),
+    ],
+  };
+};

package/src/components/SheetToolbar/useToolbarAction.ts

@@ -0,0 +1,87 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useCallback } from 'react';
+
+import { createIntent, useIntentDispatcher } from '@dxos/app-framework';
+import { inRange } from '@dxos/compute';
+import { ThreadAction } from '@dxos/plugin-thread/types';
+import type { MenuAction, MenuActionHandler } from '@dxos/react-ui-menu';
+
+import { type AlignAction } from './align';
+import { type CommentAction } from './comment';
+import { type StyleAction } from './style';
+import { type ToolbarState } from './useToolbarState';
+import { completeCellRangeToThreadCursor } from '../../integrations';
+import { alignKey, rangeFromIndex, rangeToIndex } from '../../types';
+import { useSheetContext } from '../SheetContext';
+
+export type ToolbarAction = StyleAction | AlignAction | CommentAction;
+
+export const useToolbarAction = (state: ToolbarState) => {
+  const { model, cursorFallbackRange, cursor } = useSheetContext();
+  const { dispatchPromise: dispatch } = useIntentDispatcher();
+
+  // TODO(Zan): Externalize the toolbar action handler. E.g., Toolbar/keys should both fire events.
+  return useCallback(
+    (action: MenuAction<ToolbarAction>) => {
+      const { key, value } = action.properties;
+      if (cursorFallbackRange) {
+        const index =
+          model.sheet.ranges?.findIndex(
+            (range) => range.key === key && inRange(rangeFromIndex(model.sheet, range.range), cursorFallbackRange.from),
+          ) ?? -1;
+        const nextRangeEntity = {
+          range: rangeToIndex(model.sheet, cursorFallbackRange),
+          key,
+          value,
+        };
+        switch (key) {
+          case 'alignment':
+            if (index < 0) {
+              model.sheet.ranges?.push(nextRangeEntity);
+              state[alignKey] = value;
+            } else if (model.sheet.ranges![index].value === value) {
+              model.sheet.ranges?.splice(index, 1);
+              state[alignKey] = undefined;
+            } else {
+              model.sheet.ranges?.splice(index, 1, nextRangeEntity);
+              state[alignKey] = value;
+            }
+            break;
+          case 'style':
+            if (
+              model.sheet.ranges
+                .filter(
+                  ({ range, key: rangeKey }) =>
+                    rangeKey === 'style' && inRange(rangeFromIndex(model.sheet, range), cursorFallbackRange.from),
+                )
+                .some(({ value: rangeValue }) => rangeValue === value)
+            ) {
+              // this value should be unset
+              if (index >= 0) {
+                model.sheet.ranges?.splice(index, 1);
+              }
+              state[value] = false;
+            } else {
+              model.sheet.ranges?.push(nextRangeEntity);
+              state[value] = true;
+            }
+            break;
+          case 'comment': {
+            const cellContent = model.getCellText(cursorFallbackRange.from);
+            void dispatch(
+              createIntent(ThreadAction.Create, {
+                cursor: completeCellRangeToThreadCursor(cursorFallbackRange),
+                name: cellContent,
+                subject: model.sheet,
+              }),
+            );
+          }
+        }
+      }
+    },
+    [model.sheet, cursorFallbackRange, cursor, dispatch],
+  ) as MenuActionHandler;
+};

package/src/components/SheetToolbar/useToolbarState.ts

@@ -0,0 +1,17 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useMemo } from 'react';
+
+import { create } from '@dxos/live-object';
+
+import { type AlignState } from './align';
+import { type CommentState } from './comment';
+import { type StyleState } from './style';
+
+export type ToolbarState = Partial<StyleState & AlignState & CommentState>;
+
+export const useToolbarState = (initialState: ToolbarState = {}) => {
+  return useMemo(() => create<ToolbarState>(initialState), []);
+};

package/src/components/index.ts

@@ -8,6 +8,5 @@ export * from './ComputeGraph';
 export * from './GridSheet';
 export * from './RangeList';
 export * from './SheetContext';
-export * from './SheetObjectSettings';
 
 export const SheetContainer = lazy(() => import('./SheetContainer'));