@dxos/plugin-sheet 0.8.4-main.c1de068 → 0.8.4-main.c85a9c8dae

package/src/components/ComputeGraph/compute-graph.stories.tsx

@@ -2,37 +2,36 @@
 // Copyright 2024 DXOS.org
 //
 
-import '@dxos-theme';
-
-import { type Meta } from '@storybook/react-vite';
+import { type Meta, type StoryObj } from '@storybook/react-vite';
 import React, { useEffect, useRef, useState } from 'react';
 
 import { testFunctionPlugins } from '@dxos/compute/testing';
-import { Obj, Filter } from '@dxos/echo';
-import { FunctionType } from '@dxos/functions';
+import { Filter } from '@dxos/echo';
+import { Function } from '@dxos/functions';
 import { useSpace } from '@dxos/react-client/echo';
 import { withClientProvider } from '@dxos/react-client/testing';
-import { Toolbar, Button, Input } from '@dxos/react-ui';
+import { Button, Input, Toolbar } from '@dxos/react-ui';
+import { withTheme } from '@dxos/react-ui/testing';
 import { SyntaxHighlighter } from '@dxos/react-ui-syntax-highlighter';
-import { withTheme } from '@dxos/storybook-utils';
 
-import { useComputeGraph } from './ComputeGraphContextProvider';
 import { useSheetModel } from '../../model';
 import { withComputeGraphDecorator } from '../../testing';
-import { createSheet, SheetType } from '../../types';
+import { Sheet } from '../../types';
+
+import { useComputeGraph } from './ComputeGraphContextProvider';
 
 const FUNCTION_NAME = 'TEST';
 
-const Story = () => {
+const DefaultStory = () => {
   const space = useSpace();
   const graph = useComputeGraph(space);
-  const [sheet, setSheet] = useState<SheetType>();
+  const [sheet, setSheet] = useState<Sheet.Sheet>();
   const [text, setText] = useState(`${FUNCTION_NAME}(100)`);
   const [result, setResult] = useState<any>();
   const model = useSheetModel(graph, sheet);
   useEffect(() => {
     if (space) {
-      const sheet = space.db.add(createSheet());
+      const sheet = space.db.add(Sheet.make());
       setSheet(sheet);
     }
   }, [space]);
@@ -45,14 +44,14 @@ const Story = () => {
         setResult({ functions: { standard: f1.length, echo: f2.length } });
       });
 
-      space.db.add(Obj.make(FunctionType, { name: 'test', version: '0.0.1', binding: FUNCTION_NAME }));
+      space.db.add(Function.make({ name: 'test', version: '0.0.1', binding: FUNCTION_NAME }));
     }
   }, [space, graph]);
 
   const inputRef = useRef<HTMLInputElement | null>(null);
   const handleTest = async () => {
     if (space && graph) {
-      const { objects } = await space.db.query(Filter.type(FunctionType)).run();
+      const objects = await space.db.query(Filter.type(Function.Function)).run();
       const mapped = graph.mapFunctionBindingToId(text);
       const unmapped = graph.mapFunctionBindingFromId(mapped);
       const internal = graph.mapFormulaToNative(text);
@@ -82,16 +81,18 @@ const Story = () => {
   );
 };
 
-export const Default = {};
+export const Default: Story = {};
 
-const meta: Meta = {
-  title: 'plugins/plugin-sheet/functions',
+const meta = {
+  title: 'plugins/plugin-sheet/components/functions',
+  render: DefaultStory,
   decorators: [
-    withClientProvider({ types: [FunctionType, SheetType], createIdentity: true, createSpace: true }),
+    withTheme(),
+    withClientProvider({ types: [Function.Function, Sheet.Sheet], createIdentity: true, createSpace: true }),
     withComputeGraphDecorator({ plugins: testFunctionPlugins }),
-    withTheme,
   ],
-  render: (args: any) => <Story {...args} />,
-};
+} satisfies Meta<typeof DefaultStory>;
 
 export default meta;
+
+type Story = StoryObj<typeof meta>;

package/src/components/Sheet/Sheet.tsx

@@ -0,0 +1,20 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { SheetContent } from '../SheetContent';
+import { SheetRoot } from '../SheetRoot';
+import { SheetStatusbar } from '../SheetStatusbar';
+import { SheetToolbar } from '../SheetToolbar';
+
+export { useSheetContext, type SheetContextValue, type SheetRootProps } from '../SheetRoot';
+export { type SheetContentProps } from '../SheetContent';
+export { type SheetToolbarProps } from '../SheetToolbar';
+export { type SheetStatusbarProps } from '../SheetStatusbar';
+
+export const Sheet = {
+  Root: SheetRoot,
+  Toolbar: SheetToolbar,
+  Content: SheetContent,
+  Statusbar: SheetStatusbar,
+};

package/src/components/Sheet/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './Sheet';

package/src/components/SheetContent/SheetCellEditor.stories.tsx

@@ -0,0 +1,94 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import React, { useMemo, useState } from 'react';
+
+import { Client } from '@dxos/client';
+import { defaultFunctions } from '@dxos/compute';
+import { getRegisteredFunctionNames } from '@dxos/compute/testing';
+import { Obj } from '@dxos/echo';
+import { createDocAccessor } from '@dxos/echo-db';
+import { useAsyncEffect } from '@dxos/react-hooks';
+import { withTheme } from '@dxos/react-ui/testing';
+import { CellEditor, type CellEditorProps } from '@dxos/react-ui-grid';
+import { automerge } from '@dxos/ui-editor';
+
+import { sheetExtension } from '../../extensions';
+import { Sheet } from '../../types';
+
+const DefaultStory = ({ value, ...props }: CellEditorProps) => {
+  const extensions = useMemo(() => {
+    const functionNames = getRegisteredFunctionNames();
+    const functions = defaultFunctions.filter(({ name }) => functionNames.includes(name));
+    return [sheetExtension({ functions })];
+  }, []);
+
+  return <CellEditor {...props} value={value} extensions={extensions} />;
+};
+
+const AutomergeStory = ({ value, ...props }: CellEditorProps) => {
+  const cell = 'A1';
+  const [object, setObject] = useState<Sheet.Sheet>();
+  useAsyncEffect(async () => {
+    const client = new Client({ types: [Sheet.Sheet] });
+    await client.initialize();
+    await client.halo.createIdentity();
+    const space = await client.spaces.create();
+
+    const sheet = Sheet.make();
+    Obj.change(sheet, (obj) => {
+      obj.name = 'Test';
+      obj.cells[cell] = { value };
+    });
+    space.db.add(sheet);
+    setObject(sheet);
+  }, [value]);
+
+  const extensions = useMemo(() => {
+    if (!object) {
+      return [];
+    }
+
+    const functionNames = getRegisteredFunctionNames();
+    const functions = defaultFunctions.filter(({ name }) => functionNames.includes(name));
+    const accessor = createDocAccessor(object, ['cells', cell, 'value']);
+    return [automerge(accessor), sheetExtension({ functions })];
+  }, [object]);
+
+  return <CellEditor {...props} value={value} extensions={extensions} />;
+};
+
+const meta = {
+  title: 'plugins/plugin-sheet/components/CellEditor',
+
+  decorators: [withTheme()],
+  component: CellEditor,
+  render: DefaultStory,
+} satisfies Meta<typeof DefaultStory>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {};
+
+export const AutoComplete: Story = {
+  args: {
+    value: '=SUM',
+  },
+};
+
+export const Formatting: Story = {
+  args: {
+    value: '=SUM(A1:A2, 100, TRUE, "100", SUM(A1:A2, B1:B2))',
+  },
+};
+
+export const Automerge: Story = {
+  render: AutomergeStory,
+  args: {
+    value: '=SUM(A1:A2, 100, TRUE, "100", SUM(A1:A2, B1:B2))',
+  },
+};

package/src/components/SheetContent/SheetContent.stories.tsx

@@ -0,0 +1,60 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import React from 'react';
+
+import { withPluginManager } from '@dxos/app-framework/testing';
+import { testFunctionPlugins } from '@dxos/compute/testing';
+import { OperationPlugin, RuntimePlugin } from '@dxos/plugin-testing';
+import { useSpace } from '@dxos/react-client/echo';
+import { withClientProvider } from '@dxos/react-client/testing';
+import { withLayout, withTheme } from '@dxos/react-ui/testing';
+
+import { createTestCells, useTestSheet, withComputeGraphDecorator } from '../../testing';
+import { translations } from '../../translations';
+import { Sheet } from '../../types';
+import { useComputeGraph } from '../ComputeGraph';
+import { SheetRoot } from '../SheetRoot';
+
+import { SheetContent } from './SheetContent';
+
+export const Basic = () => {
+  const space = useSpace();
+  const graph = useComputeGraph(space);
+  const sheet = useTestSheet(space, graph, { cells: createTestCells() });
+  if (!sheet || !graph) {
+    return null;
+  }
+
+  return (
+    <SheetRoot graph={graph} sheet={sheet} ignoreAttention>
+      <div role='none' className='grid h-full w-full'>
+        <SheetContent />
+      </div>
+    </SheetRoot>
+  );
+};
+
+const meta = {
+  title: 'plugins/plugin-sheet/components/SheetContent',
+  component: SheetContent,
+  decorators: [
+    withTheme(),
+    withLayout({ layout: 'fullscreen' }),
+    withClientProvider({ types: [Sheet.Sheet], createSpace: true }),
+    withComputeGraphDecorator({ plugins: testFunctionPlugins }),
+    withPluginManager({
+      plugins: [OperationPlugin(), RuntimePlugin()],
+    }),
+  ],
+  parameters: {
+    layout: 'fullscreen',
+    translations,
+  },
+} satisfies Meta<typeof SheetContent>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;

package/src/components/{GridSheet/GridSheet.tsx → SheetContent/SheetContent.tsx}

@@ -3,41 +3,44 @@
 //
 
 import React, {
+  type FocusEvent,
+  type KeyboardEvent,
+  type MouseEvent,
+  type WheelEvent,
   useCallback,
   useMemo,
   useRef,
   useState,
-  type FocusEvent,
-  type KeyboardEvent,
-  type WheelEvent,
-  type MouseEvent,
 } from 'react';
 
-import { createIntent, useIntentDispatcher } from '@dxos/app-framework';
-import { rangeToA1Notation, type CellRange } from '@dxos/compute';
+import { useOperationInvoker } from '@dxos/app-framework/ui';
+import { type CellRange, rangeToA1Notation } from '@dxos/compute';
+import { Obj } from '@dxos/echo';
 import { defaultColSize, defaultRowSize } from '@dxos/lit-grid';
-import { DropdownMenu, Icon, useTranslation } from '@dxos/react-ui';
+import { type ComposableProps, DropdownMenu, Icon, useTranslation } from '@dxos/react-ui';
 import { useAttention } from '@dxos/react-ui-attention';
 import {
-  closestCell,
-  editorKeys,
-  parseCellIndex,
-  Grid,
-  GridCellEditor,
+  type DxGridCellIndex,
   type DxGridElement,
   type DxGridPosition,
-  type DxGridCellIndex,
-  type EditorKeyHandler,
   type EditorBlurHandler,
+  type EditorKeyHandler,
+  Grid,
+  GridCellEditor,
   type GridContentProps,
+  closestCell,
+  editorKeys,
+  parseCellIndex,
 } from '@dxos/react-ui-grid';
+import { mx, useComposableProps } from '@dxos/ui-theme';
 
-import { colLabelCell, rowLabelCell, useSheetModelDxGridProps } from './util';
-import { rangeExtension, sheetExtension, type RangeController } from '../../extensions';
+import { type RangeController, rangeExtension, sheetExtension } from '../../extensions';
 import { useSelectThreadOnCellFocus, useUpdateFocusedCellOnThreadSelection } from '../../integrations';
-import { SHEET_PLUGIN } from '../../meta';
-import { DEFAULT_COLS, DEFAULT_ROWS, SheetAction } from '../../types';
-import { useSheetContext } from '../SheetContext';
+import { meta } from '../../meta';
+import { DEFAULT_COLS, DEFAULT_ROWS, SheetOperation } from '../../types';
+import { useSheetContext } from '../SheetRoot';
+
+import { colLabelCell, rowLabelCell, useSheetModelDxGridProps } from './util';
 
 const inertPosition: DxGridPosition = { plane: 'grid', col: 0, row: 0 };
 
@@ -59,25 +62,29 @@ const frozen = {
 };
 
 const sheetColDefault = {
-  frozenColsStart: { size: 48, readonly: true },
+  frozenColsStart: { size: 48, readonly: true, focusUnfurl: false },
   grid: { size: defaultColSize, resizeable: true },
 };
 const sheetRowDefault = {
-  frozenRowsStart: { size: defaultRowSize, readonly: true },
+  frozenRowsStart: { size: defaultRowSize, readonly: true, focusUnfurl: false },
   grid: { size: defaultRowSize, resizeable: true },
 };
 
-export const GridSheet = () => {
-  const { t } = useTranslation(SHEET_PLUGIN);
+export type SheetContentProps = ComposableProps<React.HTMLAttributes<HTMLDivElement>>;
+
+export const SheetContent = (props: SheetContentProps) => {
+  const { t } = useTranslation(meta.id);
   const { id, model, editing, setCursor, setRange, cursor, cursorFallbackRange, activeRefs, ignoreAttention } =
     useSheetContext();
+
   // NOTE(thure): using `useState` instead of `useRef` works with refs provided by `@lit/react` and gives us
   //  a reliable dependency for `useEffect` whereas `useLayoutEffect` does not guarantee the element will be defined.
   const [dxGrid, setDxGrid] = useState<DxGridElement | null>(null);
   const [extraplanarFocus, setExtraplanarFocus] = useState<DxGridPosition | null>(null);
-  const { dispatchPromise: dispatch } = useIntentDispatcher();
-  const rangeController = useRef<RangeController>();
+  const { invokePromise } = useOperationInvoker();
+  const rangeController = useRef<RangeController>(null);
   const { hasAttention } = useAttention(id);
+  const { className, ...rest } = useComposableProps(props);
 
   const handleFocus = useCallback(
     (event: FocusEvent) => {
@@ -126,15 +133,17 @@ export const GridSheet = () => {
 
   const handleAxisResize = useCallback<NonNullable<GridContentProps['onAxisResize']>>(
     ({ axis, size, index: numericIndex }) => {
-      if (axis === 'row') {
-        const rowId = model.sheet.rows[parseInt(numericIndex)];
-        model.sheet.rowMeta[rowId] ??= {};
-        model.sheet.rowMeta[rowId].size = size;
-      } else {
-        const columnId = model.sheet.columns[parseInt(numericIndex)];
-        model.sheet.columnMeta[columnId] ??= {};
-        model.sheet.columnMeta[columnId].size = size;
-      }
+      Obj.change(model.sheet, (sheet) => {
+        if (axis === 'row') {
+          const rowId = sheet.rows[parseInt(numericIndex)];
+          sheet.rowMeta[rowId] ??= {};
+          sheet.rowMeta[rowId].size = size;
+        } else {
+          const columnId = sheet.columns[parseInt(numericIndex)];
+          sheet.columnMeta[columnId] ??= {};
+          sheet.columnMeta[columnId].size = size;
+        }
+      });
     },
     [model],
   );
@@ -171,12 +180,20 @@ export const GridSheet = () => {
         case 'frozenRowsStart':
           return dxGrid?.setSelection({
             start: { col: pos.col, row: 0, plane: 'grid' },
-            end: { col: pos.col, row: model.sheet.rows.length - 1, plane: 'grid' },
+            end: {
+              col: pos.col,
+              row: model.sheet.rows.length - 1,
+              plane: 'grid',
+            },
           });
         case 'frozenColsStart':
           return dxGrid?.setSelection({
             start: { row: pos.row, col: 0, plane: 'grid' },
-            end: { row: pos.row, col: model.sheet.columns.length - 1, plane: 'grid' },
+            end: {
+              row: pos.row,
+              col: model.sheet.columns.length - 1,
+              plane: 'grid',
+            },
           });
       }
     },
@@ -256,31 +273,30 @@ export const GridSheet = () => {
       switch (operation) {
         case 'insert-before':
         case 'insert-after':
-          return dispatch(
-            createIntent(SheetAction.InsertAxis, {
-              model,
-              axis: contextMenuAxis,
-              index: contextMenuOpen![contextMenuAxis] + (operation === 'insert-before' ? 0 : 1),
-            }),
-          );
+          return invokePromise(SheetOperation.InsertAxis, {
+            model,
+            axis: contextMenuAxis,
+            index: contextMenuOpen![contextMenuAxis] + (operation === 'insert-before' ? 0 : 1),
+          });
         case 'drop':
-          return dispatch(
-            createIntent(SheetAction.DropAxis, {
-              model,
-              axis: contextMenuAxis,
-              axisIndex: model.sheet[contextMenuAxis === 'row' ? 'rows' : 'columns'][contextMenuOpen![contextMenuAxis]],
-            }),
-          );
+          return invokePromise(SheetOperation.DropAxis, {
+            model,
+            axis: contextMenuAxis,
+            axisIndex: model.sheet[contextMenuAxis === 'row' ? 'rows' : 'columns'][contextMenuOpen![contextMenuAxis]],
+          });
       }
     },
-    [contextMenuAxis, contextMenuOpen, model, dispatch],
+    [contextMenuAxis, contextMenuOpen, model, invokePromise],
   );
 
   const { columns, rows } = useSheetModelDxGridProps(dxGrid, model);
 
-  const extension = useMemo(
+  const extensions = useMemo(
     () => [
-      editorKeys({ onClose: handleClose, ...(editing?.initialContent && { onNav: handleClose }) }),
+      editorKeys({
+        onClose: handleClose,
+        ...(editing?.initialContent && { onNav: handleClose }),
+      }),
       sheetExtension({ functions: model.graph.getFunctions() }),
       rangeExtension({
         onInit: (fn) => (rangeController.current = fn),
@@ -306,19 +322,20 @@ export const GridSheet = () => {
   useSelectThreadOnCellFocus();
 
   return (
-    // TODO(thure): Why are Table’s and Sheet’s editor boxes off by 1px?
-    <div role='none' className='relative min-bs-0 [&_.cm-editor]:!border-lb [&_.cm-editor]:!border-transparent '>
-      <GridCellEditor getCellContent={getCellContent} extension={extension} onBlur={handleBlur} />
+    <div {...rest} role='none' className={mx('relative min-h-0', className)}>
+      <GridCellEditor getCellContent={getCellContent} extensions={extensions} onBlur={handleBlur} />
       <Grid.Content
+        className='[--dx-grid-base:var(--base-surface)] [&_.dx-grid]:absolute [&_.dx-grid]:inset-0'
         initialCells={initialCells}
         limitColumns={DEFAULT_COLS}
         limitRows={DEFAULT_ROWS}
         columns={columns}
         rows={rows}
-        // TODO(burdon): `col` vs. `column`?
         columnDefault={sheetColDefault}
         rowDefault={sheetRowDefault}
+        activeRefs={activeRefs}
         frozen={frozen}
+        overscroll='trap'
         onAxisResize={handleAxisResize}
         onSelect={handleSelect}
         onFocus={handleFocus}
@@ -326,9 +343,6 @@ export const GridSheet = () => {
         onKeyDown={handleKeyDown}
         onContextMenu={handleContextMenu}
         onClick={handleClick}
-        overscroll='trap'
-        className='[--dx-grid-base:var(--baseSurface)] [&_.dx-grid]:absolute [&_.dx-grid]:inset-0'
-        activeRefs={activeRefs}
         ref={setDxGrid}
       />
       <DropdownMenu.Root

package/src/components/{RangeList → SheetContent}/index.ts

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

package/src/components/{GridSheet → SheetContent}/util.ts

@@ -5,21 +5,21 @@
 import { useEffect, useState } from 'react';
 
 import { inRange } from '@dxos/compute';
-import { createDocAccessor } from '@dxos/react-client/echo';
-import { parseValue, cellClassesForFieldType } from '@dxos/react-ui-form';
+import { createDocAccessor } from '@dxos/echo-db';
+import { cellClassesForFieldType, parseValue } from '@dxos/react-ui-form';
 import {
-  type GridContentProps,
-  type DxGridElement,
   type DxGridAxisMeta,
+  type DxGridCellValue,
+  type DxGridElement,
   type DxGridPlane,
-  type DxGridPlaneRange,
   type DxGridPlaneCells,
-  type DxGridCellValue,
+  type DxGridPlaneRange,
+  type GridContentProps,
   colToA1Notation,
-  rowToA1Notation,
   commentedClassName,
+  rowToA1Notation,
 } from '@dxos/react-ui-grid';
-import { mx } from '@dxos/react-ui-theme';
+import { mx } from '@dxos/ui-theme';
 
 import { type SheetModel } from '../../model';
 import { cellClassNameForRange, rangeFromIndex } from '../../types';
@@ -28,7 +28,10 @@ const createDxGridColumns = (model: SheetModel): DxGridAxisMeta => {
   return model.sheet.columns.reduce(
     (acc: DxGridAxisMeta, columnId, numericIndex) => {
       if (model.sheet.columnMeta[columnId] && model.sheet.columnMeta[columnId].size) {
-        acc.grid[numericIndex] = { size: model.sheet.columnMeta[columnId].size, resizeable: true };
+        acc.grid[numericIndex] = {
+          size: model.sheet.columnMeta[columnId].size,
+          resizeable: true,
+        };
       }
       return acc;
     },
@@ -40,7 +43,10 @@ const createDxGridRows = (model: SheetModel): DxGridAxisMeta => {
   return model.sheet.rows.reduce(
     (acc: DxGridAxisMeta, rowId, numericIndex) => {
       if (model.sheet.rowMeta[rowId] && model.sheet.rowMeta[rowId].size) {
-        acc.grid[numericIndex] = { size: model.sheet.rowMeta[rowId].size, resizeable: true };
+        acc.grid[numericIndex] = {
+          size: model.sheet.rowMeta[rowId].size,
+          resizeable: true,
+        };
       }
       return acc;
     },
@@ -59,7 +65,7 @@ const projectCellProps = (model: SheetModel, col: number, row: number): DxGridCe
   //     const range = thread.target?.anchor && parseThreadAnchorAsCellRange(thread.target!.anchor);
   //     return thread && range ? inRange(range, address) : false;
   //   })
-  //   .map((thread) => fullyQualifiedId(thread!))
+  //   .map((thread) => Obj.getDXN(thread!).toString())
   //   .join(' ');
 
   const description = model.getValueDescription(address);
@@ -90,13 +96,13 @@ const gridCellGetter = (model: SheetModel) => {
 
 export const rowLabelCell = (row: number) => ({
   value: rowToA1Notation(row),
-  className: '!bg-toolbarSurface text-subdued text-end pie-1',
+  className: '!bg-toolbar-surface text-subdued text-end pe-1',
   resizeHandle: 'row',
 });
 
 export const colLabelCell = (col: number) => ({
   value: colToA1Notation(col),
-  className: '!bg-toolbarSurface text-subdued',
+  className: '!bg-toolbar-surface text-subdued',
   resizeHandle: 'col',
 });
 
@@ -108,7 +114,7 @@ const cellGetter = (model: SheetModel) => {
         return getGridCells(nextBounds);
       case 'fixedStartStart': {
         return {
-          '0,0': { className: '!bg-toolbarSurface' },
+          '0,0': { className: '!bg-toolbar-surface' },
         };
       }
       case 'frozenColsStart':