@dxos/plugin-sheet 0.6.12-main.c974201 → 0.6.12-main.f9d0246

package/src/components/GridSheet/util.ts

@@ -2,13 +2,20 @@
 // Copyright 2024 DXOS.org
 //
 
-import { useEffect, useState } from 'react';
+import { type MutableRefObject, useEffect, useLayoutEffect, useState } from 'react';
 
 import { createDocAccessor } from '@dxos/react-client/echo';
-import { type GridEditing, type GridContentProps } from '@dxos/react-ui-grid';
+import {
+  type GridEditing,
+  type GridContentProps,
+  type DxGridElement,
+  type DxGridCells,
+  type DxGridAxisMeta,
+  type DxGridRange,
+} from '@dxos/react-ui-grid';
 import { mx } from '@dxos/react-ui-theme';
 
-import { addressFromIndex, type CellAddress } from '../../defs';
+import { type CellAddress } from '../../defs';
 import { type SheetModel, type FormattingModel } from '../../model';
 
 export const dxGridCellIndexToSheetCellAddress = (gridEditing: GridEditing): CellAddress | null => {
@@ -22,19 +29,8 @@ export const dxGridCellIndexToSheetCellAddress = (gridEditing: GridEditing): Cel
   };
 };
 
-const createDxGridCells = (model: SheetModel, formatting: FormattingModel) => {
-  return Object.keys(model.sheet.cells).reduce((acc: NonNullable<GridContentProps['cells']>, sheetCellIndex) => {
-    const address = addressFromIndex(model.sheet, sheetCellIndex);
-    const cell = formatting.getFormatting(address);
-    if (cell.value) {
-      acc[`${address.col},${address.row}`] = { value: cell.value, className: mx(cell.classNames) };
-    }
-    return acc;
-  }, {});
-};
-
-const createDxGridColumns = (model: SheetModel): GridContentProps['columns'] => {
-  return model.sheet.columns.reduce((acc: NonNullable<GridContentProps['columns']>, columnId, numericIndex) => {
+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[numericIndex] = { size: model.sheet.columnMeta[columnId].size, resizeable: true };
     }
@@ -42,8 +38,8 @@ const createDxGridColumns = (model: SheetModel): GridContentProps['columns'] =>
   }, {});
 };
 
-const createDxGridRows = (model: SheetModel): GridContentProps['rows'] => {
-  return model.sheet.rows.reduce((acc: NonNullable<GridContentProps['rows']>, rowId, numericIndex) => {
+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[numericIndex] = { size: model.sheet.rowMeta[rowId].size, resizeable: true };
     }
@@ -51,18 +47,41 @@ const createDxGridRows = (model: SheetModel): GridContentProps['rows'] => {
   }, {});
 };
 
+const cellGetter = (model: SheetModel, formatting: FormattingModel) => {
+  // TODO(thure): Actually use the cache.
+  let _cachedBounds: DxGridRange | null = null;
+  const cachedCells: DxGridCells = {};
+  return (nextBounds: DxGridRange): DxGridCells => {
+    [...Array(nextBounds.end.col - nextBounds.start.col)].forEach((_, c0) => {
+      return [...Array(nextBounds.end.row - nextBounds.start.row)].forEach((_, r0) => {
+        const col = nextBounds.start.col + c0;
+        const row = nextBounds.start.row + r0;
+        const cell = formatting.getFormatting({ col, row });
+        if (cell.value) {
+          cachedCells[`${col},${row}`] = { value: cell.value, className: mx(cell.classNames) };
+        }
+      });
+    });
+    _cachedBounds = nextBounds;
+    return cachedCells;
+  };
+};
+
 export const useSheetModelDxGridProps = (
+  dxGridRef: MutableRefObject<DxGridElement | null>,
   model: SheetModel,
   formatting: FormattingModel,
-): Pick<GridContentProps, 'cells' | 'columns' | 'rows'> => {
-  const [dxGridCells, setDxGridCells] = useState<GridContentProps['cells']>(createDxGridCells(model, formatting));
-  const [dxGridColumns, setDxGridColumns] = useState<GridContentProps['columns']>(createDxGridColumns(model));
-  const [dxGridRows, setDxGridRows] = useState<GridContentProps['rows']>(createDxGridColumns(model));
+): Pick<GridContentProps, 'columns' | 'rows'> => {
+  const [columns, setColumns] = useState<DxGridAxisMeta>(createDxGridColumns(model));
+  const [rows, setRows] = useState<DxGridAxisMeta>(createDxGridColumns(model));
 
-  useEffect(() => {
+  useLayoutEffect(() => {
     const cellsAccessor = createDocAccessor(model.sheet, ['cells']);
+    if (dxGridRef.current) {
+      dxGridRef.current.getCells = cellGetter(model, formatting);
+    }
     const handleCellsUpdate = () => {
-      setDxGridCells(createDxGridCells(model, formatting));
+      dxGridRef.current?.requestUpdate('initialCells');
     };
     cellsAccessor.handle.addListener('change', handleCellsUpdate);
     return () => cellsAccessor.handle.removeListener('change', handleCellsUpdate);
@@ -72,10 +91,10 @@ export const useSheetModelDxGridProps = (
     const columnMetaAccessor = createDocAccessor(model.sheet, ['columnMeta']);
     const rowMetaAccessor = createDocAccessor(model.sheet, ['rowMeta']);
     const handleColumnMetaUpdate = () => {
-      setDxGridColumns(createDxGridColumns(model));
+      setColumns(createDxGridColumns(model));
     };
     const handleRowMetaUpdate = () => {
-      setDxGridRows(createDxGridRows(model));
+      setRows(createDxGridRows(model));
     };
     columnMetaAccessor.handle.addListener('change', handleColumnMetaUpdate);
     rowMetaAccessor.handle.addListener('change', handleRowMetaUpdate);
@@ -85,5 +104,5 @@ export const useSheetModelDxGridProps = (
     };
   }, [model]);
 
-  return { cells: dxGridCells, columns: dxGridColumns, rows: dxGridRows };
+  return { columns, rows };
 };

package/src/components/Sheet/Sheet.stories.tsx

@@ -7,7 +7,7 @@ import '@dxos-theme';
 import React, { useState } from 'react';
 
 import { log } from '@dxos/log';
-import { type Space, useSpace } from '@dxos/react-client/echo';
+import { useSpace } from '@dxos/react-client/echo';
 import { withClientProvider } from '@dxos/react-client/testing';
 import { Button } from '@dxos/react-ui';
 import { mx } from '@dxos/react-ui-theme';
@@ -17,18 +17,19 @@ import { Sheet } from './Sheet';
 import { type SizeMap } from './grid';
 import { useSheetContext } from './sheet-context';
 import { addressToIndex, rangeToIndex } from '../../defs';
+import { type ComputeGraph } from '../../graph';
+import { testPlugins } from '../../graph/testing';
 import { useComputeGraph } from '../../hooks';
-import { useTestSheet, withGraphDecorator } from '../../testing';
+import { createTestCells, useTestSheet, withComputeGraphDecorator } from '../../testing';
 import { SheetType, ValueTypeEnum } from '../../types';
 import { Toolbar, type ToolbarActionHandler } from '../Toolbar';
 
 // TODO(burdon): Allow toolbar to access sheet context; provide state for current cursor/range.
-const SheetWithToolbar = ({ debug, space }: { debug?: boolean; space: Space }) => {
+const SheetWithToolbar = ({ graph, debug }: { graph: ComputeGraph; debug?: boolean }) => {
   const { model, cursor, range } = useSheetContext();
 
-  const graph = useComputeGraph(space);
   const handleRefresh = () => {
-    graph?.refresh();
+    // graph?.refresh(); // TODO(burdon): ???
   };
 
   // TODO(burdon): Factor out.
@@ -104,7 +105,7 @@ export default {
   component: Sheet,
   decorators: [
     withClientProvider({ types: [SheetType], createIdentity: true }),
-    withGraphDecorator,
+    withComputeGraphDecorator({ plugins: testPlugins }),
     withTheme,
     withLayout({ fullscreen: true, tooltips: true, classNames: 'inset-4' }),
   ],
@@ -114,14 +115,14 @@ export const Default = () => {
   const [debug, setDebug] = useState(false);
   const space = useSpace();
   const graph = useComputeGraph(space);
-  const sheet = useTestSheet(space, graph);
-  if (!space || !sheet) {
+  const sheet = useTestSheet(space, graph, { cells: createTestCells() });
+  if (!graph || !sheet) {
     return null;
   }
 
   return (
-    <Sheet.Root space={space} sheet={sheet} onInfo={() => setDebug((debug) => !debug)}>
-      <SheetWithToolbar debug={debug} space={space} />
+    <Sheet.Root graph={graph} sheet={sheet} onInfo={() => setDebug((debug) => !debug)}>
+      <SheetWithToolbar graph={graph} debug={debug} />
     </Sheet.Root>
   );
 };
@@ -129,13 +130,13 @@ export const Default = () => {
 export const Debug = () => {
   const space = useSpace();
   const graph = useComputeGraph(space);
-  const sheet = useTestSheet(space, graph);
-  if (!sheet || !space) {
+  const sheet = useTestSheet(space, graph, { cells: createTestCells() });
+  if (!graph || !sheet) {
     return null;
   }
 
   return (
-    <Sheet.Root space={space} sheet={sheet}>
+    <Sheet.Root graph={graph} sheet={sheet}>
       <Sheet.Main />
       <Sheet.Debug />
     </Sheet.Root>
@@ -147,12 +148,12 @@ export const Rows = () => {
   const space = useSpace();
   const graph = useComputeGraph(space);
   const sheet = useTestSheet(space, graph);
-  if (!sheet || !space) {
+  if (!graph || !sheet) {
     return null;
   }
 
   return (
-    <Sheet.Root space={space} sheet={sheet}>
+    <Sheet.Root graph={graph} sheet={sheet}>
       <Sheet.Rows
         rows={sheet.rows}
         sizes={rowSizes}
@@ -167,12 +168,12 @@ export const Columns = () => {
   const space = useSpace();
   const graph = useComputeGraph(space);
   const sheet = useTestSheet(space, graph);
-  if (!sheet || !space) {
+  if (!graph || !sheet) {
     return null;
   }
 
   return (
-    <Sheet.Root space={space} sheet={sheet}>
+    <Sheet.Root graph={graph} sheet={sheet}>
       <Sheet.Columns
         columns={sheet.columns}
         sizes={columnSizes}
@@ -185,13 +186,13 @@ export const Columns = () => {
 export const Main = () => {
   const space = useSpace();
   const graph = useComputeGraph(space);
-  const sheet = useTestSheet(space, graph);
-  if (!sheet || !space) {
+  const sheet = useTestSheet(space, graph, { cells: createTestCells() });
+  if (!graph || !sheet) {
     return null;
   }
 
   return (
-    <Sheet.Root space={space} sheet={sheet}>
+    <Sheet.Root graph={graph} sheet={sheet}>
       <Sheet.Grid
         size={{
           numRows: 50,

package/src/components/Sheet/sheet-context.tsx

@@ -5,10 +5,10 @@
 import React, { type PropsWithChildren, createContext, useContext, useMemo, useState } from 'react';
 
 import { invariant } from '@dxos/invariant';
-import { type Space } from '@dxos/react-client/echo';
 
 import { createDecorations } from './decorations';
 import { type CellAddress, type CellRange } from '../../defs';
+import { type ComputeGraph } from '../../graph';
 import { useSheetModel, useFormattingModel } from '../../hooks';
 import { type FormattingModel, type SheetModel } from '../../model';
 import { type SheetType } from '../../types';
@@ -45,19 +45,19 @@ export const useSheetContext = (): SheetContextType => {
 };
 
 export type SheetContextProps = {
+  graph: ComputeGraph;
   sheet: SheetType;
-  space: Space;
   readonly?: boolean;
 } & Pick<SheetContextType, 'onInfo'>;
 
 export const SheetContextProvider = ({
   children,
+  graph,
   sheet,
-  space,
   readonly,
   onInfo,
 }: PropsWithChildren<SheetContextProps>) => {
-  const model = useSheetModel(space, sheet, { readonly });
+  const model = useSheetModel(graph, sheet, { readonly });
   const formatting = useFormattingModel(model);
 
   // TODO(Zan): Impl. set range and set cursor that scrolls to that cell or range if it is not visible.

package/src/components/SheetContainer.tsx

@@ -22,7 +22,7 @@ const attentionFragment = mx(
 export const sectionToolbarLayout =
   'bs-[--rail-action] bg-[--sticky-bg] sticky block-start-0 __-block-start-px transition-opacity';
 
-const SheetContainer = ({ sheet, space, role }: SheetRootProps & { role?: string }) => {
+const SheetContainer = ({ graph, sheet, role }: SheetRootProps & { role?: string }) => {
   const dispatch = useIntentDispatcher();
 
   const id = fullyQualifiedId(sheet);
@@ -50,7 +50,7 @@ const SheetContainer = ({ sheet, space, role }: SheetRootProps & { role?: string
 
   return (
     <div role='none' className={role === 'article' ? 'row-span-2 grid grid-rows-subgrid' : undefined}>
-      <Sheet.Root space={space} sheet={sheet}>
+      <Sheet.Root graph={graph} sheet={sheet}>
         <div role='none' className={mx('flex flex-0 justify-center overflow-x-auto')}>
           <Toolbar.Root
             onAction={handleAction}

package/src/defs/types.ts

@@ -34,6 +34,7 @@ export const addressToA1Notation = ({ col, row }: CellAddress): string => {
   return `${columnLetter(col)}${row + 1}`;
 };
 
+// TODO(burdon): See simpleCellAddressFromString
 export const addressFromA1Notation = (ref: string): CellAddress => {
   const match = ref.match(/([A-Z]+)(\d+)/);
   invariant(match, `Invalid notation: ${ref}`);

package/src/defs/util.ts

@@ -5,7 +5,15 @@
 import { randomBytes } from '@dxos/crypto';
 import { create } from '@dxos/echo-schema';
 
-import { type CellAddress, type CellRange, DEFAULT_COLUMNS, DEFAULT_ROWS, MAX_COLUMNS, MAX_ROWS } from './types';
+import {
+  addressFromA1Notation,
+  type CellAddress,
+  type CellRange,
+  DEFAULT_COLUMNS,
+  DEFAULT_ROWS,
+  MAX_COLUMNS,
+  MAX_ROWS,
+} from './types';
 import { type CreateSheetOptions, type SheetSize, SheetType } from '../types';
 
 // TODO(burdon): Factor out from dxos/protocols to new common package.
@@ -52,9 +60,9 @@ export const initialize = (
   }
 };
 
-export const createSheet = ({ title, ...size }: CreateSheetOptions = {}): SheetType => {
+export const createSheet = ({ name, cells, ...size }: CreateSheetOptions = {}): SheetType => {
   const sheet = create(SheetType, {
-    title,
+    name,
     cells: {},
     rows: [],
     columns: [],
@@ -64,6 +72,14 @@ export const createSheet = ({ title, ...size }: CreateSheetOptions = {}): SheetT
   });
 
   initialize(sheet, size);
+
+  if (cells) {
+    Object.entries(cells).forEach(([key, { value }]) => {
+      const idx = addressToIndex(sheet, addressFromA1Notation(key));
+      sheet.cells[idx] = { value };
+    });
+  }
+
   return sheet;
 };
 

package/src/extensions/compute.stories.tsx

@@ -3,10 +3,11 @@
 //
 
 import '@dxos-theme';
-import React, { useEffect, useState } from 'react';
+import React, { useEffect } from 'react';
 
 import { useSpace } from '@dxos/react-client/echo';
 import { withClientProvider } from '@dxos/react-client/testing';
+import { useAsyncState } from '@dxos/react-hooks';
 import { useThemeContext } from '@dxos/react-ui';
 import {
   createBasicExtensions,
@@ -18,11 +19,11 @@ import {
 import { withTheme, withLayout } from '@dxos/storybook-utils';
 import { nonNullable } from '@dxos/util';
 
-import { compute } from './compute';
+import { compute, computeNodeFacet } from './compute';
 import { Sheet } from '../components';
 import { type ComputeNode } from '../graph';
 import { useComputeGraph, useSheetModel } from '../hooks';
-import { useTestSheet, withGraphDecorator } from '../testing';
+import { useTestSheet, withComputeGraphDecorator } from '../testing';
 import { SheetType } from '../types';
 
 const str = (...lines: string[]) => lines.join('\n');
@@ -34,6 +35,8 @@ type EditorProps = {
 // TODO(burdon): Implement named expressions.
 //  https://hyperformula.handsontable.com/guide/cell-references.html
 
+// TODO(burdon): Inline Adobe eCharts.
+
 const DOC_NAME = 'Test Doc';
 const SHEET_NAME = 'Test Sheet';
 
@@ -41,12 +44,8 @@ const Editor = ({ text }: EditorProps) => {
   const { themeMode } = useThemeContext();
   const space = useSpace();
   const graph = useComputeGraph(space);
-  const [node, setNode] = useState<ComputeNode>();
-  // TODO(burdon): Virtualize SheetModel.
-  useEffect(() => {
-    if (graph) {
-      setNode(graph.getOrCreateNode(DOC_NAME));
-    }
+  const [computeNode] = useAsyncState<ComputeNode>(async () => {
+    return graph ? await graph.getOrCreateNode(DOC_NAME) : undefined;
   }, [graph]);
   const { parentRef, focusAttributes } = useTextEditor(
     () => ({
@@ -55,11 +54,12 @@ const Editor = ({ text }: EditorProps) => {
         createBasicExtensions(),
         createMarkdownExtensions({ themeMode }),
         createThemeExtensions({ themeMode, syntaxHighlighting: true }),
-        node && compute(node),
+        computeNode && computeNodeFacet.of(computeNode),
+        compute(),
         decorateMarkdown(),
       ].filter(nonNullable),
     }),
-    [node, themeMode],
+    [computeNode, themeMode],
   );
 
   return <div className='w-[40rem] overflow-hidden' ref={parentRef} {...focusAttributes} />;
@@ -68,21 +68,21 @@ const Editor = ({ text }: EditorProps) => {
 const Grid = () => {
   const space = useSpace();
   const graph = useComputeGraph(space);
-  const sheet = useTestSheet(space, graph, { title: SHEET_NAME });
-  const model = useSheetModel(space, sheet);
+  const sheet = useTestSheet(space, graph, { name: SHEET_NAME });
+  const model = useSheetModel(graph, sheet);
   useEffect(() => {
     if (model) {
       model.setValues({ A1: { value: 100 }, A2: { value: 200 }, A3: { value: 300 }, A5: { value: '=SUM(A1:A3)' } });
     }
   }, [model]);
 
-  if (!space || !sheet) {
+  if (!graph || !sheet) {
     return null;
   }
 
   return (
     <div className='flex w-[40rem] overflow-hidden'>
-      <Sheet.Root space={space} sheet={sheet}>
+      <Sheet.Root graph={graph} sheet={sheet}>
         <Sheet.Main classNames='border border-separator' />
       </Sheet.Root>
     </div>
@@ -102,13 +102,14 @@ export default {
   title: 'plugin-sheet/extensions',
   decorators: [
     withClientProvider({ types: [SheetType], createIdentity: true, createSpace: true }),
-    withGraphDecorator,
+    withComputeGraphDecorator(),
     withTheme,
     withLayout({ fullscreen: true, classNames: 'justify-center' }),
   ],
   parameters: { layout: 'fullscreen' },
 };
 
+// TODO(burdon): Inline formulae.
 export const Default = {
   render: Editor,
   args: {
@@ -146,6 +147,7 @@ export const Graph = {
       `="${SHEET_NAME}"!A5`,
       '```',
       '',
+      '',
     ),
   },
 };

package/src/extensions/compute.ts

@@ -3,6 +3,7 @@
 //
 
 import { syntaxTree } from '@codemirror/language';
+import { Facet } from '@codemirror/state';
 import {
   type EditorState,
   type Extension,
@@ -14,7 +15,21 @@ import {
 } from '@codemirror/state';
 import { Decoration, EditorView, ViewPlugin, WidgetType } from '@codemirror/view';
 
+import { type UnsubscribeCallback } from '@dxos/async';
+import { type Space } from '@dxos/client/echo';
+
+import { type CellAddress } from '../defs';
 import { type ComputeNode } from '../graph';
+import { type CellScalarValue } from '../types';
+
+export const spaceFacet = Facet.define<Space, Space>({
+  combine: (values) => values[0],
+});
+
+// TODO(burdon): Create on demand?
+export const computeNodeFacet = Facet.define<ComputeNode, ComputeNode>({
+  combine: (values) => values[0],
+});
 
 const LANGUAGE_TAG = 'dx';
 
@@ -23,36 +38,46 @@ const updateAllDecorations = StateEffect.define<void>();
 
 export type ComputeOptions = {};
 
-export const compute = (computeNode: ComputeNode, options: ComputeOptions = {}): Extension => {
-  const update = (state: EditorState) => {
-    const builder = new RangeSetBuilder();
-    syntaxTree(state).iterate({
-      enter: (node) => {
-        if (node.name === 'FencedCode') {
-          const cursor = state.selection.main.head;
-          if (state.readOnly || cursor < node.from || cursor > node.to) {
-            const info = node.node.getChild('CodeInfo');
-            if (info) {
-              const type = state.sliceDoc(info.from, info.to);
-              const text = node.node.getChild('CodeText');
-              if (type === LANGUAGE_TAG && text) {
-                const content = state.sliceDoc(text.from, text.to);
-                // TODO(burdon): Map unique reference onto cell; e.g., track ordered list?
-                computeNode.setValue({ col: 0, row: 0 }, content);
-                const value = computeNode.getValue({ col: 0, row: 0 });
-                builder.add(
-                  node.from,
-                  node.to,
-                  Decoration.replace({
-                    widget: new DxWidget(String(value)),
-                  }),
-                );
+export const compute = (options: ComputeOptions = {}): Extension => {
+  const update = (state: EditorState, rangeSet?: RangeSet<Decoration>) => {
+    const builder = new RangeSetBuilder<Decoration>();
+    const computeNode = state.facet(computeNodeFacet);
+    if (computeNode) {
+      computeNode.clear();
+      syntaxTree(state).iterate({
+        enter: (node) => {
+          if (node.name === 'FencedCode') {
+            const cursor = state.selection.main.head;
+            if (state.readOnly || cursor < node.from || cursor > node.to) {
+              const info = node.node.getChild('CodeInfo');
+              if (info) {
+                const type = state.sliceDoc(info.from, info.to);
+                const text = node.node.getChild('CodeText');
+                if (type === LANGUAGE_TAG && text) {
+                  const formula = state.sliceDoc(text.from, text.to);
+                  const iter = rangeSet?.iter(node.node.from);
+                  if (iter?.value && iter?.value.spec.formula === formula) {
+                    builder.add(node.from, node.to, iter.value);
+                  } else {
+                    const cell: CellAddress = { col: node.node.from, row: 0 };
+                    computeNode.setValue(cell, formula);
+                    const value = computeNode.getValue(cell);
+                    builder.add(
+                      node.from,
+                      node.to,
+                      Decoration.replace({
+                        widget: new DxWidget(formula, value),
+                        formula,
+                      }),
+                    );
+                  }
+                }
               }
             }
           }
-        }
-      },
-    });
+        },
+      });
+    }
 
     return builder.finish();
   };
@@ -61,38 +86,46 @@ export const compute = (computeNode: ComputeNode, options: ComputeOptions = {}):
     // Graph subscription.
     ViewPlugin.fromClass(
       class {
-        private readonly _subscription: any;
+        private readonly _subscription?: UnsubscribeCallback;
         constructor(view: EditorView) {
-          this._subscription = computeNode.graph.update.on(() => {
-            view.dispatch({
-              effects: updateAllDecorations.of(),
+          const computeNode = view.state.facet(computeNodeFacet);
+          if (computeNode) {
+            this._subscription = computeNode.update.on(({ type }) => {
+              if (type === 'valuesUpdated') {
+                view.dispatch({
+                  effects: updateAllDecorations.of(),
+                });
+              }
             });
-          });
+          }
         }
 
         destroy() {
-          this._subscription();
+          this._subscription?.();
         }
       },
     ),
 
-    // Decorations.
-    StateField.define<RangeSet<any>>({
+    StateField.define<RangeSet<Decoration>>({
       create: (state) => update(state),
-      update: (_: RangeSet<any>, tr: Transaction) => update(tr.state),
+      update: (rangeSet: RangeSet<Decoration>, tr: Transaction) => update(tr.state, rangeSet),
       provide: (field) => EditorView.decorations.from(field),
     }),
   ];
 };
 
 class DxWidget extends WidgetType {
-  constructor(private readonly value: string) {
+  constructor(
+    private readonly formula: string,
+    private readonly value: CellScalarValue,
+  ) {
     super();
   }
 
-  override toDOM(view: EditorView) {
+  override toDOM(_view: EditorView) {
     const div = document.createElement('div');
-    div.innerText = this.value;
+    div.setAttribute('title', this.formula);
+    div.innerText = String(this.value);
     return div;
   }
 }