@dxos/plugin-sheet 0.6.12-main.5cc132e → 0.6.12-main.7907542

package/src/model/{model.ts → sheet-model.ts}

@@ -2,40 +2,30 @@
 // Copyright 2024 DXOS.org
 //
 
-import { DetailedCellError, ExportedCellChange } from 'hyperformula';
 import { type SimpleCellRange } from 'hyperformula/typings/AbsoluteCellRange';
 import { type SimpleCellAddress } from 'hyperformula/typings/Cell';
 import { type SimpleDate, type SimpleDateTime } from 'hyperformula/typings/DateTimeHelper';
 
 import { Event } from '@dxos/async';
-import { type Space } from '@dxos/client/echo';
-import { Context } from '@dxos/context';
+import { Resource } from '@dxos/context';
+import { getTypename } from '@dxos/echo-schema';
 import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
-import { type FunctionType } from '@dxos/plugin-script/types';
 
-import { defaultFunctions, type FunctionDefinition } from './functions';
-import { addressFromA1Notation, addressToA1Notation, type CellAddress, type CellRange } from './types';
-import { addressFromIndex, addressToIndex, createIndices, RangeException, ReadonlyException } from './util';
-import { type ComputeGraph } from '../components';
+import { DetailedCellError, ExportedCellChange } from '#hyperformula';
+import {
+  addressFromA1Notation,
+  addressToA1Notation,
+  type CellAddress,
+  type CellRange,
+  MAX_COLUMNS,
+  MAX_ROWS,
+} from '../defs';
+import { addressFromIndex, addressToIndex, initialize, insertIndices, ReadonlyException } from '../defs';
+import { type ComputeNode, type ComputeGraph, createSheetName, type ComputeNodeEvent } from '../graph';
 import { type CellScalarValue, type CellValue, type SheetType, ValueTypeEnum } from '../types';
 
-const DEFAULT_ROWS = 100;
-const DEFAULT_COLUMNS = 26;
-
-export type CellIndex = string;
-
-export type CellContentValue = number | string | boolean | null;
-
-export type SheetModelOptions = {
-  readonly?: boolean;
-  rows: number;
-  columns: number;
-  mapFormulaBindingToId: (functions: FunctionType[]) => (formula: string) => string;
-  mapFormulaBindingFromId: (functions: FunctionType[]) => (formula: string) => string;
-};
-
 const typeMap: Record<string, ValueTypeEnum> = {
   BOOLEAN: ValueTypeEnum.Boolean,
   NUMBER_RAW: ValueTypeEnum.Number,
@@ -46,22 +36,15 @@ const typeMap: Record<string, ValueTypeEnum> = {
   NUMBER_TIME: ValueTypeEnum.Time,
 };
 
-export const defaultOptions: SheetModelOptions = {
-  rows: 50,
-  columns: 26,
-  mapFormulaBindingFromId: () => (formula) => formula,
-  mapFormulaBindingToId: () => (formula) => formula,
-};
-
-const getTopLeft = (range: CellRange) => {
+const getTopLeft = (range: CellRange): CellAddress => {
   const to = range.to ?? range.from;
-  return { row: Math.min(range.from.row, to.row), column: Math.min(range.from.column, to.column) };
+  return { row: Math.min(range.from.row, to.row), col: Math.min(range.from.col, to.col) };
 };
 
 const toSimpleCellAddress = (sheet: number, cell: CellAddress): SimpleCellAddress => ({
   sheet,
   row: cell.row,
-  col: cell.column,
+  col: cell.col,
 });
 
 const toModelRange = (sheet: number, range: CellRange): SimpleCellRange => ({
@@ -69,39 +52,30 @@ const toModelRange = (sheet: number, range: CellRange): SimpleCellRange => ({
   end: toSimpleCellAddress(sheet, range.to ?? range.from),
 });
 
+export type SheetModelOptions = {
+  readonly?: boolean;
+};
+
 /**
  * Spreadsheet data model.
  *
  * [ComputeGraphContext] > [SheetContext]:[SheetModel] > [Sheet.Root]
  */
-export class SheetModel {
+// TODO(burdon): Factor out commonality with ComputeNode. Factor out HF.
+export class SheetModel extends Resource {
   public readonly id = `model-${PublicKey.random().truncate()}`;
-  private _ctx?: Context = undefined;
 
-  /**
-   * Formula engine.
-   * Acts as a write through cache for scalar and computed values.
-   */
-  private readonly _sheetId: number;
-  private readonly _options: SheetModelOptions;
-  private _functions: FunctionType[] = [];
+  // Wraps compute node.
+  public readonly update = new Event<ComputeNodeEvent>();
 
-  public readonly update = new Event();
+  private _node?: ComputeNode;
 
   constructor(
     private readonly _graph: ComputeGraph,
     private readonly _sheet: SheetType,
-    private readonly _space?: Space,
-    options: Partial<SheetModelOptions> = {},
+    private readonly _options: SheetModelOptions = {},
   ) {
-    // Sheet for this object.
-    const name = this._sheet.id;
-    if (!this._graph.hf.doesSheetExist(name)) {
-      this._graph.hf.addSheet(name);
-    }
-    this._sheetId = this._graph.hf.getSheetId(name)!;
-    this._options = { ...defaultOptions, ...options };
-    this.reset();
+    super();
   }
 
   get graph() {
@@ -123,59 +97,22 @@ export class SheetModel {
     };
   }
 
-  get functions(): FunctionDefinition[] {
-    const hfFunctions = this._graph.hf
-      .getRegisteredFunctionNames()
-      .map((name) => defaultFunctions.find((fn) => fn.name === name) ?? { name });
-    const echoFunctions = this._functions.map((fn) => ({ name: fn.binding! }));
-    return [...hfFunctions, ...echoFunctions];
-  }
-
-  get initialized(): boolean {
-    return !!this._ctx;
-  }
-
   /**
    * Initialize sheet and engine.
    */
-  async initialize() {
+  protected override async _open() {
     log('initialize', { id: this.id });
-    invariant(!this.initialized, 'Already initialized.');
-    this._ctx = new Context();
-    if (!this._sheet.rows.length) {
-      this._insertIndices(this._sheet.rows, 0, this._options.rows, DEFAULT_ROWS);
-    }
-    if (!this._sheet.columns.length) {
-      this._insertIndices(this._sheet.columns, 0, this._options.columns, DEFAULT_COLUMNS);
-    }
-    this.reset();
+    initialize(this._sheet);
+
+    // TODO(burdon): SheetModel should extend ComputeNode and be constructed via the graph.
+    this._node = this._graph.getOrCreateNode(createSheetName({ type: getTypename(this._sheet)!, id: this._sheet.id }));
+    await this._node.open();
 
     // Listen for model updates (e.g., async calculations).
-    const unsubscribe = this._graph.update.on(() => this.update.emit());
+    const unsubscribe = this._node.update.on((event) => this.update.emit(event));
     this._ctx.onDispose(unsubscribe);
 
-    if (this._space) {
-      const { Filter } = await import('@dxos/client/echo');
-      const { FunctionType } = await import('@dxos/plugin-script/types');
-
-      // Listen for function changes.
-      const query = this._space?.db.query(Filter.schema(FunctionType));
-      const unsubscribe = query.subscribe(({ objects }) => {
-        this._functions = objects.filter((fn) => fn.binding);
-        this.update.emit();
-      });
-      this._ctx.onDispose(unsubscribe);
-    }
-
-    return this;
-  }
-
-  async destroy() {
-    log('destroy', { id: this.id });
-    if (this._ctx) {
-      await this._ctx.dispose();
-      this._ctx = undefined;
-    }
+    this.reset();
   }
 
   /**
@@ -184,14 +121,18 @@ export class SheetModel {
    * @deprecated
    */
   reset() {
-    this._graph.hf.clearSheet(this._sheetId);
+    invariant(this._node);
+    this._node.graph.hf.clearSheet(this._node.sheetId);
     Object.entries(this._sheet.cells).forEach(([key, { value }]) => {
-      const { column, row } = addressFromIndex(this._sheet, key);
+      invariant(this._node);
+      const { col, row } = addressFromIndex(this._sheet, key);
       if (typeof value === 'string' && value.charAt(0) === '=') {
-        value = this.mapFormulaBindingToFormula(this.mapFormulaBindingFromId(this.mapFormulaIndicesToRefs(value)));
+        value = this._graph.mapFormulaToNative(
+          this._graph.mapFunctionBindingFromId(this.mapFormulaIndicesToRefs(value)),
+        );
       }
 
-      this._graph.hf.setCellContents({ sheet: this._sheetId, row, col: column }, value);
+      this._node.graph.hf.setCellContents({ sheet: this._node.sheetId, row, col }, value);
     });
   }
 
@@ -203,16 +144,16 @@ export class SheetModel {
    */
   // TODO(burdon): Remove.
   recalculate() {
-    this._graph.hf.rebuildAndRecalculate();
+    this._node?.graph.hf.rebuildAndRecalculate();
   }
 
   insertRows(i: number, n = 1) {
-    this._insertIndices(this._sheet.rows, i, n, DEFAULT_ROWS);
+    insertIndices(this._sheet.rows, i, n, MAX_ROWS);
     this.reset();
   }
 
   insertColumns(i: number, n = 1) {
-    this._insertIndices(this._sheet.columns, i, n, DEFAULT_COLUMNS);
+    insertIndices(this._sheet.columns, i, n, MAX_COLUMNS);
     this.reset();
   }
 
@@ -220,13 +161,15 @@ export class SheetModel {
   // Undoable actions.
   // TODO(burdon): Group undoable methods; consistently update hf/sheet.
   //
+
   /**
    * Clear range of values.
    */
   clear(range: CellRange) {
+    invariant(this._node);
     const topLeft = getTopLeft(range);
     const values = this._iterRange(range, () => null);
-    this._graph.hf.setCellContents(toSimpleCellAddress(this._sheetId, topLeft), values);
+    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];
@@ -234,7 +177,8 @@ export class SheetModel {
   }
 
   cut(range: CellRange) {
-    this._graph.hf.cut(toModelRange(this._sheetId, range));
+    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];
@@ -242,16 +186,18 @@ export class SheetModel {
   }
 
   copy(range: CellRange) {
-    this._graph.hf.copy(toModelRange(this._sheetId, range));
+    invariant(this._node);
+    this._node.graph.hf.copy(toModelRange(this._node.sheetId, range));
   }
 
   paste(cell: CellAddress) {
-    if (!this._graph.hf.isClipboardEmpty()) {
-      const changes = this._graph.hf.paste(toSimpleCellAddress(this._sheetId, cell));
+    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, column: address.col });
+          const idx = addressToIndex(this._sheet, { row: address.row, col: address.col });
           this._sheet.cells[idx] = { value: newValue };
         }
       }
@@ -260,16 +206,18 @@ export class SheetModel {
 
   // TODO(burdon): Display undo/redo state.
   undo() {
-    if (this._graph.hf.isThereSomethingToUndo()) {
-      this._graph.hf.undo();
-      this.update.emit();
+    invariant(this._node);
+    if (this._node.graph.hf.isThereSomethingToUndo()) {
+      this._node.graph.hf.undo();
+      // this.update.emit();
     }
   }
 
   redo() {
-    if (this._graph.hf.isThereSomethingToRedo()) {
-      this._graph.hf.redo();
-      this.update.emit();
+    invariant(this._node);
+    if (this._node.graph.hf.isThereSomethingToRedo()) {
+      this._node.graph.hf.redo();
+      // this.update.emit();
     }
   }
 
@@ -291,7 +239,7 @@ export class SheetModel {
     }
 
     if (typeof value === 'string' && value.charAt(0) === '=') {
-      return this.mapFormulaBindingFromId(this.mapFormulaIndicesToRefs(value));
+      return this._graph.mapFunctionBindingFromId(this.mapFormulaIndicesToRefs(value));
     } else {
       return String(value);
     }
@@ -309,7 +257,8 @@ export class SheetModel {
    */
   getValue(cell: CellAddress): CellScalarValue {
     // Applies rounding and post-processing.
-    const value = this._graph.hf.getCellValue(toSimpleCellAddress(this._sheetId, cell));
+    invariant(this._node);
+    const value = this._node.graph.hf.getCellValue(toSimpleCellAddress(this._node.sheetId, cell));
     if (value instanceof DetailedCellError) {
       return value.toString();
     }
@@ -321,8 +270,9 @@ export class SheetModel {
    * Get value type.
    */
   getValueType(cell: CellAddress): ValueTypeEnum {
-    const addr = toSimpleCellAddress(this._sheetId, cell);
-    const type = this._graph.hf.getCellValueDetailedType(addr);
+    invariant(this._node);
+    const addr = toSimpleCellAddress(this._node.sheetId, cell);
+    const type = this._node.graph.hf.getCellValueDetailedType(addr);
     return typeMap[type];
   }
 
@@ -330,6 +280,7 @@ export class SheetModel {
    * Sets the value, updating the sheet and engine.
    */
   setValue(cell: CellAddress, value: CellScalarValue) {
+    invariant(this._node);
     if (this._options.readonly) {
       throw new ReadonlyException();
     }
@@ -337,21 +288,22 @@ export class SheetModel {
     // Reallocate if > current bounds.
     let refresh = false;
     if (cell.row >= this._sheet.rows.length) {
-      this._insertIndices(this._sheet.rows, cell.row, 1, DEFAULT_ROWS);
+      insertIndices(this._sheet.rows, cell.row, 1, MAX_ROWS);
       refresh = true;
     }
-    if (cell.column >= this._sheet.columns.length) {
-      this._insertIndices(this._sheet.columns, cell.column, 1, DEFAULT_COLUMNS);
+    if (cell.col >= this._sheet.columns.length) {
+      insertIndices(this._sheet.columns, cell.col, 1, MAX_COLUMNS);
       refresh = true;
     }
+
     if (refresh) {
       // TODO(burdon): Remove.
       this.reset();
     }
 
     // Insert into engine.
-    this._graph.hf.setCellContents({ sheet: this._sheetId, row: cell.row, col: cell.column }, [
-      [typeof value === 'string' && value.charAt(0) === '=' ? this.mapFormulaBindingToFormula(value) : value],
+    this._node.graph.hf.setCellContents({ sheet: this._node.sheetId, row: cell.row, col: cell.col }, [
+      [typeof value === 'string' && value.charAt(0) === '=' ? this._graph.mapFormulaToNative(value) : value],
     ]);
 
     // Insert into sheet.
@@ -360,7 +312,7 @@ export class SheetModel {
       delete this._sheet.cells[idx];
     } else {
       if (typeof value === 'string' && value.charAt(0) === '=') {
-        value = this.mapFormulaBindingToId(this.mapFormulaRefsToIndices(value));
+        value = this._graph.mapFunctionBindingToId(this.mapFormulaRefsToIndices(value));
       }
 
       this._sheet.cells[idx] = { value };
@@ -382,35 +334,23 @@ export class SheetModel {
   private _iterRange(range: CellRange, cb: (cell: CellAddress) => CellScalarValue | void): CellScalarValue[][] {
     const to = range.to ?? range.from;
     const rowRange = [Math.min(range.from.row, to.row), Math.max(range.from.row, to.row)];
-    const columnRange = [Math.min(range.from.column, to.column), Math.max(range.from.column, to.column)];
+    const columnRange = [Math.min(range.from.col, to.col), Math.max(range.from.col, to.col)];
     const rows: CellScalarValue[][] = [];
     for (let row = rowRange[0]; row <= rowRange[1]; row++) {
       const rowCells: CellScalarValue[] = [];
       for (let column = columnRange[0]; column <= columnRange[1]; column++) {
-        const value = cb({ row, column });
+        const value = cb({ row, col: column });
         if (value !== undefined) {
           rowCells.push(value);
         }
       }
+
       rows.push(rowCells);
     }
 
     return rows;
   }
 
-  /**
-   *
-   */
-  // TODO(burdon): Insert indices into sheet.
-  private _insertIndices(indices: string[], i: number, n: number, max: number) {
-    if (i + n > max) {
-      throw new RangeException(i + n);
-    }
-
-    const idx = createIndices(n);
-    indices.splice(i, 0, ...idx);
-  }
-
   // TODO(burdon): Delete index.
   private _deleteIndices(indices: string[], i: number, n: number) {
     throw new Error('Not implemented');
@@ -425,49 +365,6 @@ export class SheetModel {
   // Indices.
   //
 
-  /**
-   * E.g., "HELLO()" => "EDGE("HELLO")".
-   */
-  mapFormulaBindingToFormula(formula: string): string {
-    return formula.replace(/([a-zA-Z0-9]+)\((.*)\)/g, (match, binding, args) => {
-      const fn = this._functions.find((fn) => fn.binding === binding);
-      if (!fn) {
-        return match;
-      }
-
-      if (args.trim() === '') {
-        return `EDGE("${binding}")`;
-      }
-      return `EDGE("${binding}", ${args})`;
-    });
-  }
-
-  /**
-   * E.g., "EDGE("HELLO")" => "HELLO()".
-   */
-  mapFormulaBindingFromFormula(formula: string): string {
-    return formula.replace(/EDGE\("([a-zA-Z0-9]+)"(.*)\)/, (_match, binding, args) => {
-      if (args.trim() === '') {
-        return `${binding}()`;
-      }
-      return `${binding}(${args.slice(2)})`;
-    });
-  }
-
-  /**
-   * Map from binding to fully qualified ECHO ID.
-   */
-  mapFormulaBindingToId(formula: string): string {
-    return this._options.mapFormulaBindingToId(this._functions)(formula);
-  }
-
-  /**
-   * Map from fully qualified ECHO ID to binding.
-   */
-  mapFormulaBindingFromId(formula: string): string {
-    return this._options.mapFormulaBindingFromId(this._functions)(formula);
-  }
-
   /**
    * Map from A1 notation to indices.
    */
@@ -503,14 +400,17 @@ export class SheetModel {
   }
 
   toDateTime(num: number): SimpleDateTime {
-    return this._graph.hf.numberToDateTime(num) as SimpleDateTime;
+    invariant(this._node);
+    return this._node.graph.hf.numberToDateTime(num) as SimpleDateTime;
   }
 
   toDate(num: number): SimpleDate {
-    return this._graph.hf.numberToDate(num) as SimpleDate;
+    invariant(this._node);
+    return this._node.graph.hf.numberToDate(num) as SimpleDate;
   }
 
   toTime(num: number): SimpleDate {
-    return this._graph.hf.numberToTime(num) as SimpleDate;
+    invariant(this._node);
+    return this._node.graph.hf.numberToTime(num) as SimpleDate;
   }
 }

package/src/sanity.test.ts

@@ -0,0 +1,40 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { describe, test, expect } from 'vitest';
+
+// Part 2.
+// TODO(burdon): Cannot test outside of browser.
+//  - Cannot test Hyperformula
+//    - throws "Cannot convert undefined or null to object" in vitest (no browser).
+//    - throws "process.nextTick is not a function" (if browser)
+
+import { Client } from '@dxos/client';
+import { create } from '@dxos/client/echo';
+import { FunctionType } from '@dxos/plugin-script/types';
+
+// TODO(burdon): Fix test infrastructure:
+//  - Need docs? esp. needed for config. need pristine example package?
+//    - NOTE for non browser tests, import types from x-plugin/types (otherwise will bring in react deps).
+//  - Can't add flags to our tools?
+//  - .only / .skip ignored (have to comment out tests)
+
+describe('test', () => {
+  test('test', async () => {
+    const client = new Client();
+    client.addTypes([FunctionType]);
+    await client.initialize();
+    await client.halo.createIdentity();
+
+    // Part 1.
+    // Create script.
+    // VITEST_ENV=chromium p test
+    // TODO(burdon): Test after initialize.
+    //  - 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(create(FunctionType, { version: 1, binding: 'HELLO' }));
+    expect(fn).to.exist;
+  });
+});

package/src/testing/index.ts

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

package/src/testing/testing.tsx

@@ -0,0 +1,68 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { type Decorator } from '@storybook/react';
+import React, { useState } from 'react';
+
+import { type Space } from '@dxos/react-client/echo';
+import { useAsyncState } from '@dxos/react-hooks';
+
+import { ComputeGraphContextProvider } from '../components';
+import { createSheet } from '../defs';
+import { type ComputeGraph, type ComputeGraphOptions, ComputeGraphRegistry } from '../graph';
+import { type CellValue, type CreateSheetOptions } from '../types';
+
+const testSheetName = 'test';
+
+export const createTestCells = (): Record<string, CellValue> => ({
+  B1: { value: 'Qty2' },
+  B3: { value: 1 },
+  B4: { value: 2 },
+  B5: { value: 3 },
+  B7: { value: 'Total' },
+
+  C1: { value: 'Price' },
+  C3: { value: 2_000 },
+  C4: { value: 2_500 },
+  C5: { value: 3_000 },
+  C7: { value: '=SUMPRODUCT(B2:B6, C2:C6)' },
+  // C8: { value: '=C7*CRYPTO(D7)' },
+  C8: { value: '=C7*TEST()' },
+
+  D7: { value: 'USD' },
+  D8: { value: 'BTC' },
+
+  E3: { value: '=TODAY()' },
+  E4: { value: '=NOW()' },
+
+  F1: { value: `=${testSheetName}!A1` }, // Ref test sheet.
+  F3: { value: true },
+  F4: { value: false },
+  F5: { value: '8%' },
+  F6: { value: '$10000' },
+});
+
+export const useTestSheet = (space?: Space, graph?: ComputeGraph, options?: CreateSheetOptions) => {
+  const [sheet] = useAsyncState(async () => {
+    if (!space || !graph) {
+      return;
+    }
+
+    const sheet = createSheet(options);
+    space.db.add(sheet);
+    return sheet;
+  }, [space, graph]);
+  return sheet;
+};
+
+export const withComputeGraphDecorator =
+  (options?: ComputeGraphOptions): Decorator =>
+  (Story) => {
+    const [registry] = useState(new ComputeGraphRegistry(options));
+    return (
+      <ComputeGraphContextProvider registry={registry}>
+        <Story />
+      </ComputeGraphContextProvider>
+    );
+  };