@dxos/plugin-sheet 0.8.4-main.406dc2a → 0.8.4-main.548089c

package/src/components/SheetToolbar/SheetToolbar.tsx

@@ -2,12 +2,11 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Rx } from '@effect-rx/rx-react';
+import { Atom } from '@effect-atom/atom-react';
 import React, { type PropsWithChildren, useMemo } from 'react';
 
-import { useAppGraph } from '@dxos/app-framework';
+import { useAppGraph } from '@dxos/app-framework/react';
 import { type CompleteCellRange } from '@dxos/compute';
-import { type ThemedClassName } from '@dxos/react-ui';
 import {
   type ActionGraphProps,
   MenuProvider,
@@ -24,19 +23,13 @@ import { createAlign, useAlignState } from './align';
 import { createStyle, useStyleState } from './style';
 import { type ToolbarState, useToolbarState } from './useToolbarState';
 
-//
-// Root
-//
-
-export type SheetToolbarProps = ThemedClassName<PropsWithChildren<{ id: string }>>;
-
 const createToolbarActions = (
   model: SheetModel,
   state: ToolbarState,
   cursorFallbackRange?: CompleteCellRange,
-  customActions?: Rx.Rx<ActionGraphProps>,
-): Rx.Rx<ActionGraphProps> => {
-  return Rx.make((get) => {
+  customActions?: Atom.Atom<ActionGraphProps>,
+): Atom.Atom<ActionGraphProps> => {
+  return Atom.make((get) => {
     const align = get(rxFromSignal(() => createAlign(model, state, cursorFallbackRange)));
     const style = get(rxFromSignal(() => createStyle(model, state, cursorFallbackRange)));
     const gap = createGapSeparator();
@@ -56,7 +49,9 @@ const createToolbarActions = (
   });
 };
 
-export const SheetToolbar = ({ id, classNames }: SheetToolbarProps) => {
+export type SheetToolbarProps = PropsWithChildren<{ id: string }>;
+
+export const SheetToolbar = ({ id }: SheetToolbarProps) => {
   const { model, cursorFallbackRange } = useSheetContext();
   const state = useToolbarState({});
   useAlignState(state);
@@ -64,10 +59,13 @@ export const SheetToolbar = ({ id, classNames }: SheetToolbarProps) => {
 
   const { graph } = useAppGraph();
   const customActions = useMemo(() => {
-    return Rx.make((get) => {
+    return Atom.make((get) => {
       const actions = get(graph.actions(id));
       const nodes = actions.filter((action) => action.properties.disposition === 'toolbar');
-      return { nodes, edges: nodes.map((node) => ({ source: 'root', target: node.id })) };
+      return {
+        nodes,
+        edges: nodes.map((node) => ({ source: 'root', target: node.id })),
+      };
     });
   }, [graph]);
 
@@ -79,7 +77,7 @@ export const SheetToolbar = ({ id, classNames }: SheetToolbarProps) => {
 
   return (
     <MenuProvider {...menu} attendableId={id}>
-      <ToolbarMenu classNames={classNames} />
+      <ToolbarMenu />
     </MenuProvider>
   );
 };

package/src/extensions/compute.stories.tsx

@@ -25,7 +25,7 @@ import { isNonNullable } from '@dxos/util';
 import { GridSheet, SheetProvider, useComputeGraph } from '../components';
 import { useSheetModel } from '../model';
 import { useTestSheet, withComputeGraphDecorator } from '../testing';
-import { SheetType } from '../types';
+import { Sheet } from '../types';
 
 import { compute, computeGraphFacet } from './compute';
 
@@ -103,7 +103,7 @@ const meta = {
   title: 'plugins/plugin-sheet/extensions',
   decorators: [
     withTheme,
-    withClientProvider({ types: [SheetType], createIdentity: true, createSpace: true }),
+    withClientProvider({ types: [Sheet.Sheet], createIdentity: true, createSpace: true }),
     // TODO(wittjosiah): Try to write story which does not depend on plugin manager.
     withPluginManager({ plugins: [IntentPlugin()] }),
     withComputeGraphDecorator(),

package/src/integrations/thread-ranges.ts

@@ -6,22 +6,16 @@ import * as Function from 'effect/Function';
 import * as Schema from 'effect/Schema';
 import { useCallback, useEffect, useMemo } from 'react';
 
-import {
-  LayoutAction,
-  chain,
-  createIntent,
-  createResolver,
-  useIntentDispatcher,
-  useIntentResolver,
-} from '@dxos/app-framework';
+import { LayoutAction, chain, createIntent, createResolver } from '@dxos/app-framework';
+import { useIntentDispatcher, useIntentResolver } from '@dxos/app-framework/react';
 import { debounce } from '@dxos/async';
 import { type CellAddress, type CompleteCellRange, inRange } from '@dxos/compute';
 import { Obj, Relation } from '@dxos/echo';
 import { ATTENDABLE_PATH_SEPARATOR, DeckAction } from '@dxos/plugin-deck/types';
-import { ThreadAction, ThreadType } from '@dxos/plugin-thread/types';
-import { Filter, Query, fullyQualifiedId, getSpace, useQuery } from '@dxos/react-client/echo';
+import { Thread, ThreadAction } from '@dxos/plugin-thread/types';
+import { Filter, Query, getSpace, useQuery } from '@dxos/react-client/echo';
 import { type DxGridElement, type GridContentProps } from '@dxos/react-ui-grid';
-import { AnchoredTo } from '@dxos/schema';
+import { AnchoredTo } from '@dxos/types';
 
 import { useSheetContext } from '../components';
 import { meta } from '../meta';
@@ -61,7 +55,7 @@ export const useUpdateFocusedCellOnThreadSelection = (grid: DxGridElement | null
             return false;
           }
 
-          return data.subject === fullyQualifiedId(model.sheet) && !!data.options?.cursor;
+          return data.subject === Obj.getDXN(model.sheet).toString() && !!data.options?.cursor;
         },
         resolve: ({ options: { cursor, ref } }) => {
           setActiveRefs(ref);
@@ -81,7 +75,7 @@ export const useSelectThreadOnCellFocus = () => {
   const { dispatchPromise: dispatch } = useIntentDispatcher();
 
   const space = getSpace(model.sheet);
-  const anchors = useQuery(space, Query.select(Filter.ids(model.sheet.id)).targetOf(AnchoredTo));
+  const anchors = useQuery(space, Query.select(Filter.ids(model.sheet.id)).targetOf(AnchoredTo.AnchoredTo));
 
   const selectClosestThread = useCallback(
     (cellAddress: CellAddress) => {
@@ -91,7 +85,7 @@ export const useSelectThreadOnCellFocus = () => {
 
       const closestThread = anchors.find((anchor) => {
         const source = Relation.getSource(anchor);
-        if (anchor.anchor && Obj.instanceOf(ThreadType, source)) {
+        if (anchor.anchor && Obj.instanceOf(Thread.Thread, source)) {
           const range = parseThreadAnchorAsCellRange(anchor.anchor);
           return range ? inRange(range, cellAddress) : false;
         } else {
@@ -100,9 +94,9 @@ export const useSelectThreadOnCellFocus = () => {
       });
 
       if (closestThread) {
-        const primary = fullyQualifiedId(model.sheet);
+        const primary = Obj.getDXN(model.sheet).toString();
         const intent = Function.pipe(
-          createIntent(ThreadAction.Select, { current: fullyQualifiedId(closestThread) }),
+          createIntent(ThreadAction.Select, { current: Obj.getDXN(closestThread).toString() }),
           chain(DeckAction.ChangeCompanion, { primary, companion: `${primary}${ATTENDABLE_PATH_SEPARATOR}comments` }),
         );
         void dispatch(intent);

package/src/meta.ts

@@ -3,13 +3,17 @@
 //
 
 import { type PluginMeta } from '@dxos/app-framework';
+import { trim } from '@dxos/util';
 
 export const meta: PluginMeta = {
   id: 'dxos.org/plugin/sheet',
   name: 'Sheet',
-  description:
-    'Sheets in Composer are simple spreadsheets which allow you to leverage custom functions inside of cell grids. Leverage more than 400 pre-built formulas like Sum, Average, Count, Max, Min along with many others. You can also deploy your own custom functions using the Scripts plugin. ',
+  description: trim`
+    Full-featured spreadsheet application with over 400 built-in formulas for calculations and data analysis.
+    Create custom JavaScript functions and integrate with AI agents for advanced automation.
+  `,
   icon: 'ph--grid-nine--regular',
+  iconHue: 'indigo',
   source: 'https://github.com/dxos/dxos/tree/main/packages/plugins/plugin-sheet',
   screenshots: ['https://dxos.network/plugin-details-sheet-dark.png'],
 };

package/src/model/sheet-model.test.ts

@@ -7,10 +7,10 @@ import { afterEach, beforeEach, describe, expect, onTestFinished, test } from 'v
 import { Trigger } from '@dxos/async';
 import { type CellScalarValue, addressFromA1Notation, isFormula } from '@dxos/compute';
 import { TestBuilder, testFunctionPlugins } from '@dxos/compute/testing';
-import { FunctionType } from '@dxos/functions';
+import { Function } from '@dxos/functions';
 import { log } from '@dxos/log';
 
-import { createSheet, mapFormulaIndicesToRefs, mapFormulaRefsToIndices } from '../types';
+import { Sheet, mapFormulaIndicesToRefs, mapFormulaRefsToIndices } from '../types';
 
 import { SheetModel } from './sheet-model';
 import { createTestGrid } from './testing';
@@ -18,7 +18,7 @@ import { createTestGrid } from './testing';
 describe('SheetModel', () => {
   let testBuilder: TestBuilder;
   beforeEach(async () => {
-    testBuilder = new TestBuilder({ types: [FunctionType], plugins: testFunctionPlugins });
+    testBuilder = new TestBuilder({ types: [Function.Function], plugins: testFunctionPlugins });
     await testBuilder.open();
   });
   afterEach(async () => {
@@ -31,7 +31,7 @@ describe('SheetModel', () => {
     await graph.open();
 
     // TODO(burdon): Create via factory.
-    const sheet = createSheet({ rows: 5, columns: 5 });
+    const sheet = Sheet.make({ rows: 5, columns: 5 });
     const model = new SheetModel(graph, sheet);
     await model.open();
     testBuilder.ctx.onDispose(() => model.close());

package/src/model/sheet-model.ts

@@ -39,7 +39,7 @@ import {
   mapFormulaIndicesToRefs,
   mapFormulaRefsToIndices,
 } from '../types';
-import { type CellValue, type SheetAction, type SheetType } from '../types';
+import { type Sheet, type SheetAction } from '../types';
 
 // TODO(burdon): Move to compute.
 // Map sheet types to system types.
@@ -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();
@@ -414,7 +414,7 @@ export class SheetModel extends Resource {
   /**
    * 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/sanity.test.ts

@@ -5,8 +5,7 @@
 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]);
+    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

@@ -6,16 +6,16 @@ import { Obj } from '@dxos/echo';
 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

@@ -11,15 +11,15 @@ import { type Space } from '@dxos/react-client/echo';
 import { useAsyncState } from '@dxos/react-hooks';
 
 import { ComputeGraphContextProvider } from '../components';
-import { type CreateSheetOptions, createSheet } 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]);

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',

package/src/types/Sheet.ts

@@ -0,0 +1,103 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { addressFromA1Notation, isFormula } from '@dxos/compute';
+import { Obj, Type } from '@dxos/echo';
+import { FormAnnotation } 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: Schema.mutable(CellValue) }).pipe(
+    Schema.mutable,
+    FormAnnotation.set(false),
+  ),
+
+  // Ordered row indices.
+  rows: Schema.Array(Schema.String).pipe(Schema.mutable, FormAnnotation.set(false)),
+
+  // Ordered column indices.
+  columns: Schema.Array(Schema.String).pipe(Schema.mutable, FormAnnotation.set(false)),
+
+  // Row metadata referenced by index.
+  rowMeta: Schema.Record({ key: Schema.String, value: Schema.mutable(RowColumnMeta) }).pipe(
+    Schema.mutable,
+    FormAnnotation.set(false),
+  ),
+
+  // Column metadata referenced by index.
+  columnMeta: Schema.Record({ key: Schema.String, value: Schema.mutable(RowColumnMeta) }).pipe(
+    Schema.mutable,
+    FormAnnotation.set(false),
+  ),
+
+  // Cell formatting referenced by indexed range.
+  ranges: Schema.Array(Range).pipe(Schema.mutable, FormAnnotation.set(false)),
+}).pipe(
+  Type.Obj({
+    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(sheet, size);
+
+  if (cells) {
+    Object.entries(cells).forEach(([key, { value }]) => {
+      const idx = addressToIndex(sheet, addressFromA1Notation(key));
+      if (isFormula(value)) {
+        value = mapFormulaRefsToIndices(sheet, value);
+      }
+
+      sheet.cells[idx] = { value };
+    });
+  }
+
+  return sheet;
+};

package/src/types/index.ts

@@ -2,7 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
-export * from './schema';
+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) {

package/src/types/types.ts

@@ -7,17 +7,7 @@ import * as Schema from 'effect/Schema';
 import { meta } from '../meta';
 import { SheetModel } from '../model';
 
-import { type CellValue, RowColumnMeta, SheetType } from './schema';
-
-export type SheetSize = {
-  rows: number;
-  columns: number;
-};
-
-export type CreateSheetOptions = {
-  name?: string;
-  cells?: Record<string, CellValue>;
-} & Partial<SheetSize>;
+import * as Sheet from './Sheet';
 
 export namespace SheetAction {
   const SHEET_ACTION = `${meta.id}/action`;
@@ -27,7 +17,7 @@ export namespace SheetAction {
       name: Schema.optional(Schema.String),
     }),
     output: Schema.Struct({
-      object: SheetType,
+      object: Sheet.Sheet,
     }),
   }) {}
 
@@ -49,7 +39,7 @@ export namespace SheetAction {
     axis: Axis,
     axisIndex: Schema.String,
     index: Schema.Number,
-    axisMeta: RowColumnMeta,
+    axisMeta: Sheet.RowColumnMeta,
     values: Schema.Array(Schema.Any),
   });
 

package/src/types/util.ts

@@ -11,10 +11,9 @@ import {
   isFormula,
 } from '@dxos/compute';
 import { randomBytes } from '@dxos/crypto';
-import { Obj } from '@dxos/echo';
 import { invariant } from '@dxos/invariant';
 
-import { type CreateSheetOptions, type SheetSize, SheetType } from '../types';
+import { type Sheet } from '../types';
 
 export const MAX_ROWS = 500;
 export const MAX_COLS = 676; // 26^2;
@@ -56,8 +55,8 @@ export const insertIndices = (indices: string[], i: number, n: number, max: numb
 };
 
 export const initialize = (
-  sheet: SheetType,
-  { rows = DEFAULT_ROWS, columns = DEFAULT_COLS }: Partial<SheetSize> = {},
+  sheet: Sheet.Sheet,
+  { rows = DEFAULT_ROWS, columns = DEFAULT_COLS }: Partial<Sheet.SheetSize> = {},
 ) => {
   if (!sheet.rows.length) {
     insertIndices(sheet.rows, 0, rows, MAX_ROWS);
@@ -67,44 +66,17 @@ export const initialize = (
   }
 };
 
-export const createSheet = ({ name, cells, ...size }: CreateSheetOptions = {}): SheetType => {
-  const sheet = Obj.make(SheetType, {
-    name,
-    cells: {},
-    rows: [],
-    columns: [],
-    rowMeta: {},
-    columnMeta: {},
-    ranges: [],
-  });
-
-  initialize(sheet, size);
-
-  if (cells) {
-    Object.entries(cells).forEach(([key, { value }]) => {
-      const idx = addressToIndex(sheet, addressFromA1Notation(key));
-      if (isFormula(value)) {
-        value = mapFormulaRefsToIndices(sheet, value);
-      }
-
-      sheet.cells[idx] = { value };
-    });
-  }
-
-  return sheet;
-};
-
 /**
  * E.g., "A1" => "CA2@CB3".
  */
-export const addressToIndex = (sheet: SheetType, cell: CellAddress): string => {
+export const addressToIndex = (sheet: Sheet.Sheet, cell: CellAddress): string => {
   return `${sheet.columns[cell.col]}@${sheet.rows[cell.row]}`;
 };
 
 /**
  * E.g., "CA2@CB3" => "A1".
  */
-export const addressFromIndex = (sheet: SheetType, idx: string): CellAddress => {
+export const addressFromIndex = (sheet: Sheet.Sheet, idx: string): CellAddress => {
   const [column, row] = idx.split('@');
   return {
     col: sheet.columns.indexOf(column),
@@ -115,14 +87,14 @@ export const addressFromIndex = (sheet: SheetType, idx: string): CellAddress =>
 /**
  * E.g., "A1:B2" => "CA2@CB3:CC4@CD5".
  */
-export const rangeToIndex = (sheet: SheetType, range: CellRange): string => {
+export const rangeToIndex = (sheet: Sheet.Sheet, range: CellRange): string => {
   return [range.from, range.to ?? range.from].map((cell) => addressToIndex(sheet, cell)).join(':');
 };
 
 /**
  * E.g., "CA2@CB3:CC4@CD5" => "A1:B2".
  */
-export const rangeFromIndex = (sheet: SheetType, idx: string): CompleteCellRange => {
+export const rangeFromIndex = (sheet: Sheet.Sheet, idx: string): CompleteCellRange => {
   const [from, to] = idx.split(':').map((index) => addressFromIndex(sheet, index));
   return { from, to };
 };
@@ -131,7 +103,7 @@ export const rangeFromIndex = (sheet: SheetType, idx: string): CompleteCellRange
  * Compares the positions of two cell indexes in a sheet.
  * Sorts primarily by row, then by column if rows are equal.
  */
-export const compareIndexPositions = (sheet: SheetType, indexA: string, indexB: string): number => {
+export const compareIndexPositions = (sheet: Sheet.Sheet, indexA: string, indexB: string): number => {
   const { row: rowA, col: columnA } = addressFromIndex(sheet, indexA);
   const { row: rowB, col: columnB } = addressFromIndex(sheet, indexB);
 
@@ -148,7 +120,7 @@ export const compareIndexPositions = (sheet: SheetType, indexA: string, indexB:
 /**
  * Map from A1 notation to indices.
  */
-export const mapFormulaRefsToIndices = (sheet: SheetType, formula: string): string => {
+export const mapFormulaRefsToIndices = (sheet: Sheet.Sheet, formula: string): string => {
   invariant(isFormula(formula));
   return formula.replace(/([a-zA-Z]+)([0-9]+)/g, (match) => {
     return addressToIndex(sheet, addressFromA1Notation(match));
@@ -158,7 +130,7 @@ export const mapFormulaRefsToIndices = (sheet: SheetType, formula: string): stri
 /**
  * Map from indices to A1 notation.
  */
-export const mapFormulaIndicesToRefs = (sheet: SheetType, formula: string): string => {
+export const mapFormulaIndicesToRefs = (sheet: Sheet.Sheet, formula: string): string => {
   invariant(isFormula(formula));
   return formula.replace(/([a-zA-Z0-9]+)@([a-zA-Z0-9]+)/g, (idx) => {
     return addressToA1Notation(addressFromIndex(sheet, idx));