@dxos/plugin-sheet 0.7.4 → 0.7.5-labs.401163d

package/src/integrations/thread-ranges.ts

@@ -4,13 +4,21 @@
 
 import { useCallback, useEffect, useMemo } from 'react';
 
-import { type IntentResolver, LayoutAction, useIntentDispatcher, useIntentResolver } from '@dxos/app-framework';
+import {
+  createIntent,
+  createResolver,
+  LayoutAction,
+  useIntentResolver,
+  useIntentDispatcher,
+} from '@dxos/app-framework';
 import { debounce } from '@dxos/async';
+import { type CellAddress, type CompleteCellRange, inRange } from '@dxos/compute';
+import { S } from '@dxos/echo-schema';
+import { ThreadAction } from '@dxos/plugin-thread/types';
 import { fullyQualifiedId } from '@dxos/react-client/echo';
-import { type DxGridElement, type DxGridPosition } from '@dxos/react-ui-grid';
+import { type DxGridElement, type DxGridPosition, type GridContentProps } from '@dxos/react-ui-grid';
 
 import { useSheetContext } from '../components';
-import { type CellAddress, type CompleteCellRange, inRange } from '../defs';
 import { SHEET_PLUGIN } from '../meta';
 
 export const completeCellRangeToThreadCursor = (range: CompleteCellRange): string => {
@@ -32,31 +40,40 @@ export const parseThreadAnchorAsCellRange = (cursor: string): CompleteCellRange
 
 export const useUpdateFocusedCellOnThreadSelection = (grid: DxGridElement | null) => {
   const { model, setActiveRefs } = useSheetContext();
-  const handleScrollIntoView: IntentResolver = useCallback(
-    ({ action, data }) => {
-      switch (action) {
-        case LayoutAction.SCROLL_INTO_VIEW: {
-          if (!data?.id || data?.cursor === undefined || data?.id !== fullyQualifiedId(model.sheet)) {
-            return;
+  const scrollIntoViewResolver = useMemo(
+    () =>
+      createResolver({
+        intent: LayoutAction.ScrollIntoView,
+        position: 'hoist',
+        filter: (
+          data,
+        ): data is {
+          part: 'current';
+          subject: string;
+          options: { cursor: string; ref: GridContentProps['activeRefs'] };
+        } => {
+          if (!S.is(LayoutAction.ScrollIntoView.fields.input)(data)) {
+            return false;
           }
-          setActiveRefs(data.thread);
+
+          return data.subject === fullyQualifiedId(model.sheet) && !!data.options?.cursor;
+        },
+        resolve: ({ options: { cursor, ref } }) => {
+          setActiveRefs(ref);
           // TODO(Zan): Everywhere we refer to the cursor in a thread context should change to `anchor`.
-          const range = parseThreadAnchorAsCellRange(data.cursor);
+          const range = parseThreadAnchorAsCellRange(cursor!);
           range && grid?.setFocus({ ...range.to, plane: 'grid' }, true);
-
-          return { data: true };
-        }
-      }
-    },
+        },
+      }),
     [model.sheet, setActiveRefs],
   );
 
-  useIntentResolver(SHEET_PLUGIN, handleScrollIntoView);
+  useIntentResolver(SHEET_PLUGIN, scrollIntoViewResolver);
 };
 
 export const useSelectThreadOnCellFocus = () => {
   const { model, cursor } = useSheetContext();
-  const dispatch = useIntentDispatcher();
+  const { dispatchPromise: dispatch } = useIntentDispatcher();
 
   const threads = useMemo(
     () => model.sheet.threads?.filter((thread): thread is NonNullable<typeof thread> => !!thread) ?? [],
@@ -72,9 +89,9 @@ export const useSelectThreadOnCellFocus = () => {
         return;
       }
 
-      const closestThread = threads?.find(({ anchor }) => {
-        if (anchor) {
-          const range = parseThreadAnchorAsCellRange(anchor);
+      const closestThread = threads?.find((ref) => {
+        if (ref.target?.anchor) {
+          const range = parseThreadAnchorAsCellRange(ref.target!.anchor);
           return range ? inRange(range, cellAddress) : false;
         } else {
           return false;
@@ -82,9 +99,7 @@ export const useSelectThreadOnCellFocus = () => {
       });
 
       if (closestThread) {
-        void dispatch([
-          { action: 'dxos.org/plugin/thread/action/select', data: { current: fullyQualifiedId(closestThread) } },
-        ]);
+        void dispatch(createIntent(ThreadAction.Select, { current: fullyQualifiedId(closestThread) }));
       }
     },
     [dispatch, threads],

package/src/meta.ts

@@ -6,10 +6,12 @@ import { type PluginMeta } from '@dxos/app-framework';
 
 export const SHEET_PLUGIN = 'dxos.org/plugin/sheet';
 
-export default {
+export const meta = {
   id: SHEET_PLUGIN,
   name: 'Sheet',
-  description: 'A simple spreadsheet plugin.',
+  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. ',
   icon: 'ph--grid-nine--regular',
   source: 'https://github.com/dxos/dxos/tree/main/packages/plugins/plugin-sheet',
+  screenshots: ['https://dxos.network/plugin-details-sheet-dark.png'],
 } satisfies PluginMeta;

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

@@ -5,20 +5,14 @@
 import { afterEach, beforeEach, describe, expect, onTestFinished, test } from 'vitest';
 
 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 { log } from '@dxos/log';
-import { FunctionType } from '@dxos/plugin-script/types';
 
 import { SheetModel } from './sheet-model';
 import { createTestGrid } from './testing';
-import { TestBuilder, testFunctionPlugins } from '../compute-graph/testing';
-import {
-  addressFromA1Notation,
-  createSheet,
-  isFormula,
-  mapFormulaIndicesToRefs,
-  mapFormulaRefsToIndices,
-} from '../defs';
-import { type CellScalarValue } from '../types';
+import { createSheet, mapFormulaIndicesToRefs, mapFormulaRefsToIndices } from '../types';
 
 describe('SheetModel', () => {
   let testBuilder: TestBuilder;

package/src/model/sheet-model.ts

@@ -2,37 +2,45 @@
 // Copyright 2024 DXOS.org
 //
 
-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 {
+  addressFromA1Notation,
+  addressToA1Notation,
+  createSheetName,
+  isFormula,
+  type CellAddress,
+  type CellRange,
+  type CellScalarValue,
+  type ComputeGraph,
+  type ComputeNode,
+  type ComputeNodeEvent,
+  DetailedCellError,
+  ExportedCellChange,
+  type SimpleCellRange,
+  type SimpleCellAddress,
+  type SimpleDate,
+  type SimpleDateTime,
+} from '@dxos/compute';
 import { Resource } from '@dxos/context';
 import { getTypename, FormatEnum, TypeEnum } from '@dxos/echo-schema';
 import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 
-import { DetailedCellError, ExportedCellChange } from '#hyperformula';
-import { type ComputeGraph, type ComputeNode, type ComputeNodeEvent, createSheetName } from '../compute-graph';
 import {
-  addressFromA1Notation,
+  ReadonlyException,
   addressFromIndex,
-  addressToA1Notation,
   addressToIndex,
   initialize,
   insertIndices,
-  isFormula,
-  type CellAddress,
-  type CellRange,
-  ReadonlyException,
-  MAX_COLUMNS,
-  MAX_ROWS,
   mapFormulaIndicesToRefs,
   mapFormulaRefsToIndices,
-} from '../defs';
-import { type CellScalarValue, type CellValue, type SheetType, type RestoreAxis } from '../types';
+  MAX_ROWS,
+  MAX_COLS,
+} from '../types';
+import { type SheetAction, type CellValue, type SheetType } 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)
@@ -176,12 +184,12 @@ export class SheetModel extends Resource {
   }
 
   insertColumns(i: number, n = 1) {
-    const idx = insertIndices(this._sheet.columns, i, n, MAX_COLUMNS);
+    const idx = insertIndices(this._sheet.columns, i, n, MAX_COLS);
     this.reset();
     return idx;
   }
 
-  dropRow(rowIndex: string): RestoreAxis {
+  dropRow(rowIndex: string): SheetAction.RestoreAxis {
     const range = {
       from: addressFromIndex(this._sheet, `${this._sheet.columns[0]}@${rowIndex}`),
       to: addressFromIndex(this._sheet, `${this._sheet.columns[this._sheet.columns.length - 1]}@${rowIndex}`),
@@ -195,7 +203,7 @@ export class SheetModel extends Resource {
     return { axis: 'row', index, axisIndex: rowIndex, axisMeta: this._sheet.rowMeta[rowIndex], values };
   }
 
-  dropColumn(colIndex: string): RestoreAxis {
+  dropColumn(colIndex: string): SheetAction.RestoreAxis {
     const range = {
       from: addressFromIndex(this._sheet, `${colIndex}@${this._sheet.rows[0]}`),
       to: addressFromIndex(this._sheet, `${colIndex}@${this._sheet.rows[this._sheet.rows.length - 1]}`),
@@ -209,7 +217,7 @@ export class SheetModel extends Resource {
     return { axis: 'col', index, axisIndex: colIndex, axisMeta: this._sheet.rowMeta[colIndex], values };
   }
 
-  restoreRow({ index, axisIndex, axisMeta, values }: RestoreAxis) {
+  restoreRow({ index, axisIndex, axisMeta, values }: SheetAction.RestoreAxis) {
     this._sheet.rows.splice(index, 0, axisIndex);
     values.forEach((value, col) => {
       if (value) {
@@ -222,7 +230,7 @@ export class SheetModel extends Resource {
     this.reset();
   }
 
-  restoreColumn({ index, axisIndex, axisMeta, values }: RestoreAxis) {
+  restoreColumn({ index, axisIndex, axisMeta, values }: SheetAction.RestoreAxis) {
     this._sheet.columns.splice(index, 0, axisIndex);
     values.forEach((value, row) => {
       if (value) {
@@ -373,7 +381,7 @@ export class SheetModel extends Resource {
       refresh = true;
     }
     if (cell.col >= this._sheet.columns.length) {
-      insertIndices(this._sheet.columns, cell.col, 1, MAX_COLUMNS);
+      insertIndices(this._sheet.columns, cell.col, 1, MAX_COLS);
       refresh = true;
     }
 

package/src/model/testing.ts

@@ -2,8 +2,9 @@
 // Copyright 2024 DXOS.org
 //
 
-import { addressToA1Notation, createSheet } from '../defs';
-import type { CellValue, SheetType } from '../types';
+import { addressToA1Notation } from '@dxos/compute';
+
+import { type CellValue, type SheetType, createSheet } from '../types';
 
 // TODO(burdon): Create testing endpoint.
 // TODO(burdon): Move to react-ui-sheet.

package/src/model/useSheetModel.ts

@@ -4,7 +4,8 @@
 
 import { useEffect, useState } from 'react';
 
-import { type ComputeGraph } from '../compute-graph';
+import { type ComputeGraph } from '@dxos/compute';
+
 import { SheetModel } from '../model';
 import { type SheetType } from '../types';
 

package/src/sanity.test.ts

@@ -12,7 +12,7 @@ import { describe, test, expect } from 'vitest';
 
 import { Client } from '@dxos/client';
 import { create } from '@dxos/client/echo';
-import { FunctionType } from '@dxos/plugin-script/types';
+import { FunctionType } from '@dxos/functions';
 
 // TODO(burdon): Fix test infrastructure:
 //  - Need docs? esp. needed for config. need pristine example package?

package/src/testing/testing.tsx

@@ -5,13 +5,12 @@
 import { type Decorator } from '@storybook/react';
 import React, { useState } from 'react';
 
+import { type ComputeGraph, type ComputeGraphOptions, ComputeGraphRegistry } from '@dxos/compute';
 import { type Space } from '@dxos/react-client/echo';
 import { useAsyncState } from '@dxos/react-hooks';
 
 import { ComputeGraphContextProvider } from '../components';
-import { type ComputeGraph, type ComputeGraphOptions, ComputeGraphRegistry } from '../compute-graph';
-import { createSheet } from '../defs';
-import { type CreateSheetOptions } from '../types';
+import { createSheet, type CreateSheetOptions } from '../types';
 
 export const useTestSheet = (space?: Space, graph?: ComputeGraph, options?: CreateSheetOptions) => {
   const [sheet] = useAsyncState(async () => {

package/src/{defs → types}/index.ts

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

package/src/types/schema.ts

@@ -0,0 +1,56 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { Ref, S, TypedObject } from '@dxos/echo-schema';
+import { ThreadType } from '@dxos/plugin-space/types';
+
+export const CellValue = S.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: S.Any,
+});
+
+export type CellValue = S.Schema.Type<typeof CellValue>;
+
+// TODO(burdon): IMPORTANT: Reconcile with Field definition.
+export const Range = S.Struct({
+  range: S.String,
+  key: S.String,
+  value: S.String,
+});
+
+export type Range = S.Schema.Type<typeof Range>;
+
+// TODO(burdon): Visibility, locked, frozen, etc.
+export const RowColumnMeta = S.Struct({
+  size: S.optional(S.Number),
+});
+
+// TODO(burdon): Reconcile col/column (across packages).
+// TODO(burdon): Index to all updates when rows/columns are inserted/deleted.
+export class SheetType extends TypedObject({ typename: 'dxos.org/type/Sheet', version: '0.1.0' })({
+  name: S.optional(S.String),
+
+  // Sparse map of cells referenced by index.
+  cells: S.mutable(S.Record({ key: S.String, value: S.mutable(CellValue) })),
+
+  // Ordered row indices.
+  rows: S.mutable(S.Array(S.String)),
+
+  // Ordered column indices.
+  columns: S.mutable(S.Array(S.String)),
+
+  // Row metadata referenced by index.
+  rowMeta: S.mutable(S.Record({ key: S.String, value: S.mutable(RowColumnMeta) })),
+
+  // Column metadata referenced by index.
+  columnMeta: S.mutable(S.Record({ key: S.String, value: S.mutable(RowColumnMeta) })),
+
+  // Cell formatting referenced by indexed range.
+  ranges: S.mutable(S.Array(Range)),
+
+  // Threads associated with the sheet
+  threads: S.optional(S.mutable(S.Array(Ref(ThreadType)))),
+}) {}

package/src/{defs → types}/sheet-range-types.ts

@@ -8,7 +8,7 @@ import { type SheetType } from '../types';
 
 export const alignKey = 'alignment';
 export type AlignKey = typeof alignKey;
-export type AlignValue = 'start' | 'center' | 'end' | 'unset';
+export type AlignValue = 'start' | 'center' | 'end';
 
 export const commentKey = 'comment';
 export type CommentKey = typeof commentKey;

package/src/types/types.ts

@@ -0,0 +1,67 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { S } from '@dxos/echo-schema';
+
+import { type CellValue, RowColumnMeta, SheetType } from './schema';
+import { SHEET_PLUGIN } from '../meta';
+import { SheetModel } from '../model';
+
+export type SheetSize = {
+  rows: number;
+  columns: number;
+};
+
+export type CreateSheetOptions = {
+  name?: string;
+  cells?: Record<string, CellValue>;
+} & Partial<SheetSize>;
+
+export namespace SheetAction {
+  const SHEET_ACTION = `${SHEET_PLUGIN}/action`;
+
+  export class Create extends S.TaggedClass<Create>()(`${SHEET_ACTION}/create`, {
+    input: S.Struct({
+      name: S.optional(S.String),
+    }),
+    output: S.Struct({
+      object: SheetType,
+    }),
+  }) {}
+
+  // TODO(wittjosiah): Factor out. This is `DxGridAxis` from `@dxos/react-ui-grid`.
+  const Axis = S.Union(S.Literal('row'), S.Literal('col'));
+
+  export class InsertAxis extends S.TaggedClass<InsertAxis>()(`${SHEET_ACTION}/axis-insert`, {
+    input: S.Struct({
+      // TODO(wittjosiah): S.instanceOf(SheetModel) throws when running tests.
+      model: S.Any.pipe(S.filter((model) => model instanceof SheetModel)) as S.Schema<SheetModel>,
+      axis: Axis,
+      index: S.Number,
+      count: S.optional(S.Number),
+    }),
+    output: S.Void,
+  }) {}
+
+  export const RestoreAxis = S.Struct({
+    axis: Axis,
+    axisIndex: S.String,
+    index: S.Number,
+    axisMeta: RowColumnMeta,
+    values: S.Array(S.Any),
+  });
+
+  export type RestoreAxis = S.Schema.Type<typeof RestoreAxis>;
+
+  export class DropAxis extends S.TaggedClass<DropAxis>()(`${SHEET_ACTION}/axis-drop`, {
+    input: S.Struct({
+      // TODO(wittjosiah): S.instanceOf(SheetModel) throws when running tests.
+      model: S.Any.pipe(S.filter((model) => model instanceof SheetModel)) as S.Schema<SheetModel>,
+      axis: Axis,
+      axisIndex: S.String,
+      deletionData: S.optional(RestoreAxis),
+    }),
+    output: S.Void,
+  }) {}
+}

package/src/{defs → types}/util.ts

@@ -2,10 +2,6 @@
 // Copyright 2024 DXOS.org
 //
 
-import { randomBytes } from '@dxos/crypto';
-import { invariant } from '@dxos/invariant';
-import { create } from '@dxos/live-object';
-
 import {
   addressFromA1Notation,
   addressToA1Notation,
@@ -13,13 +9,19 @@ import {
   type CellAddress,
   type CellRange,
   type CompleteCellRange,
-  DEFAULT_COLUMNS,
-  DEFAULT_ROWS,
-  MAX_COLUMNS,
-  MAX_ROWS,
-} from './types';
+} from '@dxos/compute';
+import { randomBytes } from '@dxos/crypto';
+import { invariant } from '@dxos/invariant';
+import { create } from '@dxos/live-object';
+
 import { type CreateSheetOptions, type SheetSize, SheetType } from '../types';
 
+export const MAX_ROWS = 500;
+export const MAX_COLS = 676; // 26^2;
+
+export const DEFAULT_ROWS = 50;
+export const DEFAULT_COLS = 26;
+
 // TODO(burdon): Factor out from dxos/protocols to new common package.
 export class ApiError extends Error {}
 
@@ -31,8 +33,6 @@ export class RangeException extends ApiError {
   }
 }
 
-// TODO(burdon): Factor out to types lib.
-
 /**
  * With a string length of 8, the chance of a collision is 0.02% for a sheet with 10,000 strings.
  */
@@ -57,13 +57,13 @@ export const insertIndices = (indices: string[], i: number, n: number, max: numb
 
 export const initialize = (
   sheet: SheetType,
-  { rows = DEFAULT_ROWS, columns = DEFAULT_COLUMNS }: Partial<SheetSize> = {},
+  { rows = DEFAULT_ROWS, columns = DEFAULT_COLS }: Partial<SheetSize> = {},
 ) => {
   if (!sheet.rows.length) {
     insertIndices(sheet.rows, 0, rows, MAX_ROWS);
   }
   if (!sheet.columns.length) {
-    insertIndices(sheet.columns, 0, columns, MAX_COLUMNS);
+    insertIndices(sheet.columns, 0, columns, MAX_COLS);
   }
 };