@dxos/plugin-sheet 0.8.4-main.67995b8 → 0.8.4-main.69d29f4

package/src/model/sheet-model.ts

@@ -4,10 +4,6 @@
 
 import { Event } from '@dxos/async';
 import {
-  addressFromA1Notation,
-  addressToA1Notation,
-  createSheetName,
-  isFormula,
   type CellAddress,
   type CellRange,
   type CellScalarValue,
@@ -16,14 +12,18 @@ import {
   type ComputeNodeEvent,
   DetailedCellError,
   ExportedCellChange,
-  type SimpleCellRange,
   type SimpleCellAddress,
+  type SimpleCellRange,
   type SimpleDate,
   type SimpleDateTime,
+  addressFromA1Notation,
+  addressToA1Notation,
+  createSheetName,
+  isFormula,
 } from '@dxos/compute';
 import { Resource } from '@dxos/context';
 import { Obj } from '@dxos/echo';
-import { FormatEnum, TypeEnum } from '@dxos/echo-schema';
+import { Format, TypeEnum } from '@dxos/echo/internal';
 import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
@@ -39,21 +39,21 @@ import {
   mapFormulaIndicesToRefs,
   mapFormulaRefsToIndices,
 } from '../types';
-import { type SheetAction, type CellValue, type SheetType } from '../types';
+import { type Sheet, type SheetAction } from '../types';
 
 // TODO(burdon): Move to compute.
 // Map sheet types to system types.
 // https://hyperformula.handsontable.com/guide/types-of-values.html
 //  - https://github.com/handsontable/hyperformula/blob/master/src/Cell.ts (CellValueType)
 //  - https://github.com/handsontable/hyperformula/blob/master/src/interpreter/InterpreterValue.ts (NumberType)
-const typeMap: Record<string, { type: TypeEnum; format?: FormatEnum }> = {
+const typeMap: Record<string, { type: TypeEnum; format?: Format.TypeFormat }> = {
   BOOLEAN: { type: TypeEnum.Boolean },
   NUMBER_RAW: { type: TypeEnum.Number },
-  NUMBER_PERCENT: { type: TypeEnum.Number, format: FormatEnum.Percent },
-  NUMBER_CURRENCY: { type: TypeEnum.Number, format: FormatEnum.Currency },
-  NUMBER_DATETIME: { type: TypeEnum.String, format: FormatEnum.DateTime },
-  NUMBER_DATE: { type: TypeEnum.String, format: FormatEnum.Date },
-  NUMBER_TIME: { type: TypeEnum.String, format: FormatEnum.Time },
+  NUMBER_PERCENT: { type: TypeEnum.Number, format: Format.TypeFormat.Percent },
+  NUMBER_CURRENCY: { type: TypeEnum.Number, format: Format.TypeFormat.Currency },
+  NUMBER_DATETIME: { type: TypeEnum.String, format: Format.TypeFormat.DateTime },
+  NUMBER_DATE: { type: TypeEnum.String, format: Format.TypeFormat.Date },
+  NUMBER_TIME: { type: TypeEnum.String, format: Format.TypeFormat.Time },
 };
 
 const getTopLeft = (range: CellRange): CellAddress => {
@@ -92,7 +92,7 @@ export class SheetModel extends Resource {
 
   constructor(
     private readonly _graph: ComputeGraph,
-    private readonly _sheet: SheetType,
+    private readonly _sheet: Sheet.Sheet,
     private readonly _options: SheetModelOptions = {},
   ) {
     super();
@@ -122,7 +122,9 @@ export class SheetModel extends Resource {
    */
   protected override async _open(): Promise<void> {
     log('initialize', { id: this.id });
-    initialize(this._sheet);
+    Obj.change(this._sheet, (s) => {
+      initialize(s);
+    });
 
     this._graph.update.on((event) => {
       if (event.type === 'functionsUpdated') {
@@ -181,13 +183,19 @@ export class SheetModel extends Resource {
   }
 
   insertRows(i: number, n = 1): string[] {
-    const idx = insertIndices(this._sheet.rows, i, n, MAX_ROWS);
+    let idx: string[] = [];
+    Obj.change(this._sheet, (s) => {
+      idx = insertIndices(s.rows, i, n, MAX_ROWS);
+    });
     this.reset();
     return idx;
   }
 
   insertColumns(i: number, n = 1): string[] {
-    const idx = insertIndices(this._sheet.columns, i, n, MAX_COLS);
+    let idx: string[] = [];
+    Obj.change(this._sheet, (s) => {
+      idx = insertIndices(s.columns, i, n, MAX_COLS);
+    });
     this.reset();
     return idx;
   }
@@ -200,8 +208,10 @@ export class SheetModel extends Resource {
     const values = this.getCellValues(range).flat();
     const index = this._sheet.rows.indexOf(rowIndex);
     this.clear(range);
-    this._sheet.rows.splice(index, 1);
-    delete this._sheet.rowMeta[rowIndex];
+    Obj.change(this._sheet, (s) => {
+      s.rows.splice(index, 1);
+      delete s.rowMeta[rowIndex];
+    });
     this.reset();
     return { axis: 'row', index, axisIndex: rowIndex, axisMeta: this._sheet.rowMeta[rowIndex], values };
   }
@@ -214,35 +224,41 @@ export class SheetModel extends Resource {
     const values = this.getCellValues(range).flat();
     const index = this._sheet.columns.indexOf(colIndex);
     this.clear(range);
-    this._sheet.columns.splice(index, 1);
-    delete this._sheet.columnMeta[colIndex];
+    Obj.change(this._sheet, (s) => {
+      s.columns.splice(index, 1);
+      delete s.columnMeta[colIndex];
+    });
     this.reset();
     return { axis: 'col', index, axisIndex: colIndex, axisMeta: this._sheet.rowMeta[colIndex], values };
   }
 
   restoreRow({ index, axisIndex, axisMeta, values }: SheetAction.RestoreAxis): void {
-    this._sheet.rows.splice(index, 0, axisIndex);
-    values.forEach((value, col) => {
-      if (value) {
-        this._sheet.cells[`${this._sheet.columns[col]}@${axisIndex}`] = { value };
+    Obj.change(this._sheet, (s) => {
+      s.rows.splice(index, 0, axisIndex);
+      values.forEach((value, col) => {
+        if (value) {
+          s.cells[`${s.columns[col]}@${axisIndex}`] = { value };
+        }
+      });
+      if (axisMeta) {
+        s.rowMeta[axisIndex] = axisMeta;
       }
     });
-    if (axisMeta) {
-      this._sheet.rowMeta[axisIndex] = axisMeta;
-    }
     this.reset();
   }
 
   restoreColumn({ index, axisIndex, axisMeta, values }: SheetAction.RestoreAxis): void {
-    this._sheet.columns.splice(index, 0, axisIndex);
-    values.forEach((value, row) => {
-      if (value) {
-        this._sheet.cells[`${axisIndex}@${this._sheet.rows[row]}`] = { value };
+    Obj.change(this._sheet, (s) => {
+      s.columns.splice(index, 0, axisIndex);
+      values.forEach((value, row) => {
+        if (value) {
+          s.cells[`${axisIndex}@${s.rows[row]}`] = { value };
+        }
+      });
+      if (axisMeta) {
+        s.columnMeta[axisIndex] = axisMeta;
       }
     });
-    if (axisMeta) {
-      this._sheet.columnMeta[axisIndex] = axisMeta;
-    }
     this.reset();
   }
 
@@ -259,18 +275,22 @@ export class SheetModel extends Resource {
     const topLeft = getTopLeft(range);
     const values = this._iterRange(range, () => null);
     this._node.graph.hf.setCellContents(toSimpleCellAddress(this._node.sheetId, topLeft), values);
-    this._iterRange(range, (cell) => {
-      const idx = addressToIndex(this._sheet, cell);
-      delete this._sheet.cells[idx];
+    Obj.change(this._sheet, (s) => {
+      this._iterRange(range, (cell) => {
+        const idx = addressToIndex(this._sheet, cell);
+        delete s.cells[idx];
+      });
     });
   }
 
   cut(range: CellRange): void {
     invariant(this._node);
     this._node.graph.hf.cut(toModelRange(this._node.sheetId, range));
-    this._iterRange(range, (cell) => {
-      const idx = addressToIndex(this._sheet, cell);
-      delete this._sheet.cells[idx];
+    Obj.change(this._sheet, (s) => {
+      this._iterRange(range, (cell) => {
+        const idx = addressToIndex(this._sheet, cell);
+        delete s.cells[idx];
+      });
     });
   }
 
@@ -283,13 +303,15 @@ export class SheetModel extends Resource {
     invariant(this._node);
     if (!this._node.graph.hf.isClipboardEmpty()) {
       const changes = this._node.graph.hf.paste(toSimpleCellAddress(this._node.sheetId, cell));
-      for (const change of changes) {
-        if (change instanceof ExportedCellChange) {
-          const { address, newValue } = change;
-          const idx = addressToIndex(this._sheet, { row: address.row, col: address.col });
-          this._sheet.cells[idx] = { value: newValue };
+      Obj.change(this._sheet, (s) => {
+        for (const change of changes) {
+          if (change instanceof ExportedCellChange) {
+            const { address, newValue } = change;
+            const idx = addressToIndex(this._sheet, { row: address.row, col: address.col });
+            s.cells[idx] = { value: newValue };
+          }
         }
-      }
+      });
     }
   }
 
@@ -361,7 +383,7 @@ export class SheetModel extends Resource {
   /**
    * Get value type.
    */
-  getValueDescription(cell: CellAddress): { type: TypeEnum; format?: FormatEnum } | undefined {
+  getValueDescription(cell: CellAddress): { type: TypeEnum; format?: Format.TypeFormat } | undefined {
     invariant(this._node);
     const addr = toSimpleCellAddress(this._node.sheetId, cell);
     const type = this._node.graph.hf.getCellValueDetailedType(addr);
@@ -380,11 +402,15 @@ export class SheetModel extends Resource {
     // Reallocate if > current bounds.
     let refresh = false;
     if (cell.row >= this._sheet.rows.length) {
-      insertIndices(this._sheet.rows, cell.row, 1, MAX_ROWS);
+      Obj.change(this._sheet, (s) => {
+        insertIndices(s.rows, cell.row, 1, MAX_ROWS);
+      });
       refresh = true;
     }
     if (cell.col >= this._sheet.columns.length) {
-      insertIndices(this._sheet.columns, cell.col, 1, MAX_COLS);
+      Obj.change(this._sheet, (s) => {
+        insertIndices(s.columns, cell.col, 1, MAX_COLS);
+      });
       refresh = true;
     }
 
@@ -401,20 +427,24 @@ export class SheetModel extends Resource {
     // Insert into sheet.
     const idx = addressToIndex(this._sheet, cell);
     if (value === undefined || value === null) {
-      delete this._sheet.cells[idx];
+      Obj.change(this._sheet, (s) => {
+        delete s.cells[idx];
+      });
     } else {
       if (isFormula(value)) {
         value = this._graph.mapFunctionBindingToId(mapFormulaRefsToIndices(this._sheet, value));
       }
 
-      this._sheet.cells[idx] = { value };
+      Obj.change(this._sheet, (s) => {
+        s.cells[idx] = { value };
+      });
     }
   }
 
   /**
    * Sets values from a simple map.
    */
-  setValues(values: Record<string, CellValue>): void {
+  setValues(values: Record<string, Sheet.CellValue>): void {
     Object.entries(values).forEach(([key, { value }]) => {
       this.setValue(addressFromA1Notation(key), value);
     });

package/src/model/testing.ts

@@ -4,14 +4,14 @@
 
 import { addressToA1Notation } from '@dxos/compute';
 
-import { type CellValue, type SheetType, createSheet } from '../types';
+import { Sheet } from '../types';
 
 // TODO(burdon): Create testing endpoint.
 // TODO(burdon): Move to react-ui-sheet.
-export const createTestGrid = ({ cols = 4, rows = 10 }: { cols: number; rows: number }): SheetType => {
+export const createTestGrid = ({ cols = 4, rows = 10 }: { cols: number; rows: number }): Sheet.Sheet => {
   const year = new Date().getFullYear();
 
-  const cells: Record<string, CellValue> = {};
+  const cells: Record<string, Sheet.CellValue> = {};
   for (let col = 1; col <= cols; col++) {
     for (let row = 1; row <= 10; row++) {
       const cell = addressToA1Notation({ col, row });
@@ -27,7 +27,7 @@ export const createTestGrid = ({ cols = 4, rows = 10 }: { cols: number; rows: nu
     }
   }
 
-  const sheet = createSheet({
+  const sheet = Sheet.make({
     name: 'Test',
     cells,
   });

package/src/model/useSheetModel.ts

@@ -7,7 +7,7 @@ import { useEffect, useState } from 'react';
 import { type ComputeGraph } from '@dxos/compute';
 
 import { SheetModel } from '../model';
-import { type SheetType } from '../types';
+import { type Sheet } from '../types';
 
 export type UseSheetModelOptions = {
   readonly?: boolean;
@@ -15,7 +15,7 @@ export type UseSheetModelOptions = {
 
 export const useSheetModel = (
   graph?: ComputeGraph,
-  sheet?: SheetType,
+  sheet?: Sheet.Sheet,
   { readonly }: UseSheetModelOptions = {},
 ): SheetModel | undefined => {
   const [model, setModel] = useState<SheetModel>();

package/src/playwright/playwright.config.ts

@@ -10,7 +10,7 @@ export default defineConfig({
   ...e2ePreset(import.meta.dirname),
   // TODO(wittjosiah): Avoid hard-coding ports.
   webServer: {
-    command: 'moon run storybook:serve-e2e -- --port=9005',
+    command: 'moon run storybook-react:serve-e2e -- --port=9005',
     port: 9005,
     reuseExistingServer: false,
   },

package/src/playwright/sheet-manager.ts

@@ -5,7 +5,7 @@
 import { type Locator, type Page } from '@playwright/test';
 
 import { DxGridManager } from '@dxos/lit-grid/testing';
-import { type DxGridPosition, type DxGridAxis } from '@dxos/react-ui-grid';
+import { type DxGridAxis, type DxGridPosition } from '@dxos/react-ui-grid';
 
 /**
  * Test helper for managing dx-grid interactions and assertions in Playwright tests.

package/src/playwright/sheet.spec.ts

@@ -2,7 +2,7 @@
 // Copyright 2021 DXOS.org
 //
 
-import { expect, test, type Page } from '@playwright/test';
+import { type Page, expect, test } from '@playwright/test';
 
 import { faker } from '@dxos/random';
 import { setupPage, storybookUrl } from '@dxos/test-utils/playwright';
@@ -16,6 +16,7 @@ test.describe('plugin-sheet', () => {
   test.beforeEach(async ({ browser }) => {
     const setup = await setupPage(browser, {
       url: storybookUrl('plugins-plugin-sheet-sheetcontainer--spec', 9005),
+      viewportSize: { width: 1280, height: 720 },
     });
     page = setup.page;
     sheet = new SheetManager(page);

package/src/sanity.test.ts

@@ -2,11 +2,10 @@
 // Copyright 2024 DXOS.org
 //
 
-import { describe, test, expect } from 'vitest';
+import { describe, expect, test } from 'vitest';
 
 import { Client } from '@dxos/client';
-import { Obj } from '@dxos/echo';
-import { FunctionType } from '@dxos/functions';
+import { Function } from '@dxos/functions';
 
 // Part 2.
 // TODO(burdon): Cannot test outside of browser.
@@ -23,7 +22,7 @@ import { FunctionType } from '@dxos/functions';
 describe('test', () => {
   test('test', async () => {
     const client = new Client();
-    client.addTypes([FunctionType]);
+    await client.addTypes([Function.Function]);
     await client.initialize();
     await client.halo.createIdentity();
 
@@ -34,7 +33,7 @@ describe('test', () => {
     //  - ERROR "process.nextTick is not a function"
     //  - ERROR "Identifier 'Buffer' has already been declared" if { nodeExternal: true }
     const space = await client.spaces.create();
-    const fn = space.db.add(Obj.make(FunctionType, { name: 'test', version: '0.0.1', binding: 'HELLO' }));
+    const fn = space.db.add(Function.make({ name: 'test', version: '0.0.1', binding: 'HELLO' }));
     expect(fn).to.exist;
   });
 });

package/src/serializer.ts

@@ -3,19 +3,19 @@
 //
 
 import { Obj } from '@dxos/echo';
+import { getObjectCore } from '@dxos/echo-db';
 import { type TypedObjectSerializer } from '@dxos/plugin-space/types';
-import { getObjectCore } from '@dxos/react-client/echo';
 
-import { SheetType } from './types';
+import { Sheet } from './types';
 
-export const serializer: TypedObjectSerializer<SheetType> = {
+export const serializer: TypedObjectSerializer<Sheet.Sheet> = {
   serialize: async ({ object }): Promise<string> => {
     return JSON.stringify(object, null, 2);
   },
 
   deserialize: async ({ content, newId }) => {
     const { id, ...parsed } = JSON.parse(content);
-    const sheet = Obj.make(SheetType, parsed);
+    const sheet = Obj.make(Sheet.Sheet, parsed);
 
     if (!newId) {
       const core = getObjectCore(sheet);

package/src/testing/data.ts

@@ -2,9 +2,9 @@
 // Copyright 2024 DXOS.org
 //
 
-import type { CellValue } from '../types';
+import type { Sheet } from '../types';
 
-export const createTestCells = (testSheetName = 'test'): Record<string, CellValue> => ({
+export const createTestCells = (testSheetName = 'test'): Record<string, Sheet.CellValue> => ({
   B1: { value: 'Qty2' },
   B3: { value: 1 },
   B4: { value: 2 },

package/src/testing/testing.tsx

@@ -6,19 +6,20 @@ import { type Decorator } from '@storybook/react';
 import React, { useState } from 'react';
 
 import { type ComputeGraph, type ComputeGraphOptions, ComputeGraphRegistry } from '@dxos/compute';
+import { createMockedComputeRuntimeProvider } from '@dxos/compute/testing';
 import { type Space } from '@dxos/react-client/echo';
 import { useAsyncState } from '@dxos/react-hooks';
 
 import { ComputeGraphContextProvider } from '../components';
-import { createSheet, type CreateSheetOptions } from '../types';
+import { Sheet } from '../types';
 
-export const useTestSheet = (space?: Space, graph?: ComputeGraph, options?: CreateSheetOptions) => {
+export const useTestSheet = (space?: Space, graph?: ComputeGraph, options?: Sheet.SheetProps) => {
   const [sheet] = useAsyncState(async () => {
     if (!space || !graph) {
       return;
     }
 
-    const sheet = createSheet(options);
+    const sheet = Sheet.make(options);
     space.db.add(sheet);
     return sheet;
   }, [space, graph]);
@@ -26,9 +27,14 @@ export const useTestSheet = (space?: Space, graph?: ComputeGraph, options?: Crea
 };
 
 export const withComputeGraphDecorator =
-  (options?: ComputeGraphOptions): Decorator =>
+  (options?: Partial<ComputeGraphOptions>): Decorator =>
   (Story) => {
-    const [registry] = useState(new ComputeGraphRegistry(options));
+    const [registry] = useState(
+      new ComputeGraphRegistry({
+        ...options,
+        computeRuntime: options?.computeRuntime ?? createMockedComputeRuntimeProvider(),
+      }),
+    );
     return (
       <ComputeGraphContextProvider registry={registry}>
         <Story />

package/src/translations.ts

@@ -5,12 +5,12 @@
 import { type Resource } from '@dxos/react-ui';
 
 import { meta } from './meta';
-import { SheetType } from './types';
+import { Sheet } from './types';
 
 export const translations = [
   {
     'en-US': {
-      [SheetType.typename]: {
+      [Sheet.Sheet.typename]: {
         'typename label': 'Sheet',
         'typename label_zero': 'Sheets',
         'typename label_one': 'Sheet',
@@ -18,6 +18,7 @@ export const translations = [
         'object name placeholder': 'New sheet',
         'rename object label': 'Rename sheet',
         'delete object label': 'Delete sheet',
+        'object deleted label': 'Sheet deleted',
       },
       [meta.id]: {
         'plugin name': 'Sheets',

package/src/types/Sheet.ts

@@ -0,0 +1,97 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { addressFromA1Notation, isFormula } from '@dxos/compute';
+import { Obj, Type } from '@dxos/echo';
+import { FormInputAnnotation } from '@dxos/echo/internal';
+
+import { addressToIndex, initialize, mapFormulaRefsToIndices } from './util';
+
+export type SheetSize = {
+  rows: number;
+  columns: number;
+};
+
+export const CellValue = Schema.Struct({
+  // TODO(burdon): How to store dates (datetime, date, time), percentages, etc.
+  //  Consider import/export; natural access for other plugins. Special handling for currency (precision).
+  // TODO(burdon): Automerge (long string) or short string or number.
+  value: Schema.Any,
+});
+
+export type CellValue = Schema.Schema.Type<typeof CellValue>;
+
+// TODO(burdon): IMPORTANT: Reconcile with Field definition.
+export const Range = Schema.Struct({
+  range: Schema.String,
+  key: Schema.String,
+  value: Schema.String,
+});
+
+export type Range = Schema.Schema.Type<typeof Range>;
+
+// TODO(burdon): Visibility, locked, frozen, etc.
+export const RowColumnMeta = Schema.Struct({
+  size: Schema.optional(Schema.Number),
+});
+
+// TODO(burdon): Reconcile col/column (across packages).
+// TODO(burdon): Index to all updates when rows/columns are inserted/deleted.
+export const Sheet = Schema.Struct({
+  name: Schema.optional(Schema.String),
+
+  // Sparse map of cells referenced by index.
+  cells: Schema.Record({ key: Schema.String, value: CellValue }).pipe(FormInputAnnotation.set(false)),
+
+  // Ordered row indices.
+  rows: Schema.Array(Schema.String).pipe(FormInputAnnotation.set(false)),
+
+  // Ordered column indices.
+  columns: Schema.Array(Schema.String).pipe(FormInputAnnotation.set(false)),
+
+  // Row metadata referenced by index.
+  rowMeta: Schema.Record({ key: Schema.String, value: RowColumnMeta }).pipe(FormInputAnnotation.set(false)),
+
+  // Column metadata referenced by index.
+  columnMeta: Schema.Record({ key: Schema.String, value: RowColumnMeta }).pipe(FormInputAnnotation.set(false)),
+
+  // Cell formatting referenced by indexed range.
+  ranges: Schema.Array(Range).pipe(FormInputAnnotation.set(false)),
+}).pipe(
+  Type.object({
+    typename: 'dxos.org/type/Sheet',
+    version: '0.1.0',
+  }),
+);
+
+export interface Sheet extends Schema.Schema.Type<typeof Sheet> {}
+
+export type SheetProps = {
+  name?: string;
+  cells?: Record<string, CellValue>;
+} & Partial<SheetSize>;
+
+export const make = ({ name, cells = {}, ...size }: SheetProps = {}) => {
+  const sheet = Obj.make(Sheet, { name, cells: {}, rows: [], columns: [], rowMeta: {}, columnMeta: {}, ranges: [] });
+
+  // Initialize and set cells within Obj.change to satisfy change context requirements.
+  Obj.change(sheet, (s) => {
+    initialize(s, size);
+
+    if (cells) {
+      Object.entries(cells).forEach(([key, { value }]) => {
+        const idx = addressToIndex(s, addressFromA1Notation(key));
+        if (isFormula(value)) {
+          value = mapFormulaRefsToIndices(s, value);
+        }
+
+        s.cells[idx] = { value };
+      });
+    }
+  });
+
+  return sheet;
+};

package/src/types/capabilities.ts

@@ -0,0 +1,14 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+import { type ComputeGraphRegistry } from '@dxos/compute';
+
+import { meta } from '../meta';
+
+export namespace SheetCapabilities {
+  export const ComputeGraphRegistry = Capability.make<ComputeGraphRegistry>(
+    `${meta.id}/capability/compute-graph-registry`,
+  );
+}

package/src/types/index.ts

@@ -2,7 +2,8 @@
 // Copyright 2024 DXOS.org
 //
 
-export * from './schema';
+export * from './capabilities';
+export * as Sheet from './Sheet';
 export * from './sheet-range-types';
 export * from './types';
 export * from './util';

package/src/types/sheet-range-types.ts

@@ -4,7 +4,7 @@
 
 import { type ClassNameValue } from '@dxos/react-ui';
 
-import { type SheetType } from '../types';
+import { type Sheet } from '../types';
 
 export const alignKey = 'alignment';
 export type AlignKey = typeof alignKey;
@@ -19,7 +19,7 @@ export type StyleKey = typeof styleKey;
 export type StyleValue = 'highlight' | 'softwrap';
 
 // TODO(burdon): Reconcile with plugin-table.
-export const cellClassNameForRange = ({ key, value }: SheetType['ranges'][number]): ClassNameValue => {
+export const cellClassNameForRange = ({ key, value }: Sheet.Sheet['ranges'][number]): ClassNameValue => {
   switch (key) {
     case alignKey:
       switch (value) {