@dxos/plugin-sheet 0.6.13-main.ed424a1 → 0.6.13

package/dist/lib/node-esm/chunk-BPXXIAOQ.mjs

@@ -1,1529 +0,0 @@
-import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
-import {
-  SheetType
-} from "./chunk-WFDTY3IC.mjs";
-import {
-  SHEET_PLUGIN
-} from "./chunk-VCYJWE3O.mjs";
-import {
-  createSheetName
-} from "./chunk-5WPZCXNS.mjs";
-
-// packages/plugins/plugin-sheet/src/components/ComputeGraph/ComputeGraphContextProvider.tsx
-import React, { createContext } from "react";
-var ComputeGraphContext = /* @__PURE__ */ createContext(void 0);
-var ComputeGraphContextProvider = ({ registry, children }) => {
-  return /* @__PURE__ */ React.createElement(ComputeGraphContext.Provider, {
-    value: {
-      registry
-    }
-  }, children);
-};
-
-// packages/plugins/plugin-sheet/src/defs/util.ts
-import { randomBytes } from "@dxos/crypto";
-import { create } from "@dxos/echo-schema";
-
-// packages/plugins/plugin-sheet/src/defs/types.ts
-import { invariant } from "@dxos/invariant";
-var __dxlog_file = "/home/runner/work/dxos/dxos/packages/plugins/plugin-sheet/src/defs/types.ts";
-var DEFAULT_ROWS = 50;
-var DEFAULT_COLUMNS = 26;
-var MAX_ROWS = 500;
-var MAX_COLUMNS = 26 * 2;
-var posEquals = (a, b) => {
-  return a?.col === b?.col && a?.row === b?.row;
-};
-var columnLetter = (col) => {
-  invariant(col < MAX_COLUMNS, `Invalid column: ${col}`, {
-    F: __dxlog_file,
-    L: 26,
-    S: void 0,
-    A: [
-      "col < MAX_COLUMNS",
-      "`Invalid column: ${col}`"
-    ]
-  });
-  return (col >= 26 ? String.fromCharCode("A".charCodeAt(0) + Math.floor(col / 26) - 1) : "") + String.fromCharCode("A".charCodeAt(0) + col % 26);
-};
-var addressToA1Notation = ({ col, row }) => {
-  return `${columnLetter(col)}${row + 1}`;
-};
-var addressFromA1Notation = (ref) => {
-  const match = ref.match(/([A-Z]+)(\d+)/);
-  invariant(match, `Invalid notation: ${ref}`, {
-    F: __dxlog_file,
-    L: 40,
-    S: void 0,
-    A: [
-      "match",
-      "`Invalid notation: ${ref}`"
-    ]
-  });
-  return {
-    row: parseInt(match[2], 10) - 1,
-    col: match[1].split("").reduce((acc, c) => acc * 26 + c.charCodeAt(0) - "A".charCodeAt(0) + 1, 0) - 1
-  };
-};
-var rangeToA1Notation = (range) => {
-  return [
-    range?.from && addressToA1Notation(range?.from),
-    range?.to && addressToA1Notation(range?.to)
-  ].filter(Boolean).join(":");
-};
-var inRange = (range, cell) => {
-  if (!range) {
-    return false;
-  }
-  const { from, to } = range;
-  if (from && posEquals(from, cell) || to && posEquals(to, cell)) {
-    return true;
-  }
-  if (!from || !to) {
-    return false;
-  }
-  const { col: c1, row: r1 } = from;
-  const { col: c2, row: r2 } = to;
-  const cMin = Math.min(c1, c2);
-  const cMax = Math.max(c1, c2);
-  const rMin = Math.min(r1, r2);
-  const rMax = Math.max(r1, r2);
-  const { col, row } = cell;
-  return col >= cMin && col <= cMax && row >= rMin && row <= rMax;
-};
-
-// packages/plugins/plugin-sheet/src/defs/util.ts
-var ApiError = class extends Error {
-};
-var ReadonlyException = class extends ApiError {
-};
-var RangeException = class extends ApiError {
-  constructor(n) {
-    super();
-  }
-};
-var createIndex = (length = 8) => {
-  const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-  const charactersLength = characters.length;
-  const randomBuffer = randomBytes(length);
-  return Array.from(randomBuffer, (byte) => characters[byte % charactersLength]).join("");
-};
-var createIndices = (length) => Array.from({
-  length
-}).map(() => createIndex());
-var insertIndices = (indices, i, n, max) => {
-  if (i + n > max) {
-    throw new RangeException(i + n);
-  }
-  const idx = createIndices(n);
-  indices.splice(i, 0, ...idx);
-};
-var initialize = (sheet, { rows = DEFAULT_ROWS, columns = DEFAULT_COLUMNS } = {}) => {
-  if (!sheet.rows.length) {
-    insertIndices(sheet.rows, 0, rows, MAX_ROWS);
-  }
-  if (!sheet.columns.length) {
-    insertIndices(sheet.columns, 0, columns, MAX_COLUMNS);
-  }
-};
-var createSheet = ({ name, cells, ...size } = {}) => {
-  const sheet = create(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));
-      sheet.cells[idx] = {
-        value
-      };
-    });
-  }
-  return sheet;
-};
-var addressToIndex = (sheet, cell) => {
-  return `${sheet.columns[cell.col]}@${sheet.rows[cell.row]}`;
-};
-var addressFromIndex = (sheet, idx) => {
-  const [column, row] = idx.split("@");
-  return {
-    col: sheet.columns.indexOf(column),
-    row: sheet.rows.indexOf(row)
-  };
-};
-var closest = (cursor, cells) => {
-  let closestCell2;
-  let closestDistance = Number.MAX_SAFE_INTEGER;
-  for (const cell of cells) {
-    const distance = Math.abs(cell.row - cursor.row) + Math.abs(cell.col - cursor.col);
-    if (distance < closestDistance) {
-      closestCell2 = cell;
-      closestDistance = distance;
-    }
-  }
-  return closestCell2;
-};
-var compareIndexPositions = (sheet, indexA, indexB) => {
-  const { row: rowA, col: columnA } = addressFromIndex(sheet, indexA);
-  const { row: rowB, col: columnB } = addressFromIndex(sheet, indexB);
-  if (rowA !== rowB) {
-    return rowA - rowB;
-  } else {
-    return columnA - columnB;
-  }
-};
-
-// packages/plugins/plugin-sheet/src/defs/sheet-range-types.ts
-var cellClassNameForRange = ({ key, value }) => {
-  switch (key) {
-    case "align":
-      switch (value) {
-        case "start":
-          return "text-start";
-        case "center":
-          return "text-center";
-        case "end":
-          return "text-end";
-        default:
-          return void 0;
-      }
-    case "comment":
-      return "bg-gridComment";
-    case "style":
-      switch (value) {
-        case "highlight":
-          return "bg-gridHighlight";
-        default:
-          return void 0;
-      }
-    default:
-      return void 0;
-  }
-};
-
-// packages/plugins/plugin-sheet/src/extensions/compute.ts
-import { syntaxTree } from "@codemirror/language";
-import { RangeSetBuilder, StateEffect, StateField } from "@codemirror/state";
-import { Decoration, EditorView, ViewPlugin, WidgetType } from "@codemirror/view";
-import { debounce } from "@dxos/async";
-import { invariant as invariant2 } from "@dxos/invariant";
-import { documentId, singleValueFacet } from "@dxos/react-ui-editor/state";
-var updateAllDecorations = StateEffect.define();
-var computeGraphFacet = singleValueFacet();
-
-// packages/plugins/plugin-sheet/src/extensions/editor/extension.ts
-import { acceptCompletion, autocompletion, completionStatus, startCompletion } from "@codemirror/autocomplete";
-import { HighlightStyle, syntaxHighlighting } from "@codemirror/language";
-import { ViewPlugin as ViewPlugin2, keymap } from "@codemirror/view";
-import { tags } from "@lezer/highlight";
-import { spreadsheet } from "codemirror-lang-spreadsheet";
-import { singleValueFacet as singleValueFacet2 } from "@dxos/react-ui-editor/state";
-import { mx } from "@dxos/react-ui-theme";
-var highlightStyles = HighlightStyle.define([
-  // Function.
-  {
-    tag: tags.name,
-    class: "text-accentText"
-  },
-  // Range.
-  {
-    tag: tags.tagName,
-    class: "text-pinkText"
-  },
-  // Values.
-  {
-    tag: tags.number,
-    class: "text-tealText"
-  },
-  {
-    tag: tags.bool,
-    class: "text-tealText"
-  },
-  {
-    tag: tags.string,
-    class: "text-tealText"
-  },
-  // Error.
-  {
-    tag: tags.invalid,
-    class: "text-unAccent"
-  }
-]);
-var languageFacet = singleValueFacet2();
-var sheetExtension = ({ functions = [] }) => {
-  const { extension, language } = spreadsheet({
-    idiom: "en-US",
-    decimalSeparator: "."
-  });
-  const createCompletion = (name) => {
-    const { section = "Custom", description, syntax } = functions.find((value) => value.name === name) ?? {};
-    return {
-      section,
-      label: name,
-      info: () => {
-        if (!description && !syntax) {
-          return null;
-        }
-        const root = document.createElement("div");
-        root.className = "flex flex-col gap-2 text-sm";
-        const title = document.createElement("h2");
-        title.innerText = name;
-        title.className = "text-lg font-mono text-accentText";
-        root.appendChild(title);
-        if (description) {
-          const info = document.createElement("p");
-          info.innerText = description;
-          info.className = "text-subdued";
-          root.appendChild(info);
-        }
-        if (syntax) {
-          const detail = document.createElement("pre");
-          detail.innerText = syntax;
-          detail.className = "whitespace-pre-wrap text-greenText";
-          root.appendChild(detail);
-        }
-        return root;
-      },
-      apply: (view, completion, from, to) => {
-        const insertParens = to === view.state.doc.toString().length;
-        view.dispatch(view.state.update({
-          changes: {
-            from,
-            to,
-            insert: completion.label + (insertParens ? "()" : "")
-          },
-          selection: {
-            anchor: from + completion.label.length + 1
-          }
-        }));
-      }
-    };
-  };
-  return [
-    extension,
-    languageFacet.of(language),
-    language.data.of({
-      autocomplete: (context) => {
-        if (context.state.doc.toString()[0] !== "=") {
-          return null;
-        }
-        const match = context.matchBefore(/\w*/);
-        if (!match || match.from === match.to) {
-          return null;
-        }
-        const text = match.text.toUpperCase();
-        if (!context.explicit && match.text.length < 2) {
-          return null;
-        }
-        return {
-          from: match.from,
-          options: functions?.filter(({ name }) => name.startsWith(text)).map(({ name }) => createCompletion(name)) ?? []
-        };
-      }
-    }),
-    syntaxHighlighting(highlightStyles),
-    autocompletion({
-      aboveCursor: false,
-      defaultKeymap: true,
-      activateOnTyping: true,
-      // NOTE: Useful for debugging.
-      closeOnBlur: false,
-      icons: false,
-      tooltipClass: () => mx("!-left-[1px] !top-[33px] !-m-0 border !border-t-0 [&>ul]:!min-w-[198px]", "[&>ul>li[aria-selected]]:!bg-accentSurface", "border-separator")
-    }),
-    keymap.of([
-      {
-        key: "Tab",
-        run: (view) => {
-          return completionStatus(view.state) === "active" ? acceptCompletion(view) : startCompletion(view);
-        }
-      }
-    ])
-  ];
-};
-var rangeExtension = (onInit) => {
-  let view;
-  let activeRange;
-  const provider = (range) => {
-    if (activeRange) {
-      view.dispatch(view.state.update({
-        changes: {
-          ...activeRange,
-          insert: range.toString()
-        },
-        selection: {
-          anchor: activeRange.from + range.length
-        }
-      }));
-    }
-    view.focus();
-  };
-  return ViewPlugin2.fromClass(class {
-    constructor(_view) {
-      view = _view;
-      onInit(provider);
-    }
-    update(view2) {
-      const { anchor } = view2.state.selection.ranges[0];
-      activeRange = void 0;
-      const language = view2.state.facet(languageFacet);
-      const { topNode } = language.parser.parse(view2.state.doc.toString());
-      visitTree(topNode, ({ type, from, to }) => {
-        if (from <= anchor && to >= anchor) {
-          switch (type.name) {
-            case "Function": {
-              activeRange = {
-                from: to,
-                to
-              };
-              break;
-            }
-            case "CloseParen": {
-              activeRange = {
-                from,
-                to: from
-              };
-              break;
-            }
-            case "RangeToken":
-            case "CellToken":
-              activeRange = {
-                from,
-                to
-              };
-              return true;
-          }
-        }
-        return false;
-      });
-      if (!activeRange && view2.state.doc.toString()[0] === "=") {
-        activeRange = {
-          from: 1,
-          to: view2.state.doc.toString().length
-        };
-      }
-    }
-  });
-};
-var visitTree = (node, callback) => {
-  if (callback(node)) {
-    return true;
-  }
-  for (let child = node.firstChild; child !== null; child = child.nextSibling) {
-    if (visitTree(child, callback)) {
-      return true;
-    }
-  }
-  return false;
-};
-
-// packages/plugins/plugin-sheet/src/hooks/useComputeGraph.ts
-import { useContext as useContext2 } from "react";
-import { raise } from "@dxos/debug";
-import { useAsyncState } from "@dxos/react-hooks";
-
-// packages/plugins/plugin-sheet/src/components/index.ts
-import React4 from "react";
-
-// packages/plugins/plugin-sheet/src/components/GridSheet/GridSheet.tsx
-import React3, { useCallback as useCallback2, useMemo as useMemo3, useRef } from "react";
-import { useAttention } from "@dxos/react-ui-attention";
-import { Grid as Grid2, editorKeys, GridCellEditor, closestCell } from "@dxos/react-ui-grid";
-
-// packages/plugins/plugin-sheet/src/components/GridSheet/util.ts
-import { useEffect, useLayoutEffect, useState } from "react";
-import { createDocAccessor } from "@dxos/react-client/echo";
-import { parseValue, cellClassesForFieldType } from "@dxos/react-ui-data";
-import { colToA1Notation, rowToA1Notation } from "@dxos/react-ui-grid";
-import { mx as mx2 } from "@dxos/react-ui-theme";
-var dxGridCellIndexToSheetCellAddress = (index) => {
-  const [colStr, rowStr] = index.split(",");
-  return {
-    col: parseInt(colStr),
-    row: parseInt(rowStr)
-  };
-};
-var createDxGridColumns = (model) => {
-  return model.sheet.columns.reduce((acc, columnId, numericIndex) => {
-    if (model.sheet.columnMeta[columnId] && model.sheet.columnMeta[columnId].size) {
-      acc.grid[numericIndex] = {
-        size: model.sheet.columnMeta[columnId].size,
-        resizeable: true
-      };
-    }
-    return acc;
-  }, {
-    grid: {}
-  });
-};
-var createDxGridRows = (model) => {
-  return model.sheet.rows.reduce((acc, rowId, numericIndex) => {
-    if (model.sheet.rowMeta[rowId] && model.sheet.rowMeta[rowId].size) {
-      acc.grid[numericIndex] = {
-        size: model.sheet.rowMeta[rowId].size,
-        resizeable: true
-      };
-    }
-    return acc;
-  }, {
-    grid: {}
-  });
-};
-var projectCellProps = (model, col, row) => {
-  const address = {
-    col,
-    row
-  };
-  const rawValue = model.getValue(address);
-  if (rawValue === void 0 || rawValue === null) {
-    return {
-      value: ""
-    };
-  }
-  const ranges = model.sheet.ranges?.filter(({ range }) => inRange(range, address));
-  const type = model.getValueType(address);
-  const classNames = ranges?.map(cellClassNameForRange).reverse();
-  return {
-    value: parseValue(type, rawValue),
-    className: mx2(cellClassesForFieldType(type), classNames)
-  };
-};
-var gridCellGetter = (model) => {
-  const cachedGridCells = {};
-  return (nextBounds) => {
-    [
-      ...Array(nextBounds.end.col - nextBounds.start.col)
-    ].forEach((_, c0) => {
-      return [
-        ...Array(nextBounds.end.row - nextBounds.start.row)
-      ].forEach((_2, r0) => {
-        const col = nextBounds.start.col + c0;
-        const row = nextBounds.start.row + r0;
-        const cell = projectCellProps(model, col, row);
-        if (cell.value) {
-          cachedGridCells;
-          cachedGridCells[`${col},${row}`] = cell;
-        }
-      });
-    });
-    return cachedGridCells;
-  };
-};
-var rowLabelCell = (row) => ({
-  value: rowToA1Notation(row),
-  className: "text-end !pie-1",
-  resizeHandle: "row"
-});
-var colLabelCell = (col) => ({
-  value: colToA1Notation(col),
-  resizeHandle: "col"
-});
-var cellGetter = (model) => {
-  const getGridCells = gridCellGetter(model);
-  return (nextBounds, plane) => {
-    switch (plane) {
-      case "grid":
-        return getGridCells(nextBounds);
-      case "frozenColsStart":
-        return [
-          ...Array(nextBounds.end.row - nextBounds.start.row)
-        ].reduce((acc, _, r0) => {
-          const r = nextBounds.start.row + r0;
-          acc[`0,${r}`] = rowLabelCell(r);
-          return acc;
-        }, {});
-      case "frozenRowsStart":
-        return [
-          ...Array(nextBounds.end.col - nextBounds.start.col)
-        ].reduce((acc, _, c0) => {
-          const c = nextBounds.start.col + c0;
-          acc[`${c},0`] = colLabelCell(c);
-          return acc;
-        }, {});
-      default:
-        return {};
-    }
-  };
-};
-var useSheetModelDxGridProps = (dxGridRef, model) => {
-  const [columns, setColumns] = useState(createDxGridColumns(model));
-  const [rows, setRows] = useState(createDxGridColumns(model));
-  useLayoutEffect(() => {
-    const cellsAccessor = createDocAccessor(model.sheet, [
-      "cells"
-    ]);
-    if (dxGridRef.current) {
-      dxGridRef.current.getCells = cellGetter(model);
-    }
-    const handleCellsUpdate = () => {
-      dxGridRef.current?.requestUpdate("initialCells");
-    };
-    cellsAccessor.handle.addListener("change", handleCellsUpdate);
-    return () => cellsAccessor.handle.removeListener("change", handleCellsUpdate);
-  }, [
-    model
-  ]);
-  useEffect(() => {
-    const columnMetaAccessor = createDocAccessor(model.sheet, [
-      "columnMeta"
-    ]);
-    const rowMetaAccessor = createDocAccessor(model.sheet, [
-      "rowMeta"
-    ]);
-    const handleColumnMetaUpdate = () => {
-      setColumns(createDxGridColumns(model));
-    };
-    const handleRowMetaUpdate = () => {
-      setRows(createDxGridRows(model));
-    };
-    columnMetaAccessor.handle.addListener("change", handleColumnMetaUpdate);
-    rowMetaAccessor.handle.addListener("change", handleRowMetaUpdate);
-    return () => {
-      columnMetaAccessor.handle.removeListener("change", handleColumnMetaUpdate);
-      rowMetaAccessor.handle.removeListener("change", handleRowMetaUpdate);
-    };
-  }, [
-    model
-  ]);
-  return {
-    columns,
-    rows
-  };
-};
-
-// packages/plugins/plugin-sheet/src/hooks/useSheetModel.ts
-import { useEffect as useEffect2, useState as useState2 } from "react";
-
-// packages/plugins/plugin-sheet/src/model/decorations.ts
-import { create as create2 } from "@dxos/echo-schema";
-var createDecorations = () => {
-  const { decorations } = create2({
-    decorations: {}
-  });
-  const addDecoration = (cellIndex, decorator) => {
-    decorations[cellIndex] = [
-      ...decorations[cellIndex] || [],
-      decorator
-    ];
-  };
-  const removeDecoration = (cellIndex, type) => {
-    if (type) {
-      decorations[cellIndex] = (decorations[cellIndex] || []).filter((d) => d.type !== type);
-    } else {
-      delete decorations[cellIndex];
-    }
-  };
-  const getDecorationsForCell = (cellIndex) => {
-    return decorations[cellIndex];
-  };
-  const getAllDecorations = () => {
-    const result = [];
-    for (const decoratorArray of Object.values(decorations)) {
-      for (const decorator of decoratorArray) {
-        result.push(decorator);
-      }
-    }
-    return result;
-  };
-  return {
-    addDecoration,
-    removeDecoration,
-    getDecorationsForCell,
-    getAllDecorations
-  };
-};
-
-// packages/plugins/plugin-sheet/src/model/sheet-model.ts
-import { Event } from "@dxos/async";
-import { Resource } from "@dxos/context";
-import { getTypename } from "@dxos/echo-schema";
-import { invariant as invariant3 } from "@dxos/invariant";
-import { PublicKey } from "@dxos/keys";
-import { log } from "@dxos/log";
-import { FieldValueType } from "@dxos/schema";
-import { DetailedCellError, ExportedCellChange } from "#hyperformula";
-var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/plugins/plugin-sheet/src/model/sheet-model.ts";
-var typeMap = {
-  BOOLEAN: FieldValueType.Boolean,
-  NUMBER_RAW: FieldValueType.Number,
-  NUMBER_PERCENT: FieldValueType.Percent,
-  NUMBER_CURRENCY: FieldValueType.Currency,
-  NUMBER_DATETIME: FieldValueType.DateTime,
-  NUMBER_DATE: FieldValueType.Date,
-  NUMBER_TIME: FieldValueType.Time
-};
-var getTopLeft = (range) => {
-  const to = range.to ?? range.from;
-  return {
-    row: Math.min(range.from.row, to.row),
-    col: Math.min(range.from.col, to.col)
-  };
-};
-var toSimpleCellAddress = (sheet, cell) => ({
-  sheet,
-  row: cell.row,
-  col: cell.col
-});
-var toModelRange = (sheet, range) => ({
-  start: toSimpleCellAddress(sheet, range.from),
-  end: toSimpleCellAddress(sheet, range.to ?? range.from)
-});
-var SheetModel = class extends Resource {
-  constructor(_graph, _sheet, _options = {}) {
-    super();
-    this._graph = _graph;
-    this._sheet = _sheet;
-    this._options = _options;
-    this.id = `model-${PublicKey.random().truncate()}`;
-    this.update = new Event();
-  }
-  get graph() {
-    return this._graph;
-  }
-  get sheet() {
-    return this._sheet;
-  }
-  get readonly() {
-    return this._options.readonly;
-  }
-  get bounds() {
-    return {
-      rows: this._sheet.rows.length,
-      columns: this._sheet.columns.length
-    };
-  }
-  /**
-  * Initialize sheet and engine.
-  */
-  async _open() {
-    log("initialize", {
-      id: this.id
-    }, {
-      F: __dxlog_file2,
-      L: 106,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    initialize(this._sheet);
-    this._node = this._graph.getOrCreateNode(createSheetName({
-      type: getTypename(this._sheet),
-      id: this._sheet.id
-    }));
-    await this._node.open();
-    const unsubscribe = this._node.update.on((event) => this.update.emit(event));
-    this._ctx.onDispose(unsubscribe);
-    this.reset();
-  }
-  /**
-  * Update engine.
-  * NOTE: This resets the undo history.
-  * @deprecated
-  */
-  reset() {
-    invariant3(this._node, void 0, {
-      F: __dxlog_file2,
-      L: 126,
-      S: this,
-      A: [
-        "this._node",
-        ""
-      ]
-    });
-    this._node.graph.hf.clearSheet(this._node.sheetId);
-    Object.entries(this._sheet.cells).forEach(([key, { value }]) => {
-      invariant3(this._node, void 0, {
-        F: __dxlog_file2,
-        L: 129,
-        S: this,
-        A: [
-          "this._node",
-          ""
-        ]
-      });
-      const { col, row } = addressFromIndex(this._sheet, key);
-      if (typeof value === "string" && value.charAt(0) === "=") {
-        value = this._graph.mapFormulaToNative(this._graph.mapFunctionBindingFromId(this.mapFormulaIndicesToRefs(value)));
-      }
-      this._node.graph.hf.setCellContents({
-        sheet: this._node.sheetId,
-        row,
-        col
-      }, value);
-    });
-  }
-  /**
-  * Recalculate formulas.
-  * NOTE: This resets the undo history.
-  * https://hyperformula.handsontable.com/guide/volatile-functions.html#volatile-actions
-  * @deprecated
-  */
-  // TODO(burdon): Remove.
-  recalculate() {
-    this._node?.graph.hf.rebuildAndRecalculate();
-  }
-  insertRows(i, n = 1) {
-    insertIndices(this._sheet.rows, i, n, MAX_ROWS);
-    this.reset();
-  }
-  insertColumns(i, n = 1) {
-    insertIndices(this._sheet.columns, i, n, MAX_COLUMNS);
-    this.reset();
-  }
-  //
-  // Undoable actions.
-  // TODO(burdon): Group undoable methods; consistently update hf/sheet.
-  //
-  /**
-  * Clear range of values.
-  */
-  clear(range) {
-    invariant3(this._node, void 0, {
-      F: __dxlog_file2,
-      L: 171,
-      S: this,
-      A: [
-        "this._node",
-        ""
-      ]
-    });
-    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];
-    });
-  }
-  cut(range) {
-    invariant3(this._node, void 0, {
-      F: __dxlog_file2,
-      L: 182,
-      S: this,
-      A: [
-        "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];
-    });
-  }
-  copy(range) {
-    invariant3(this._node, void 0, {
-      F: __dxlog_file2,
-      L: 191,
-      S: this,
-      A: [
-        "this._node",
-        ""
-      ]
-    });
-    this._node.graph.hf.copy(toModelRange(this._node.sheetId, range));
-  }
-  paste(cell) {
-    invariant3(this._node, void 0, {
-      F: __dxlog_file2,
-      L: 196,
-      S: this,
-      A: [
-        "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
-          };
-        }
-      }
-    }
-  }
-  // TODO(burdon): Display undo/redo state.
-  undo() {
-    invariant3(this._node, void 0, {
-      F: __dxlog_file2,
-      L: 211,
-      S: this,
-      A: [
-        "this._node",
-        ""
-      ]
-    });
-    if (this._node.graph.hf.isThereSomethingToUndo()) {
-      this._node.graph.hf.undo();
-    }
-  }
-  redo() {
-    invariant3(this._node, void 0, {
-      F: __dxlog_file2,
-      L: 219,
-      S: this,
-      A: [
-        "this._node",
-        ""
-      ]
-    });
-    if (this._node.graph.hf.isThereSomethingToRedo()) {
-      this._node.graph.hf.redo();
-    }
-  }
-  /**
-  * Get value from sheet.
-  */
-  getCellValue(cell) {
-    const idx = addressToIndex(this._sheet, cell);
-    return this._sheet.cells[idx]?.value ?? null;
-  }
-  /**
-  * Get value as a string for editing.
-  */
-  getCellText(cell) {
-    const value = this.getCellValue(cell);
-    if (value == null) {
-      return void 0;
-    }
-    if (typeof value === "string" && value.charAt(0) === "=") {
-      return this._graph.mapFunctionBindingFromId(this.mapFormulaIndicesToRefs(value));
-    } else {
-      return String(value);
-    }
-  }
-  /**
-  * Get array of raw values from sheet.
-  */
-  getCellValues(range) {
-    return this._iterRange(range, (cell) => this.getCellValue(cell));
-  }
-  /**
-  * Gets the regular or computed value from the engine.
-  */
-  getValue(cell) {
-    invariant3(this._node, void 0, {
-      F: __dxlog_file2,
-      L: 262,
-      S: this,
-      A: [
-        "this._node",
-        ""
-      ]
-    });
-    const value = this._node.graph.hf.getCellValue(toSimpleCellAddress(this._node.sheetId, cell));
-    if (value instanceof DetailedCellError) {
-      return value.toString();
-    }
-    return value;
-  }
-  /**
-  * Get value type.
-  */
-  getValueType(cell) {
-    invariant3(this._node, void 0, {
-      F: __dxlog_file2,
-      L: 275,
-      S: this,
-      A: [
-        "this._node",
-        ""
-      ]
-    });
-    const addr = toSimpleCellAddress(this._node.sheetId, cell);
-    const type = this._node.graph.hf.getCellValueDetailedType(addr);
-    return typeMap[type];
-  }
-  /**
-  * Sets the value, updating the sheet and engine.
-  */
-  setValue(cell, value) {
-    invariant3(this._node, void 0, {
-      F: __dxlog_file2,
-      L: 285,
-      S: this,
-      A: [
-        "this._node",
-        ""
-      ]
-    });
-    if (this._options.readonly) {
-      throw new ReadonlyException();
-    }
-    let refresh = false;
-    if (cell.row >= this._sheet.rows.length) {
-      insertIndices(this._sheet.rows, cell.row, 1, MAX_ROWS);
-      refresh = true;
-    }
-    if (cell.col >= this._sheet.columns.length) {
-      insertIndices(this._sheet.columns, cell.col, 1, MAX_COLUMNS);
-      refresh = true;
-    }
-    if (refresh) {
-      this.reset();
-    }
-    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
-      ]
-    ]);
-    const idx = addressToIndex(this._sheet, cell);
-    if (value === void 0 || value === null) {
-      delete this._sheet.cells[idx];
-    } else {
-      if (typeof value === "string" && value.charAt(0) === "=") {
-        value = this._graph.mapFunctionBindingToId(this.mapFormulaRefsToIndices(value));
-      }
-      this._sheet.cells[idx] = {
-        value
-      };
-    }
-  }
-  /**
-  * Sets values from a simple map.
-  */
-  setValues(values) {
-    Object.entries(values).forEach(([key, { value }]) => {
-      this.setValue(addressFromA1Notation(key), value);
-    });
-  }
-  /**
-  * Iterate range.
-  */
-  _iterRange(range, cb) {
-    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.col, to.col),
-      Math.max(range.from.col, to.col)
-    ];
-    const rows = [];
-    for (let row = rowRange[0]; row <= rowRange[1]; row++) {
-      const rowCells = [];
-      for (let column = columnRange[0]; column <= columnRange[1]; column++) {
-        const value = cb({
-          row,
-          col: column
-        });
-        if (value !== void 0) {
-          rowCells.push(value);
-        }
-      }
-      rows.push(rowCells);
-    }
-    return rows;
-  }
-  // TODO(burdon): Delete index.
-  _deleteIndices(indices, i, n) {
-    throw new Error("Not implemented");
-  }
-  // TODO(burdon): Move. Cannot use fractional without changing. Switch back to using unique IDs?
-  _moveIndices(indices, i, j, n) {
-    throw new Error("Not implemented");
-  }
-  //
-  // Indices.
-  //
-  /**
-  * Map from A1 notation to indices.
-  */
-  mapFormulaRefsToIndices(formula) {
-    invariant3(formula.charAt(0) === "=", void 0, {
-      F: __dxlog_file2,
-      L: 374,
-      S: this,
-      A: [
-        "formula.charAt(0) === '='",
-        ""
-      ]
-    });
-    return formula.replace(/([a-zA-Z]+)([0-9]+)/g, (match) => {
-      return addressToIndex(this._sheet, addressFromA1Notation(match));
-    });
-  }
-  /**
-  * Map from indices to A1 notation.
-  */
-  mapFormulaIndicesToRefs(formula) {
-    invariant3(formula.charAt(0) === "=", void 0, {
-      F: __dxlog_file2,
-      L: 384,
-      S: this,
-      A: [
-        "formula.charAt(0) === '='",
-        ""
-      ]
-    });
-    return formula.replace(/([a-zA-Z0-9]+)@([a-zA-Z0-9]+)/g, (idx) => {
-      return addressToA1Notation(addressFromIndex(this._sheet, idx));
-    });
-  }
-  //
-  // Values
-  //
-  /**
-  * https://hyperformula.handsontable.com/guide/date-and-time-handling.html#example
-  * https://hyperformula.handsontable.com/api/interfaces/configparams.html#nulldate
-  * NOTE: TODAY() is number of FULL days since nullDate. It will typically be -1 days from NOW().
-  */
-  toLocalDate(num) {
-    const { year, month, day, hours, minutes, seconds } = this.toDateTime(num);
-    return new Date(year, month - 1, day, hours, minutes, seconds);
-  }
-  toDateTime(num) {
-    invariant3(this._node, void 0, {
-      F: __dxlog_file2,
-      L: 405,
-      S: this,
-      A: [
-        "this._node",
-        ""
-      ]
-    });
-    return this._node.graph.hf.numberToDateTime(num);
-  }
-  toDate(num) {
-    invariant3(this._node, void 0, {
-      F: __dxlog_file2,
-      L: 410,
-      S: this,
-      A: [
-        "this._node",
-        ""
-      ]
-    });
-    return this._node.graph.hf.numberToDate(num);
-  }
-  toTime(num) {
-    invariant3(this._node, void 0, {
-      F: __dxlog_file2,
-      L: 415,
-      S: this,
-      A: [
-        "this._node",
-        ""
-      ]
-    });
-    return this._node.graph.hf.numberToTime(num);
-  }
-};
-
-// packages/plugins/plugin-sheet/src/hooks/useSheetModel.ts
-var useSheetModel = (graph, sheet, { readonly } = {}) => {
-  const [model, setModel] = useState2();
-  useEffect2(() => {
-    if (!graph || !sheet) {
-      return;
-    }
-    let model2;
-    const t = setTimeout(async () => {
-      model2 = new SheetModel(graph, sheet, {
-        readonly
-      });
-      await model2.open();
-      setModel(model2);
-    });
-    return () => {
-      clearTimeout(t);
-      void model2?.close();
-    };
-  }, [
-    graph,
-    sheet,
-    readonly
-  ]);
-  return model;
-};
-
-// packages/plugins/plugin-sheet/src/hooks/threads.ts
-import { effect } from "@preact/signals-core";
-import { useCallback, useEffect as useEffect3, useMemo } from "react";
-import { LayoutAction, useIntentDispatcher, useIntentResolver } from "@dxos/app-framework";
-import { debounce as debounce2 } from "@dxos/async";
-import { fullyQualifiedId } from "@dxos/react-client/echo";
-var useUpdateFocusedCellOnThreadSelection = (model, grid) => {
-  const handleScrollIntoView = useCallback(({ action, data }) => {
-    switch (action) {
-      case LayoutAction.SCROLL_INTO_VIEW: {
-        if (!data?.id || data?.cursor === void 0 || data?.id !== fullyQualifiedId(model.sheet)) {
-          return;
-        }
-        const cellAddress = addressFromIndex(model.sheet, data.cursor);
-        grid.current?.setFocus({
-          ...cellAddress,
-          plane: "grid"
-        }, true);
-      }
-    }
-  }, [
-    model.sheet
-  ]);
-  useIntentResolver(SHEET_PLUGIN, handleScrollIntoView);
-};
-var useSelectThreadOnCellFocus = (model, cursor) => {
-  const dispatch = useIntentDispatcher();
-  const activeThreads = useMemo(() => model.sheet.threads?.filter((thread) => !!thread && thread.status === "active") ?? [], [
-    // TODO(thure): Surely we can find a better dependency for this…
-    JSON.stringify(model.sheet.threads)
-  ]);
-  const activeThreadAddresses = useMemo(() => activeThreads.map((thread) => thread.anchor).filter((anchor) => anchor !== void 0).map((anchor) => addressFromIndex(model.sheet, anchor)), [
-    activeThreads,
-    model.sheet
-  ]);
-  const selectClosestThread = useCallback((cellAddress) => {
-    if (!cellAddress || !activeThreads) {
-      return;
-    }
-    const closestThreadAnchor = closest(cellAddress, activeThreadAddresses);
-    if (closestThreadAnchor) {
-      const closestThread = activeThreads.find((thread) => thread && thread.anchor === addressToIndex(model.sheet, closestThreadAnchor));
-      if (closestThread) {
-        void dispatch([
-          {
-            action: "dxos.org/plugin/thread/action/select",
-            data: {
-              current: fullyQualifiedId(closestThread)
-            }
-          }
-        ]);
-      }
-    }
-  }, [
-    dispatch,
-    activeThreads,
-    activeThreadAddresses,
-    model.sheet
-  ]);
-  const debounced = useMemo(() => {
-    return debounce2((cellCoords) => requestAnimationFrame(() => selectClosestThread(cellCoords)), 50);
-  }, [
-    selectClosestThread
-  ]);
-  useEffect3(() => {
-    if (!cursor) {
-      return;
-    }
-    debounced(cursor);
-  }, [
-    cursor,
-    selectClosestThread
-  ]);
-};
-var createThreadDecoration = (cellIndex, threadId, sheetId) => {
-  return {
-    type: "comment",
-    classNames: [
-      "bg-greenFill"
-    ],
-    cellIndex
-  };
-};
-var useThreadDecorations = (model, decorations) => {
-  const sheet = useMemo(() => model.sheet, [
-    model.sheet
-  ]);
-  const sheetId = useMemo(() => fullyQualifiedId(sheet), [
-    sheet
-  ]);
-  useEffect3(() => {
-    const unsubscribe = effect(() => {
-      const activeThreadAnchors = /* @__PURE__ */ new Set();
-      if (!sheet.threads) {
-        return;
-      }
-      for (const thread of sheet.threads) {
-        if (!thread || thread.anchor === void 0 || thread.status === "resolved") {
-          continue;
-        }
-        activeThreadAnchors.add(thread.anchor);
-        const index = thread.anchor;
-        const existingDecorations = decorations.getDecorationsForCell(index);
-        if (!existingDecorations || !existingDecorations.some((d) => d.type === "comment")) {
-          decorations.addDecoration(index, createThreadDecoration(index, thread.id, sheetId));
-        }
-      }
-      for (const decoration of decorations.getAllDecorations()) {
-        if (decoration.type !== "comment") {
-          continue;
-        }
-        if (!activeThreadAnchors.has(decoration.cellIndex)) {
-          decorations.removeDecoration(decoration.cellIndex, "comment");
-        }
-      }
-    });
-    return () => unsubscribe();
-  });
-};
-
-// packages/plugins/plugin-sheet/src/components/SheetContext/SheetContext.tsx
-import React2, { createContext as createContext2, useContext, useMemo as useMemo2, useState as useState3 } from "react";
-import { invariant as invariant4 } from "@dxos/invariant";
-import { fullyQualifiedId as fullyQualifiedId2 } from "@dxos/react-client/echo";
-import { Grid, useGridContext } from "@dxos/react-ui-grid";
-var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/plugins/plugin-sheet/src/components/SheetContext/SheetContext.tsx";
-var SheetContext = /* @__PURE__ */ createContext2(null);
-var useSheetContext = () => {
-  const context = useContext(SheetContext);
-  invariant4(context, void 0, {
-    F: __dxlog_file3,
-    L: 45,
-    S: void 0,
-    A: [
-      "context",
-      ""
-    ]
-  });
-  return context;
-};
-var SheetProviderImpl = ({ model, onInfo, children, __gridScope }) => {
-  const { id, editing, setEditing } = useGridContext("SheetProvider", __gridScope);
-  const decorations = useMemo2(() => createDecorations(), []);
-  const [cursor, setCursor] = useState3();
-  const [range, setRange] = useState3();
-  useSelectThreadOnCellFocus(model, cursor);
-  useThreadDecorations(model, decorations);
-  return /* @__PURE__ */ React2.createElement(SheetContext.Provider, {
-    value: {
-      id,
-      model,
-      editing,
-      setEditing,
-      cursor,
-      setCursor,
-      range,
-      setRange,
-      // TODO(burdon): Change to event.
-      onInfo,
-      decorations
-    }
-  }, children);
-};
-var SheetProvider = ({ children, graph, sheet, readonly, onInfo }) => {
-  const model = useSheetModel(graph, sheet, {
-    readonly
-  });
-  return !model ? null : /* @__PURE__ */ React2.createElement(Grid.Root, {
-    id: fullyQualifiedId2(sheet)
-  }, /* @__PURE__ */ React2.createElement(SheetProviderImpl, {
-    model,
-    onInfo
-  }, children));
-};
-
-// packages/plugins/plugin-sheet/src/components/GridSheet/GridSheet.tsx
-var initialCells = {
-  grid: {},
-  frozenColsStart: [
-    ...Array(64)
-  ].reduce((acc, _, i) => {
-    acc[`0,${i}`] = rowLabelCell(i);
-    return acc;
-  }, {}),
-  frozenRowsStart: [
-    ...Array(12)
-  ].reduce((acc, _, i) => {
-    acc[`${i},0`] = colLabelCell(i);
-    return acc;
-  }, {})
-};
-var frozen = {
-  frozenColsStart: 1,
-  frozenRowsStart: 1
-};
-var sheetRowDefault = {
-  grid: {
-    size: 32,
-    resizeable: true
-  }
-};
-var sheetColDefault = {
-  frozenColsStart: {
-    size: 48
-  },
-  grid: {
-    size: 180,
-    resizeable: true
-  }
-};
-var GridSheet = () => {
-  const { id, model, editing, setEditing, setCursor, setRange } = useSheetContext();
-  const dxGrid = useRef(null);
-  const rangeNotifier = useRef();
-  const { hasAttention } = useAttention(id);
-  const handleFocus = useCallback2((event) => {
-    if (!editing) {
-      const cell = closestCell(event.target);
-      if (cell && cell.plane === "grid") {
-        setCursor({
-          col: cell.col,
-          row: cell.row
-        });
-      }
-    }
-  }, [
-    editing
-  ]);
-  const handleClose = useCallback2((value, { key, shift }) => {
-    if (value !== void 0) {
-      model.setValue(dxGridCellIndexToSheetCellAddress(editing.index), value);
-    }
-    setEditing(null);
-    const axis = [
-      "Enter",
-      "ArrowUp",
-      "ArrowDown"
-    ].includes(key) ? "row" : [
-      "Tab",
-      "ArrowLeft",
-      "ArrowRight"
-    ].includes(key) ? "col" : void 0;
-    const delta = key.startsWith("Arrow") ? [
-      "ArrowUp",
-      "ArrowLeft"
-    ].includes(key) ? -1 : 1 : shift ? -1 : 1;
-    dxGrid.current?.refocus(axis, delta);
-  }, [
-    model,
-    editing,
-    setEditing
-  ]);
-  const handleAxisResize = useCallback2(({ axis, size, index: numericIndex }) => {
-    if (axis === "row") {
-      const rowId = model.sheet.rows[parseInt(numericIndex)];
-      model.sheet.rowMeta[rowId] ??= {};
-      model.sheet.rowMeta[rowId].size = size;
-    } else {
-      const columnId = model.sheet.columns[parseInt(numericIndex)];
-      model.sheet.columnMeta[columnId] ??= {};
-      model.sheet.columnMeta[columnId].size = size;
-    }
-  }, [
-    model
-  ]);
-  const handleSelect = useCallback2(({ minCol, maxCol, minRow, maxRow }) => {
-    const range = {
-      from: {
-        col: minCol,
-        row: minRow
-      }
-    };
-    if (minCol !== maxCol || minRow !== maxRow) {
-      range.to = {
-        col: maxCol,
-        row: maxRow
-      };
-    }
-    if (editing) {
-      rangeNotifier.current?.(rangeToA1Notation(range));
-    } else {
-      setRange(range.to ? range : void 0);
-    }
-  }, [
-    editing
-  ]);
-  const handleWheel = useCallback2((event) => {
-    if (!hasAttention) {
-      event.stopPropagation();
-    }
-  }, [
-    hasAttention
-  ]);
-  const { columns, rows } = useSheetModelDxGridProps(dxGrid, model);
-  const extension = useMemo3(() => [
-    editorKeys({
-      onClose: handleClose,
-      ...editing?.initialContent && {
-        onNav: handleClose
-      }
-    }),
-    sheetExtension({
-      functions: model.graph.getFunctions()
-    }),
-    rangeExtension((fn) => rangeNotifier.current = fn)
-  ], [
-    model,
-    handleClose,
-    editing
-  ]);
-  const getCellContent = useCallback2((index) => {
-    const cell = dxGridCellIndexToSheetCellAddress(index);
-    return model.getCellText(cell);
-  }, [
-    model
-  ]);
-  useUpdateFocusedCellOnThreadSelection(model, dxGrid);
-  return /* @__PURE__ */ React3.createElement(React3.Fragment, null, /* @__PURE__ */ React3.createElement(GridCellEditor, {
-    getCellContent,
-    extension
-  }), /* @__PURE__ */ React3.createElement(Grid2.Content, {
-    initialCells,
-    limitColumns: DEFAULT_COLUMNS,
-    limitRows: DEFAULT_ROWS,
-    columns,
-    rows,
-    onAxisResize: handleAxisResize,
-    onSelect: handleSelect,
-    rowDefault: sheetRowDefault,
-    columnDefault: sheetColDefault,
-    frozen,
-    onFocus: handleFocus,
-    onWheelCapture: handleWheel,
-    className: "[--dx-grid-base:var(--surface-bg)]",
-    ref: dxGrid
-  }));
-};
-
-// packages/plugins/plugin-sheet/src/components/index.ts
-var SheetContainer = React4.lazy(() => import("./SheetContainer-YWQVKHQB.mjs"));
-
-// packages/plugins/plugin-sheet/src/hooks/useComputeGraph.ts
-var useComputeGraph = (space) => {
-  const { registry } = useContext2(ComputeGraphContext) ?? raise(new Error("Missing ComputeGraphContext"));
-  const [graph] = useAsyncState(async () => {
-    if (space) {
-      const graph2 = registry.getOrCreateGraph(space);
-      await graph2.open();
-      return graph2;
-    }
-  }, [
-    space,
-    registry
-  ]);
-  return graph;
-};
-
-export {
-  ComputeGraphContextProvider,
-  addressToA1Notation,
-  rangeToA1Notation,
-  inRange,
-  createSheet,
-  addressToIndex,
-  compareIndexPositions,
-  computeGraphFacet,
-  useComputeGraph,
-  useSheetContext,
-  SheetProvider,
-  GridSheet,
-  SheetContainer
-};
-//# sourceMappingURL=chunk-BPXXIAOQ.mjs.map