@dxos/plugin-sheet 0.8.4-main.bc674ce → 0.8.4-main.bcb3aa67d6

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

@@ -1,1474 +0,0 @@
-import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
-import {
-  rangeExtension,
-  sheetExtension
-} from "./chunk-PPOYR7DK.mjs";
-import {
-  DEFAULT_COLS,
-  DEFAULT_ROWS,
-  MAX_COLS,
-  MAX_ROWS,
-  ReadonlyException,
-  SheetOperation,
-  Sheet_exports,
-  addressFromIndex,
-  addressToIndex,
-  cellClassNameForRange,
-  initialize,
-  insertIndices,
-  mapFormulaIndicesToRefs,
-  mapFormulaRefsToIndices,
-  meta,
-  rangeFromIndex
-} from "./chunk-6J5L47IB.mjs";
-
-// src/components/ComputeGraph/ComputeGraphContextProvider.tsx
-import React, { createContext, useContext } from "react";
-import { raise } from "@dxos/debug";
-import { useAsyncState } from "@dxos/react-hooks";
-var ComputeGraphContext = /* @__PURE__ */ createContext(void 0);
-var ComputeGraphContextProvider = ({ registry, children }) => {
-  return /* @__PURE__ */ React.createElement(ComputeGraphContext.Provider, {
-    value: {
-      registry
-    }
-  }, children);
-};
-var useComputeGraph = (space) => {
-  const { registry } = useContext(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;
-};
-
-// src/components/RangeList/RangeList.tsx
-import * as Schema from "effect/Schema";
-import React2, { useCallback } from "react";
-import { rangeToA1Notation } from "@dxos/compute";
-import { Obj } from "@dxos/echo";
-import { Callout, useTranslation } from "@dxos/react-ui";
-import { List } from "@dxos/react-ui-list";
-import { ghostHover } from "@dxos/ui-theme";
-var RangeList = ({ sheet }) => {
-  const { t } = useTranslation(meta.id);
-  const handleSelectRange = (range) => {
-  };
-  const handleDeleteRange = useCallback((range) => {
-    const index = sheet.ranges.findIndex((sheetRange) => sheetRange === range);
-    Obj.change(sheet, (s) => {
-      s.ranges.splice(index, 1);
-    });
-  }, [
-    sheet
-  ]);
-  return /* @__PURE__ */ React2.createElement(React2.Fragment, null, /* @__PURE__ */ React2.createElement("h2", {
-    className: "mbs-cardSpacingBlock mbe-labelSpacingBlock text-sm font-semibold"
-  }, t("range list heading")), sheet.ranges.length < 1 ? /* @__PURE__ */ React2.createElement(Callout.Root, null, /* @__PURE__ */ React2.createElement(Callout.Title, null, t("no ranges message"))) : /* @__PURE__ */ React2.createElement(List.Root, {
-    items: sheet.ranges,
-    isItem: Schema.is(Sheet_exports.Range)
-  }, ({ items: ranges }) => ranges.map((range, i) => /* @__PURE__ */ React2.createElement(List.Item, {
-    key: i,
-    item: range,
-    classNames: [
-      "p-2",
-      ghostHover
-    ]
-  }, /* @__PURE__ */ React2.createElement(List.ItemDragHandle, null), /* @__PURE__ */ React2.createElement(List.ItemTitle, {
-    onClick: () => handleSelectRange(range)
-  }, t("range title", {
-    position: rangeToA1Notation(rangeFromIndex(sheet, range.range)),
-    key: t(`range key ${range.key} label`),
-    value: t(`range value ${range.value} label`)
-  })), /* @__PURE__ */ React2.createElement(List.ItemDeleteButton, {
-    onClick: () => handleDeleteRange(range)
-  })))));
-};
-
-// src/components/index.ts
-import { lazy } from "react";
-
-// src/components/GridSheet/GridSheet.tsx
-import React4, { useCallback as useCallback4, useMemo as useMemo2, useRef, useState as useState4 } from "react";
-import { useOperationInvoker as useOperationInvoker2 } from "@dxos/app-framework/react";
-import { rangeToA1Notation as rangeToA1Notation2 } from "@dxos/compute";
-import { Obj as Obj5 } from "@dxos/echo";
-import { defaultColSize, defaultRowSize } from "@dxos/lit-grid";
-import { DropdownMenu, Icon, useTranslation as useTranslation2 } from "@dxos/react-ui";
-import { useAttention } from "@dxos/react-ui-attention";
-import { Grid as Grid2, GridCellEditor, closestCell, editorKeys, parseCellIndex } from "@dxos/react-ui-grid";
-
-// src/integrations/thread-ranges.ts
-import * as Effect from "effect/Effect";
-import { useCallback as useCallback2, useEffect, useMemo } from "react";
-import { Common } from "@dxos/app-framework";
-import { useOperationInvoker, useOperationResolver } from "@dxos/app-framework/react";
-import { debounce } from "@dxos/async";
-import { inRange } from "@dxos/compute";
-import { Obj as Obj2, Relation } from "@dxos/echo";
-import { OperationResolver } from "@dxos/operation";
-import { ATTENDABLE_PATH_SEPARATOR, DeckOperation } from "@dxos/plugin-deck/types";
-import { ThreadOperation } from "@dxos/plugin-thread/types";
-import { Filter, Query, useQuery } from "@dxos/react-client/echo";
-import { AnchoredTo, Thread } from "@dxos/types";
-var parseThreadAnchorAsCellRange = (cursor) => {
-  const coords = cursor.split(",");
-  if (coords.length !== 4) {
-    return null;
-  } else {
-    const [fromCol, fromRow, toCol, toRow] = coords;
-    return {
-      from: {
-        col: parseInt(fromCol),
-        row: parseInt(fromRow)
-      },
-      to: {
-        col: parseInt(toCol),
-        row: parseInt(toRow)
-      }
-    };
-  }
-};
-var useUpdateFocusedCellOnThreadSelection = (grid) => {
-  const { model, setActiveRefs } = useSheetContext();
-  const sheetId = Obj2.getDXN(model.sheet).toString();
-  const scrollIntoViewHandler = useMemo(() => OperationResolver.make({
-    operation: Common.LayoutOperation.ScrollIntoView,
-    position: "hoist",
-    filter: (input) => input.subject === sheetId && !!input.cursor,
-    handler: (input) => Effect.sync(() => {
-      const { cursor, ref } = input;
-      if (cursor) {
-        setActiveRefs(ref);
-        const range = parseThreadAnchorAsCellRange(cursor);
-        range && grid?.setFocus({
-          ...range.to,
-          plane: "grid"
-        }, true);
-      }
-    })
-  }), [
-    sheetId,
-    setActiveRefs,
-    grid
-  ]);
-  useOperationResolver(meta.id, scrollIntoViewHandler);
-};
-var useSelectThreadOnCellFocus = () => {
-  const { model, cursor } = useSheetContext();
-  const { invokePromise } = useOperationInvoker();
-  const db = Obj2.getDatabase(model.sheet);
-  const anchors = useQuery(db, Query.select(Filter.id(model.sheet.id)).targetOf(AnchoredTo.AnchoredTo));
-  const selectClosestThread = useCallback2((cellAddress) => {
-    if (!cellAddress) {
-      return;
-    }
-    const closestThread = anchors.find((anchor) => {
-      const source = Relation.getSource(anchor);
-      if (anchor.anchor && Obj2.instanceOf(Thread.Thread, source)) {
-        const range = parseThreadAnchorAsCellRange(anchor.anchor);
-        return range ? inRange(range, cellAddress) : false;
-      } else {
-        return false;
-      }
-    });
-    if (closestThread) {
-      const primary = Obj2.getDXN(model.sheet).toString();
-      void (async () => {
-        await invokePromise(ThreadOperation.Select, {
-          current: Relation.getDXN(closestThread).toString()
-        });
-        await invokePromise(DeckOperation.ChangeCompanion, {
-          primary,
-          companion: `${primary}${ATTENDABLE_PATH_SEPARATOR}comments`
-        });
-      })();
-    }
-  }, [
-    invokePromise,
-    anchors
-  ]);
-  const debounced = useMemo(() => {
-    return debounce((cellCoords) => requestAnimationFrame(() => selectClosestThread(cellCoords)), 50);
-  }, [
-    selectClosestThread
-  ]);
-  useEffect(() => {
-    if (!cursor) {
-      return;
-    }
-    debounced(cursor);
-  }, [
-    cursor,
-    debounced
-  ]);
-};
-
-// src/components/SheetContext/SheetContext.tsx
-import React3, { createContext as createContext2, useCallback as useCallback3, useContext as useContext2, useState as useState2 } from "react";
-import { Obj as Obj4 } from "@dxos/echo";
-import { invariant as invariant2 } from "@dxos/invariant";
-import { Grid, useGridContext } from "@dxos/react-ui-grid";
-
-// src/model/sheet-model.ts
-import { Event } from "@dxos/async";
-import { DetailedCellError, ExportedCellChange, addressFromA1Notation, addressToA1Notation, createSheetName, isFormula } from "@dxos/compute";
-import { Resource } from "@dxos/context";
-import { Obj as Obj3 } from "@dxos/echo";
-import { Format, TypeEnum } from "@dxos/echo/internal";
-import { invariant } from "@dxos/invariant";
-import { PublicKey } from "@dxos/keys";
-import { log } from "@dxos/log";
-var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-sheet/src/model/sheet-model.ts";
-var typeMap = {
-  BOOLEAN: {
-    type: TypeEnum.Boolean
-  },
-  NUMBER_RAW: {
-    type: TypeEnum.Number
-  },
-  NUMBER_PERCENT: {
-    type: TypeEnum.Number,
-    format: Format.TypeFormat.Percent
-  },
-  NUMBER_CURRENCY: {
-    type: TypeEnum.Number,
-    format: Format.TypeFormat.Currency
-  },
-  NUMBER_DATETIME: {
-    type: TypeEnum.String,
-    format: Format.TypeFormat.DateTime
-  },
-  NUMBER_DATE: {
-    type: TypeEnum.String,
-    format: Format.TypeFormat.Date
-  },
-  NUMBER_TIME: {
-    type: TypeEnum.String,
-    format: Format.TypeFormat.Time
-  }
-};
-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 {
-  _graph;
-  _sheet;
-  _options;
-  id = `model-${PublicKey.random().truncate()}`;
-  // Wraps compute node.
-  update = new Event();
-  _node;
-  constructor(_graph, _sheet, _options = {}) {
-    super(), this._graph = _graph, this._sheet = _sheet, this._options = _options;
-  }
-  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_file,
-      L: 124,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    Obj3.change(this._sheet, (s) => {
-      initialize(s);
-    });
-    this._graph.update.on((event) => {
-      if (event.type === "functionsUpdated") {
-        this.reset();
-      }
-    });
-    this._node = this._graph.getOrCreateNode(createSheetName({
-      type: Obj3.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() {
-    invariant(this._node, void 0, {
-      F: __dxlog_file,
-      L: 154,
-      S: this,
-      A: [
-        "this._node",
-        ""
-      ]
-    });
-    this._node.graph.hf.clearSheet(this._node.sheetId);
-    Object.entries(this._sheet.cells).forEach(([key, { value }]) => {
-      invariant(this._node, void 0, {
-        F: __dxlog_file,
-        L: 157,
-        S: this,
-        A: [
-          "this._node",
-          ""
-        ]
-      });
-      const { col, row } = addressFromIndex(this._sheet, key);
-      if (isFormula(value)) {
-        const binding = this._graph.mapFunctionBindingFromId(mapFormulaIndicesToRefs(this._sheet, value));
-        if (binding) {
-          value = this._graph.mapFormulaToNative(binding);
-        } else {
-          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) {
-    let idx = [];
-    Obj3.change(this._sheet, (s) => {
-      idx = insertIndices(s.rows, i, n, MAX_ROWS);
-    });
-    this.reset();
-    return idx;
-  }
-  insertColumns(i, n = 1) {
-    let idx = [];
-    Obj3.change(this._sheet, (s) => {
-      idx = insertIndices(s.columns, i, n, MAX_COLS);
-    });
-    this.reset();
-    return idx;
-  }
-  dropRow(rowIndex) {
-    const range = {
-      from: addressFromIndex(this._sheet, `${this._sheet.columns[0]}@${rowIndex}`),
-      to: addressFromIndex(this._sheet, `${this._sheet.columns[this._sheet.columns.length - 1]}@${rowIndex}`)
-    };
-    const values = this.getCellValues(range).flat();
-    const index = this._sheet.rows.indexOf(rowIndex);
-    this.clear(range);
-    Obj3.change(this._sheet, (s) => {
-      s.rows.splice(index, 1);
-      delete s.rowMeta[rowIndex];
-    });
-    this.reset();
-    return {
-      axis: "row",
-      index,
-      axisIndex: rowIndex,
-      axisMeta: this._sheet.rowMeta[rowIndex],
-      values
-    };
-  }
-  dropColumn(colIndex) {
-    const range = {
-      from: addressFromIndex(this._sheet, `${colIndex}@${this._sheet.rows[0]}`),
-      to: addressFromIndex(this._sheet, `${colIndex}@${this._sheet.rows[this._sheet.rows.length - 1]}`)
-    };
-    const values = this.getCellValues(range).flat();
-    const index = this._sheet.columns.indexOf(colIndex);
-    this.clear(range);
-    Obj3.change(this._sheet, (s) => {
-      s.columns.splice(index, 1);
-      delete s.columnMeta[colIndex];
-    });
-    this.reset();
-    return {
-      axis: "col",
-      index,
-      axisIndex: colIndex,
-      axisMeta: this._sheet.rowMeta[colIndex],
-      values
-    };
-  }
-  restoreRow({ index, axisIndex, axisMeta, values }) {
-    Obj3.change(this._sheet, (s) => {
-      s.rows.splice(index, 0, axisIndex);
-      values.forEach((value, col) => {
-        if (value) {
-          s.cells[`${s.columns[col]}@${axisIndex}`] = {
-            value
-          };
-        }
-      });
-      if (axisMeta) {
-        s.rowMeta[axisIndex] = axisMeta;
-      }
-    });
-    this.reset();
-  }
-  restoreColumn({ index, axisIndex, axisMeta, values }) {
-    Obj3.change(this._sheet, (s) => {
-      s.columns.splice(index, 0, axisIndex);
-      values.forEach((value, row) => {
-        if (value) {
-          s.cells[`${axisIndex}@${s.rows[row]}`] = {
-            value
-          };
-        }
-      });
-      if (axisMeta) {
-        s.columnMeta[axisIndex] = axisMeta;
-      }
-    });
-    this.reset();
-  }
-  //
-  // Undoable actions.
-  // TODO(burdon): Group undoable methods; consistently update hf/sheet.
-  //
-  /**
-  * Clear range of values.
-  */
-  clear(range) {
-    invariant(this._node, void 0, {
-      F: __dxlog_file,
-      L: 274,
-      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);
-    Obj3.change(this._sheet, (s) => {
-      this._iterRange(range, (cell) => {
-        const idx = addressToIndex(this._sheet, cell);
-        delete s.cells[idx];
-      });
-    });
-  }
-  cut(range) {
-    invariant(this._node, void 0, {
-      F: __dxlog_file,
-      L: 287,
-      S: this,
-      A: [
-        "this._node",
-        ""
-      ]
-    });
-    this._node.graph.hf.cut(toModelRange(this._node.sheetId, range));
-    Obj3.change(this._sheet, (s) => {
-      this._iterRange(range, (cell) => {
-        const idx = addressToIndex(this._sheet, cell);
-        delete s.cells[idx];
-      });
-    });
-  }
-  copy(range) {
-    invariant(this._node, void 0, {
-      F: __dxlog_file,
-      L: 298,
-      S: this,
-      A: [
-        "this._node",
-        ""
-      ]
-    });
-    this._node.graph.hf.copy(toModelRange(this._node.sheetId, range));
-  }
-  paste(cell) {
-    invariant(this._node, void 0, {
-      F: __dxlog_file,
-      L: 303,
-      S: this,
-      A: [
-        "this._node",
-        ""
-      ]
-    });
-    if (!this._node.graph.hf.isClipboardEmpty()) {
-      const changes = this._node.graph.hf.paste(toSimpleCellAddress(this._node.sheetId, cell));
-      Obj3.change(this._sheet, (s) => {
-        for (const change of changes) {
-          if (change instanceof ExportedCellChange) {
-            const { address, newValue } = change;
-            const idx = addressToIndex(this._sheet, {
-              row: address.row,
-              col: address.col
-            });
-            s.cells[idx] = {
-              value: newValue
-            };
-          }
-        }
-      });
-    }
-  }
-  // TODO(burdon): Display undo/redo state.
-  undo() {
-    invariant(this._node, void 0, {
-      F: __dxlog_file,
-      L: 320,
-      S: this,
-      A: [
-        "this._node",
-        ""
-      ]
-    });
-    if (this._node.graph.hf.isThereSomethingToUndo()) {
-      this._node.graph.hf.undo();
-    }
-  }
-  redo() {
-    invariant(this._node, void 0, {
-      F: __dxlog_file,
-      L: 328,
-      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 (isFormula(value)) {
-      return this._graph.mapFunctionBindingFromId(mapFormulaIndicesToRefs(this._sheet, 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) {
-    invariant(this._node, void 0, {
-      F: __dxlog_file,
-      L: 371,
-      S: this,
-      A: [
-        "this._node",
-        ""
-      ]
-    });
-    const address = toSimpleCellAddress(this._node.sheetId, cell);
-    const value = this._node.graph.hf.getCellValue(address);
-    if (value instanceof DetailedCellError) {
-      log.warn("cell error", {
-        cell,
-        error: value
-      }, {
-        F: __dxlog_file,
-        L: 376,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      return value.toString();
-    }
-    return value;
-  }
-  /**
-  * Get value type.
-  */
-  getValueDescription(cell) {
-    invariant(this._node, void 0, {
-      F: __dxlog_file,
-      L: 387,
-      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) {
-    invariant(this._node, void 0, {
-      F: __dxlog_file,
-      L: 397,
-      S: this,
-      A: [
-        "this._node",
-        ""
-      ]
-    });
-    if (this._options.readonly) {
-      throw new ReadonlyException();
-    }
-    let refresh = false;
-    if (cell.row >= this._sheet.rows.length) {
-      Obj3.change(this._sheet, (s) => {
-        insertIndices(s.rows, cell.row, 1, MAX_ROWS);
-      });
-      refresh = true;
-    }
-    if (cell.col >= this._sheet.columns.length) {
-      Obj3.change(this._sheet, (s) => {
-        insertIndices(s.columns, cell.col, 1, MAX_COLS);
-      });
-      refresh = true;
-    }
-    if (refresh) {
-      this.reset();
-    }
-    this._node.graph.hf.setCellContents({
-      sheet: this._node.sheetId,
-      row: cell.row,
-      col: cell.col
-    }, [
-      [
-        isFormula(value) ? this._graph.mapFormulaToNative(value) : value
-      ]
-    ]);
-    const idx = addressToIndex(this._sheet, cell);
-    if (value === void 0 || value === null) {
-      Obj3.change(this._sheet, (s) => {
-        delete s.cells[idx];
-      });
-    } else {
-      if (isFormula(value)) {
-        value = this._graph.mapFunctionBindingToId(mapFormulaRefsToIndices(this._sheet, value));
-      }
-      Obj3.change(this._sheet, (s) => {
-        s.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");
-  }
-  /**
-  * Map from indices to A1 notation.
-  */
-  mapFormulaIndicesToRefs(formula) {
-    invariant(isFormula(formula), void 0, {
-      F: __dxlog_file,
-      L: 490,
-      S: this,
-      A: [
-        "isFormula(formula)",
-        ""
-      ]
-    });
-    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) {
-    invariant(this._node, void 0, {
-      F: __dxlog_file,
-      L: 511,
-      S: this,
-      A: [
-        "this._node",
-        ""
-      ]
-    });
-    return this._node.graph.hf.numberToDateTime(num);
-  }
-  toDate(num) {
-    invariant(this._node, void 0, {
-      F: __dxlog_file,
-      L: 516,
-      S: this,
-      A: [
-        "this._node",
-        ""
-      ]
-    });
-    return this._node.graph.hf.numberToDate(num);
-  }
-  toTime(num) {
-    invariant(this._node, void 0, {
-      F: __dxlog_file,
-      L: 521,
-      S: this,
-      A: [
-        "this._node",
-        ""
-      ]
-    });
-    return this._node.graph.hf.numberToTime(num);
-  }
-};
-
-// src/model/useSheetModel.ts
-import { useEffect as useEffect2, useState } from "react";
-var useSheetModel = (graph, sheet, { readonly } = {}) => {
-  const [model, setModel] = useState();
-  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;
-};
-
-// src/components/SheetContext/SheetContext.tsx
-var __dxlog_file2 = "/__w/dxos/dxos/packages/plugins/plugin-sheet/src/components/SheetContext/SheetContext.tsx";
-var SheetContext = /* @__PURE__ */ createContext2(void 0);
-var useSheetContext = () => {
-  const context = useContext2(SheetContext);
-  invariant2(context, void 0, {
-    F: __dxlog_file2,
-    L: 54,
-    S: void 0,
-    A: [
-      "context",
-      ""
-    ]
-  });
-  return context;
-};
-var SheetProviderImpl = ({ __gridScope, children, ignoreAttention, model, onInfo }) => {
-  const { id, editing, setEditing } = useGridContext("SheetProvider", __gridScope);
-  const [cursor, setCursorInternal] = useState2();
-  const [range, setRangeInternal] = useState2();
-  const [cursorFallbackRange, setCursorFallbackRange] = useState2();
-  const [activeRefs, setActiveRefs] = useState2("");
-  const setCursor = useCallback3((nextCursor) => {
-    setCursorInternal(nextCursor);
-    setCursorFallbackRange(range?.to ? range : nextCursor ? {
-      from: nextCursor,
-      to: nextCursor
-    } : void 0);
-  }, [
-    range
-  ]);
-  const setRange = useCallback3((nextRange) => {
-    setRangeInternal(nextRange);
-    setCursorFallbackRange(nextRange?.to ? nextRange : cursor ? {
-      from: cursor,
-      to: cursor
-    } : void 0);
-  }, [
-    cursor
-  ]);
-  return /* @__PURE__ */ React3.createElement(SheetContext.Provider, {
-    value: {
-      id,
-      model,
-      editing,
-      setEditing,
-      cursor,
-      setCursor,
-      range,
-      setRange,
-      cursorFallbackRange,
-      activeRefs,
-      setActiveRefs,
-      // TODO(burdon): Change to event.
-      onInfo,
-      ignoreAttention
-    }
-  }, children);
-};
-var SheetProvider = ({ children, graph, sheet, readonly, ignoreAttention, onInfo }) => {
-  const model = useSheetModel(graph, sheet, {
-    readonly
-  });
-  return !model ? null : /* @__PURE__ */ React3.createElement(Grid.Root, {
-    id: Obj4.getDXN(sheet).toString()
-  }, /* @__PURE__ */ React3.createElement(SheetProviderImpl, {
-    model,
-    onInfo,
-    ignoreAttention
-  }, children));
-};
-
-// src/components/GridSheet/util.ts
-import { useEffect as useEffect3, useState as useState3 } from "react";
-import { inRange as inRange2 } from "@dxos/compute";
-import { createDocAccessor } from "@dxos/echo-db";
-import { cellClassesForFieldType, parseValue } from "@dxos/react-ui-form";
-import { colToA1Notation, commentedClassName, rowToA1Notation } from "@dxos/react-ui-grid";
-import { mx } from "@dxos/ui-theme";
-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);
-  const ranges = model.sheet.ranges?.filter(({ range }) => inRange2(rangeFromIndex(model.sheet, range), address));
-  const threadRefs = void 0;
-  const description = model.getValueDescription(address);
-  const type = description?.type;
-  const format = description?.format;
-  const classNames = ranges?.map(cellClassNameForRange).reverse();
-  return {
-    value: parseValue({
-      type,
-      format,
-      value: rawValue
-    }),
-    className: mx(cellClassesForFieldType({
-      type,
-      format
-    }), threadRefs && commentedClassName, classNames),
-    dataRefs: threadRefs
-  };
-};
-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;
-        cachedGridCells[`${col},${row}`] = projectCellProps(model, col, row);
-      });
-    });
-    return cachedGridCells;
-  };
-};
-var rowLabelCell = (row) => ({
-  value: rowToA1Notation(row),
-  className: "!bg-toolbarSurface text-subdued text-end pie-1",
-  resizeHandle: "row"
-});
-var colLabelCell = (col) => ({
-  value: colToA1Notation(col),
-  className: "!bg-toolbarSurface text-subdued",
-  resizeHandle: "col"
-});
-var cellGetter = (model) => {
-  const getGridCells = gridCellGetter(model);
-  return (nextBounds, plane) => {
-    switch (plane) {
-      case "grid":
-        return getGridCells(nextBounds);
-      case "fixedStartStart": {
-        return {
-          "0,0": {
-            className: "!bg-toolbarSurface"
-          }
-        };
-      }
-      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 = (dxGrid, model) => {
-  const [columns, setColumns] = useState3(createDxGridColumns(model));
-  const [rows, setRows] = useState3(createDxGridRows(model));
-  useEffect3(() => {
-    const cellsAccessor = createDocAccessor(model.sheet, [
-      "cells"
-    ]);
-    if (dxGrid) {
-      dxGrid.getCells = cellGetter(model);
-    }
-    const handleCellsUpdate = () => {
-      dxGrid?.requestUpdate("initialCells");
-    };
-    cellsAccessor.handle.addListener("change", handleCellsUpdate);
-    const unsubscribe = model.graph.update.on(handleCellsUpdate);
-    return () => {
-      cellsAccessor.handle.removeListener("change", handleCellsUpdate);
-      unsubscribe();
-    };
-  }, [
-    model,
-    dxGrid
-  ]);
-  useEffect3(() => {
-    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,
-    dxGrid
-  ]);
-  return {
-    columns,
-    rows
-  };
-};
-
-// src/components/GridSheet/GridSheet.tsx
-var inertPosition = {
-  plane: "grid",
-  col: 0,
-  row: 0
-};
-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 sheetColDefault = {
-  frozenColsStart: {
-    size: 48,
-    readonly: true,
-    focusUnfurl: false
-  },
-  grid: {
-    size: defaultColSize,
-    resizeable: true
-  }
-};
-var sheetRowDefault = {
-  frozenRowsStart: {
-    size: defaultRowSize,
-    readonly: true,
-    focusUnfurl: false
-  },
-  grid: {
-    size: defaultRowSize,
-    resizeable: true
-  }
-};
-var GridSheet = () => {
-  const { t } = useTranslation2(meta.id);
-  const { id, model, editing, setCursor, setRange, cursor, cursorFallbackRange, activeRefs, ignoreAttention } = useSheetContext();
-  const [dxGrid, setDxGrid] = useState4(null);
-  const [extraplanarFocus, setExtraplanarFocus] = useState4(null);
-  const { invokePromise } = useOperationInvoker2();
-  const rangeController = useRef(null);
-  const { hasAttention } = useAttention(id);
-  const handleFocus = useCallback4((event) => {
-    if (!editing) {
-      const cell = closestCell(event.target);
-      if (cell) {
-        if (cell.plane === "grid") {
-          setCursor({
-            col: cell.col,
-            row: cell.row
-          });
-          setExtraplanarFocus(null);
-        } else {
-          setExtraplanarFocus(cell);
-        }
-      } else {
-        setExtraplanarFocus(null);
-      }
-    }
-  }, [
-    editing
-  ]);
-  const handleClose = useCallback4((_value, event) => {
-    if (event) {
-      const { key, shift } = event;
-      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?.refocus(axis, delta);
-    }
-  }, [
-    model,
-    editing,
-    dxGrid
-  ]);
-  const handleBlur = useCallback4((value) => {
-    if (value !== void 0) {
-      model.setValue(parseCellIndex(editing.index), value);
-    }
-  }, [
-    model,
-    editing
-  ]);
-  const handleAxisResize = useCallback4(({ axis, size, index: numericIndex }) => {
-    Obj5.change(model.sheet, (sheet) => {
-      if (axis === "row") {
-        const rowId = sheet.rows[parseInt(numericIndex)];
-        sheet.rowMeta[rowId] ??= {};
-        sheet.rowMeta[rowId].size = size;
-      } else {
-        const columnId = sheet.columns[parseInt(numericIndex)];
-        sheet.columnMeta[columnId] ??= {};
-        sheet.columnMeta[columnId].size = size;
-      }
-    });
-  }, [
-    model
-  ]);
-  const handleSelect = useCallback4(({ minCol, maxCol, minRow, maxRow }) => {
-    const range = {
-      from: {
-        col: minCol,
-        row: minRow
-      }
-    };
-    if (minCol !== maxCol || minRow !== maxRow) {
-      range.to = {
-        col: maxCol,
-        row: maxRow
-      };
-    }
-    if (editing) {
-      rangeController.current?.setRange(rangeToA1Notation2(range));
-    } else {
-      setRange(range.to ? range : void 0);
-    }
-  }, [
-    editing
-  ]);
-  const handleWheel = useCallback4((event) => {
-    if (!ignoreAttention && !hasAttention) {
-      event.stopPropagation();
-    }
-  }, [
-    hasAttention,
-    ignoreAttention
-  ]);
-  const selectEntireAxis = useCallback4((pos) => {
-    switch (pos.plane) {
-      case "frozenRowsStart":
-        return dxGrid?.setSelection({
-          start: {
-            col: pos.col,
-            row: 0,
-            plane: "grid"
-          },
-          end: {
-            col: pos.col,
-            row: model.sheet.rows.length - 1,
-            plane: "grid"
-          }
-        });
-      case "frozenColsStart":
-        return dxGrid?.setSelection({
-          start: {
-            row: pos.row,
-            col: 0,
-            plane: "grid"
-          },
-          end: {
-            row: pos.row,
-            col: model.sheet.columns.length - 1,
-            plane: "grid"
-          }
-        });
-    }
-  }, [
-    dxGrid,
-    model.sheet
-  ]);
-  const handleClick = useCallback4((event) => {
-    const cell = closestCell(event.target);
-    if (cell) {
-      selectEntireAxis(cell);
-    }
-  }, [
-    selectEntireAxis
-  ]);
-  const handleKeyDown = useCallback4((event) => {
-    switch (event.key) {
-      case "Backspace":
-      case "Delete":
-        event.preventDefault();
-        return cursorFallbackRange && model.clear(cursorFallbackRange);
-      case "Enter":
-      case "Space":
-        if (dxGrid && extraplanarFocus) {
-          switch (extraplanarFocus.plane) {
-            case "frozenRowsStart":
-            case "frozenColsStart":
-              event.preventDefault();
-              return selectEntireAxis(extraplanarFocus);
-          }
-        }
-    }
-    if (event.metaKey || event.ctrlKey) {
-      switch (event.key) {
-        case "x":
-        case "X":
-          event.preventDefault();
-          return cursorFallbackRange && model.cut(cursorFallbackRange);
-        case "c":
-        case "C":
-          event.preventDefault();
-          return cursorFallbackRange && model.copy(cursorFallbackRange);
-        case "v":
-        case "V":
-          event.preventDefault();
-          return cursor && model.paste(cursor);
-        case "z":
-          event.preventDefault();
-          return event.shiftKey ? model.redo() : model.undo();
-        case "Z":
-        case "y":
-          event.preventDefault();
-          return model.redo();
-      }
-    }
-  }, [
-    cursorFallbackRange,
-    model,
-    cursor,
-    extraplanarFocus,
-    selectEntireAxis
-  ]);
-  const contextMenuAnchorRef = useRef(null);
-  const [contextMenuOpen, setContextMenuOpen] = useState4(null);
-  const contextMenuAxis = contextMenuOpen?.plane.startsWith("frozenRows") ? "col" : "row";
-  const handleContextMenu = useCallback4((event) => {
-    const cell = closestCell(event.target);
-    if (cell && cell.plane.startsWith("frozen")) {
-      event.preventDefault();
-      contextMenuAnchorRef.current = event.target;
-      setContextMenuOpen(cell);
-    }
-  }, []);
-  const handleAxisMenuAction = useCallback4((operation) => {
-    switch (operation) {
-      case "insert-before":
-      case "insert-after":
-        return invokePromise(SheetOperation.InsertAxis, {
-          model,
-          axis: contextMenuAxis,
-          index: contextMenuOpen[contextMenuAxis] + (operation === "insert-before" ? 0 : 1)
-        });
-      case "drop":
-        return invokePromise(SheetOperation.DropAxis, {
-          model,
-          axis: contextMenuAxis,
-          axisIndex: model.sheet[contextMenuAxis === "row" ? "rows" : "columns"][contextMenuOpen[contextMenuAxis]]
-        });
-    }
-  }, [
-    contextMenuAxis,
-    contextMenuOpen,
-    model,
-    invokePromise
-  ]);
-  const { columns, rows } = useSheetModelDxGridProps(dxGrid, model);
-  const extensions = useMemo2(() => [
-    editorKeys({
-      onClose: handleClose,
-      ...editing?.initialContent && {
-        onNav: handleClose
-      }
-    }),
-    sheetExtension({
-      functions: model.graph.getFunctions()
-    }),
-    rangeExtension({
-      onInit: (fn) => rangeController.current = fn,
-      onStateChange: (state) => {
-        if (dxGrid) {
-          dxGrid.mode = typeof state.activeRange === "undefined" ? "edit" : "edit-select";
-        }
-      }
-    })
-  ], [
-    model,
-    handleClose,
-    editing
-  ]);
-  const getCellContent = useCallback4((index) => {
-    return model.getCellText(parseCellIndex(index));
-  }, [
-    model
-  ]);
-  useUpdateFocusedCellOnThreadSelection(dxGrid);
-  useSelectThreadOnCellFocus();
-  return (
-    // TODO(thure): Why are Table’s and Sheet’s editor boxes off by 1px?
-    /* @__PURE__ */ React4.createElement("div", {
-      role: "none",
-      className: "relative min-bs-0 [&_.cm-editor]:!border-lb [&_.cm-editor]:!border-transparent"
-    }, /* @__PURE__ */ React4.createElement(GridCellEditor, {
-      getCellContent,
-      extensions,
-      onBlur: handleBlur
-    }), /* @__PURE__ */ React4.createElement(Grid2.Content, {
-      initialCells,
-      limitColumns: DEFAULT_COLS,
-      limitRows: DEFAULT_ROWS,
-      columns,
-      rows,
-      // TODO(burdon): `col` vs. `column`?
-      columnDefault: sheetColDefault,
-      rowDefault: sheetRowDefault,
-      frozen,
-      onAxisResize: handleAxisResize,
-      onSelect: handleSelect,
-      onFocus: handleFocus,
-      onWheelCapture: handleWheel,
-      onKeyDown: handleKeyDown,
-      onContextMenu: handleContextMenu,
-      onClick: handleClick,
-      overscroll: "trap",
-      className: "[--dx-grid-base:var(--baseSurface)] [&_.dx-grid]:absolute [&_.dx-grid]:inset-0",
-      activeRefs,
-      ref: setDxGrid
-    }), /* @__PURE__ */ React4.createElement(DropdownMenu.Root, {
-      modal: false,
-      open: !!contextMenuOpen,
-      onOpenChange: (nextOpen) => setContextMenuOpen(nextOpen ? inertPosition : null)
-    }, /* @__PURE__ */ React4.createElement(DropdownMenu.VirtualTrigger, {
-      virtualRef: contextMenuAnchorRef
-    }), /* @__PURE__ */ React4.createElement(DropdownMenu.Content, {
-      side: contextMenuAxis === "col" ? "bottom" : "right",
-      sideOffset: 4,
-      collisionPadding: 8
-    }, /* @__PURE__ */ React4.createElement(DropdownMenu.Viewport, null, /* @__PURE__ */ React4.createElement(DropdownMenu.Item, {
-      onClick: () => handleAxisMenuAction("insert-before"),
-      "data-testid": `grid.${contextMenuAxis}.insert-before`
-    }, /* @__PURE__ */ React4.createElement(Icon, {
-      size: 5,
-      icon: contextMenuAxis === "col" ? "ph--columns-plus-left--regular" : "ph--rows-plus-top--regular"
-    }), /* @__PURE__ */ React4.createElement("span", null, t(`add ${contextMenuAxis} before label`))), /* @__PURE__ */ React4.createElement(DropdownMenu.Item, {
-      onClick: () => handleAxisMenuAction("insert-after"),
-      "data-testid": `grid.${contextMenuAxis}.insert-after`
-    }, /* @__PURE__ */ React4.createElement(Icon, {
-      size: 5,
-      icon: contextMenuAxis === "col" ? "ph--columns-plus-right--regular" : "ph--rows-plus-bottom--regular"
-    }), /* @__PURE__ */ React4.createElement("span", null, t(`add ${contextMenuAxis} after label`))), /* @__PURE__ */ React4.createElement(DropdownMenu.Item, {
-      onClick: () => handleAxisMenuAction("drop"),
-      "data-testid": `grid.${contextMenuAxis}.drop`
-    }, /* @__PURE__ */ React4.createElement(Icon, {
-      size: 5,
-      icon: "ph--backspace--regular"
-    }), /* @__PURE__ */ React4.createElement("span", null, t(`delete ${contextMenuAxis} label`)))), /* @__PURE__ */ React4.createElement(DropdownMenu.Arrow, null))))
-  );
-};
-
-// src/components/index.ts
-var SheetContainer = lazy(() => import("./SheetContainer-OGSSDOZU.mjs"));
-
-export {
-  ComputeGraphContextProvider,
-  useComputeGraph,
-  useSheetContext,
-  SheetProvider,
-  GridSheet,
-  RangeList,
-  SheetContainer
-};
-//# sourceMappingURL=chunk-Y4V6HVHO.mjs.map