@dxos/plugin-sheet 0.7.4 → 0.7.5-labs.071a3e2

package/src/components/RangeList/RangeList.tsx

@@ -4,13 +4,14 @@
 
 import React, { useCallback } from 'react';
 
+import { rangeToA1Notation } from '@dxos/compute';
 import { S } from '@dxos/echo-schema';
 import { useTranslation } from '@dxos/react-ui';
 import { List } from '@dxos/react-ui-list';
 import { ghostHover } from '@dxos/react-ui-theme';
 
-import { rangeFromIndex, rangeToA1Notation } from '../../defs';
 import { SHEET_PLUGIN } from '../../meta';
+import { rangeFromIndex } from '../../types';
 import { Range, type SheetType } from '../../types';
 
 export type RangeListProps = {

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

@@ -7,9 +7,12 @@ import '@dxos-theme';
 import { type Meta } from '@storybook/react';
 import React from 'react';
 
-import { type Intent, IntentProvider } from '@dxos/app-framework';
-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';
@@ -19,24 +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({
-  dispatch: async (intents: Intent | Intent[]) => {
-    const intent = Array.isArray(intents) ? intents[0] : intents;
-    switch (intent.action) {
-      case SheetAction.DROP_AXIS: {
-        if (!intent.undo) {
-          const { model, axis, axisIndex } = intent.data as SheetAction.DropAxis;
-          model[axis === 'col' ? 'dropColumn' : 'dropRow'](axisIndex);
-        }
-      }
-    }
-  },
-  undo: async () => ({}),
-  history: [],
-  registerResolver: () => () => {},
-});
-
 export const Basic = () => {
   const space = useSpace();
   const graph = useComputeGraph(space);
@@ -45,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 = () => {
@@ -57,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>
   );
 };
 
@@ -80,6 +69,22 @@ 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({
+            intent: SheetAction.DropAxis,
+            resolve: ({ 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/SheetContext/SheetContext.tsx

@@ -4,6 +4,7 @@
 
 import React, { type PropsWithChildren, createContext, useCallback, useContext, useState } from 'react';
 
+import { type ComputeGraph, type CellAddress, type CellRange, type CompleteCellRange } from '@dxos/compute';
 import { invariant } from '@dxos/invariant';
 import { fullyQualifiedId } from '@dxos/react-client/echo';
 import {
@@ -14,8 +15,6 @@ import {
   useGridContext,
 } from '@dxos/react-ui-grid';
 
-import { type ComputeGraph } from '../../compute-graph';
-import { type CellAddress, type CellRange, type CompleteCellRange } from '../../defs';
 import { type SheetModel, useSheetModel } from '../../model';
 import { type SheetType } from '../../types';
 

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'));

package/src/extensions/compute.ts

@@ -15,13 +15,16 @@ import {
 import { Decoration, EditorView, ViewPlugin, WidgetType } from '@codemirror/view';
 
 import { type UnsubscribeCallback, debounce } from '@dxos/async';
+import {
+  createSheetName,
+  type CellAddress,
+  type CellScalarValue,
+  type ComputeGraph,
+  type ComputeNode,
+} from '@dxos/compute';
 import { invariant } from '@dxos/invariant';
 import { documentId, singleValueFacet } from '@dxos/react-ui-editor';
 
-import { type ComputeGraph, type ComputeNode, createSheetName } from '../compute-graph';
-import { type CellAddress } from '../defs';
-import { type CellScalarValue } from '../types';
-
 const LANGUAGE_TAG = 'dx';
 
 // TODO(burdon): Create marker just for our decorator?

package/src/extensions/editor/extension.test.ts

@@ -8,8 +8,9 @@ import { testTree } from '@lezer/generator/test';
 import { spreadsheet } from 'codemirror-lang-spreadsheet';
 import { describe, expect, test } from 'vitest';
 
+import { defaultFunctions } from '@dxos/compute';
+
 import { sheetExtension } from './extension';
-import { defaultFunctions } from '../../compute-graph';
 
 describe('formula parser', () => {
   const {

package/src/extensions/editor/extension.ts

@@ -18,12 +18,11 @@ import { type SyntaxNode } from '@lezer/common';
 import { tags } from '@lezer/highlight';
 import { spreadsheet } from 'codemirror-lang-spreadsheet';
 
+import { type FunctionDefinition } from '@dxos/compute';
+import { RANGE_NOTATION } from '@dxos/compute';
 import { singleValueFacet } from '@dxos/react-ui-editor';
 import { mx } from '@dxos/react-ui-theme';
 
-import { type FunctionDefinition } from '../../compute-graph';
-import { RANGE_NOTATION } from '../../defs';
-
 /**
  * https://codemirror.net/examples/styling
  * https://lezer.codemirror.net/docs/ref/#highlight

package/src/index.ts

@@ -2,11 +2,6 @@
 // Copyright 2023 DXOS.org
 //
 
-import { SheetPlugin } from './SheetPlugin';
-
+export { SheetCapabilities } from './capabilities';
+export * from './meta';
 export * from './SheetPlugin';
-
-// TODO(burdon): Move to types entrypoint or create a new one.
-export * from './defs';
-
-export default SheetPlugin;