@dxos/plugin-sheet 0.7.4 → 0.7.5-main.937ce75

package/dist/lib/node/chunk-TQOJ7DG2.cjs

@@ -0,0 +1,935 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var chunk_TQOJ7DG2_exports = {};
+__export(chunk_TQOJ7DG2_exports, {
+  ApiError: () => ApiError,
+  CellValue: () => CellValue,
+  DEFAULT_COLS: () => DEFAULT_COLS,
+  DEFAULT_ROWS: () => DEFAULT_ROWS,
+  MAX_COLS: () => MAX_COLS,
+  MAX_ROWS: () => MAX_ROWS,
+  Range: () => Range,
+  RangeException: () => RangeException,
+  ReadonlyException: () => ReadonlyException,
+  RowColumnMeta: () => RowColumnMeta,
+  SheetAction: () => SheetAction,
+  SheetType: () => SheetType,
+  addressFromIndex: () => addressFromIndex,
+  addressToIndex: () => addressToIndex,
+  alignKey: () => alignKey,
+  cellClassNameForRange: () => cellClassNameForRange,
+  commentKey: () => commentKey,
+  compareIndexPositions: () => compareIndexPositions,
+  createIndex: () => createIndex,
+  createIndices: () => createIndices,
+  createSheet: () => createSheet,
+  initialize: () => initialize,
+  insertIndices: () => insertIndices,
+  mapFormulaIndicesToRefs: () => mapFormulaIndicesToRefs,
+  mapFormulaRefsToIndices: () => mapFormulaRefsToIndices,
+  rangeFromIndex: () => rangeFromIndex,
+  rangeToIndex: () => rangeToIndex,
+  styleKey: () => styleKey,
+  useSheetModel: () => useSheetModel
+});
+module.exports = __toCommonJS(chunk_TQOJ7DG2_exports);
+var import_chunk_2ZVZI2KJ = require("./chunk-2ZVZI2KJ.cjs");
+var import_echo_schema = require("@dxos/echo-schema");
+var import_types = require("@dxos/plugin-space/types");
+var import_echo_schema2 = require("@dxos/echo-schema");
+var import_async = require("@dxos/async");
+var import_compute = require("@dxos/compute");
+var import_context = require("@dxos/context");
+var import_echo_schema3 = require("@dxos/echo-schema");
+var import_invariant = require("@dxos/invariant");
+var import_keys = require("@dxos/keys");
+var import_log = require("@dxos/log");
+var import_react = require("react");
+var import_compute2 = require("@dxos/compute");
+var import_crypto = require("@dxos/crypto");
+var import_invariant2 = require("@dxos/invariant");
+var import_live_object = require("@dxos/live-object");
+var CellValue = import_echo_schema.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: import_echo_schema.S.Any
+});
+var Range = import_echo_schema.S.Struct({
+  range: import_echo_schema.S.String,
+  key: import_echo_schema.S.String,
+  value: import_echo_schema.S.String
+});
+var RowColumnMeta = import_echo_schema.S.Struct({
+  size: import_echo_schema.S.optional(import_echo_schema.S.Number)
+});
+var SheetType = class extends (0, import_echo_schema.TypedObject)({
+  typename: "dxos.org/type/Sheet",
+  version: "0.1.0"
+})({
+  name: import_echo_schema.S.optional(import_echo_schema.S.String),
+  // Sparse map of cells referenced by index.
+  cells: import_echo_schema.S.mutable(import_echo_schema.S.Record({
+    key: import_echo_schema.S.String,
+    value: import_echo_schema.S.mutable(CellValue)
+  })),
+  // Ordered row indices.
+  rows: import_echo_schema.S.mutable(import_echo_schema.S.Array(import_echo_schema.S.String)),
+  // Ordered column indices.
+  columns: import_echo_schema.S.mutable(import_echo_schema.S.Array(import_echo_schema.S.String)),
+  // Row metadata referenced by index.
+  rowMeta: import_echo_schema.S.mutable(import_echo_schema.S.Record({
+    key: import_echo_schema.S.String,
+    value: import_echo_schema.S.mutable(RowColumnMeta)
+  })),
+  // Column metadata referenced by index.
+  columnMeta: import_echo_schema.S.mutable(import_echo_schema.S.Record({
+    key: import_echo_schema.S.String,
+    value: import_echo_schema.S.mutable(RowColumnMeta)
+  })),
+  // Cell formatting referenced by indexed range.
+  ranges: import_echo_schema.S.mutable(import_echo_schema.S.Array(Range)),
+  // Threads associated with the sheet
+  threads: import_echo_schema.S.optional(import_echo_schema.S.mutable(import_echo_schema.S.Array((0, import_echo_schema.Ref)(import_types.ThreadType))))
+}) {
+};
+var alignKey = "alignment";
+var commentKey = "comment";
+var styleKey = "style";
+var cellClassNameForRange = ({ key, value }) => {
+  switch (key) {
+    case alignKey:
+      switch (value) {
+        case "start":
+          return "text-start";
+        case "center":
+          return "text-center";
+        case "end":
+          return "text-end";
+        default:
+          return void 0;
+      }
+    case commentKey:
+      return "bg-gridComment";
+    case styleKey:
+      switch (value) {
+        case "highlight":
+          return "!bg-gridHighlight";
+        case "softwrap":
+          return "!whitespace-normal";
+        default:
+          return void 0;
+      }
+    default:
+      return void 0;
+  }
+};
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/plugins/plugin-sheet/src/model/sheet-model.ts";
+var typeMap = {
+  BOOLEAN: {
+    type: import_echo_schema3.TypeEnum.Boolean
+  },
+  NUMBER_RAW: {
+    type: import_echo_schema3.TypeEnum.Number
+  },
+  NUMBER_PERCENT: {
+    type: import_echo_schema3.TypeEnum.Number,
+    format: import_echo_schema3.FormatEnum.Percent
+  },
+  NUMBER_CURRENCY: {
+    type: import_echo_schema3.TypeEnum.Number,
+    format: import_echo_schema3.FormatEnum.Currency
+  },
+  NUMBER_DATETIME: {
+    type: import_echo_schema3.TypeEnum.String,
+    format: import_echo_schema3.FormatEnum.DateTime
+  },
+  NUMBER_DATE: {
+    type: import_echo_schema3.TypeEnum.String,
+    format: import_echo_schema3.FormatEnum.Date
+  },
+  NUMBER_TIME: {
+    type: import_echo_schema3.TypeEnum.String,
+    format: import_echo_schema3.FormatEnum.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 import_context.Resource {
+  constructor(_graph, _sheet, _options = {}) {
+    super();
+    this._graph = _graph;
+    this._sheet = _sheet;
+    this._options = _options;
+    this.id = `model-${import_keys.PublicKey.random().truncate()}`;
+    this.update = new import_async.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() {
+    (0, import_log.log)("initialize", {
+      id: this.id
+    }, {
+      F: __dxlog_file,
+      L: 123,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    initialize(this._sheet);
+    this._graph.update.on((event) => {
+      if (event.type === "functionsUpdated") {
+        this.reset();
+      }
+    });
+    this._node = this._graph.getOrCreateNode((0, import_compute.createSheetName)({
+      type: (0, import_echo_schema3.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() {
+    (0, import_invariant.invariant)(this._node, void 0, {
+      F: __dxlog_file,
+      L: 149,
+      S: this,
+      A: [
+        "this._node",
+        ""
+      ]
+    });
+    this._node.graph.hf.clearSheet(this._node.sheetId);
+    Object.entries(this._sheet.cells).forEach(([key, { value }]) => {
+      (0, import_invariant.invariant)(this._node, void 0, {
+        F: __dxlog_file,
+        L: 152,
+        S: this,
+        A: [
+          "this._node",
+          ""
+        ]
+      });
+      const { col, row } = addressFromIndex(this._sheet, key);
+      if ((0, import_compute.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) {
+    const idx = insertIndices(this._sheet.rows, i, n, MAX_ROWS);
+    this.reset();
+    return idx;
+  }
+  insertColumns(i, n = 1) {
+    const idx = insertIndices(this._sheet.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);
+    this._sheet.rows.splice(index, 1);
+    delete this._sheet.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);
+    this._sheet.columns.splice(index, 1);
+    delete this._sheet.columnMeta[colIndex];
+    this.reset();
+    return {
+      axis: "col",
+      index,
+      axisIndex: colIndex,
+      axisMeta: this._sheet.rowMeta[colIndex],
+      values
+    };
+  }
+  restoreRow({ index, axisIndex, axisMeta, values }) {
+    this._sheet.rows.splice(index, 0, axisIndex);
+    values.forEach((value, col) => {
+      if (value) {
+        this._sheet.cells[`${this._sheet.columns[col]}@${axisIndex}`] = {
+          value
+        };
+      }
+    });
+    if (axisMeta) {
+      this._sheet.rowMeta[axisIndex] = axisMeta;
+    }
+    this.reset();
+  }
+  restoreColumn({ index, axisIndex, axisMeta, values }) {
+    this._sheet.columns.splice(index, 0, axisIndex);
+    values.forEach((value, row) => {
+      if (value) {
+        this._sheet.cells[`${axisIndex}@${this._sheet.rows[row]}`] = {
+          value
+        };
+      }
+    });
+    if (axisMeta) {
+      this._sheet.columnMeta[axisIndex] = axisMeta;
+    }
+    this.reset();
+  }
+  //
+  // Undoable actions.
+  // TODO(burdon): Group undoable methods; consistently update hf/sheet.
+  //
+  /**
+  * Clear range of values.
+  */
+  clear(range) {
+    (0, import_invariant.invariant)(this._node, void 0, {
+      F: __dxlog_file,
+      L: 255,
+      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) {
+    (0, import_invariant.invariant)(this._node, void 0, {
+      F: __dxlog_file,
+      L: 266,
+      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) {
+    (0, import_invariant.invariant)(this._node, void 0, {
+      F: __dxlog_file,
+      L: 275,
+      S: this,
+      A: [
+        "this._node",
+        ""
+      ]
+    });
+    this._node.graph.hf.copy(toModelRange(this._node.sheetId, range));
+  }
+  paste(cell) {
+    (0, import_invariant.invariant)(this._node, void 0, {
+      F: __dxlog_file,
+      L: 280,
+      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 import_compute.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() {
+    (0, import_invariant.invariant)(this._node, void 0, {
+      F: __dxlog_file,
+      L: 295,
+      S: this,
+      A: [
+        "this._node",
+        ""
+      ]
+    });
+    if (this._node.graph.hf.isThereSomethingToUndo()) {
+      this._node.graph.hf.undo();
+    }
+  }
+  redo() {
+    (0, import_invariant.invariant)(this._node, void 0, {
+      F: __dxlog_file,
+      L: 303,
+      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 ((0, import_compute.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) {
+    (0, import_invariant.invariant)(this._node, void 0, {
+      F: __dxlog_file,
+      L: 346,
+      S: this,
+      A: [
+        "this._node",
+        ""
+      ]
+    });
+    const address = toSimpleCellAddress(this._node.sheetId, cell);
+    const value = this._node.graph.hf.getCellValue(address);
+    if (value instanceof import_compute.DetailedCellError) {
+      import_log.log.info("cell error", {
+        cell,
+        error: value
+      }, {
+        F: __dxlog_file,
+        L: 351,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return value.toString();
+    }
+    return value;
+  }
+  /**
+  * Get value type.
+  */
+  getValueDescription(cell) {
+    (0, import_invariant.invariant)(this._node, void 0, {
+      F: __dxlog_file,
+      L: 362,
+      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) {
+    (0, import_invariant.invariant)(this._node, void 0, {
+      F: __dxlog_file,
+      L: 372,
+      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_COLS);
+      refresh = true;
+    }
+    if (refresh) {
+      this.reset();
+    }
+    this._node.graph.hf.setCellContents({
+      sheet: this._node.sheetId,
+      row: cell.row,
+      col: cell.col
+    }, [
+      [
+        (0, import_compute.isFormula)(value) ? this._graph.mapFormulaToNative(value) : value
+      ]
+    ]);
+    const idx = addressToIndex(this._sheet, cell);
+    if (value === void 0 || value === null) {
+      delete this._sheet.cells[idx];
+    } else {
+      if ((0, import_compute.isFormula)(value)) {
+        value = this._graph.mapFunctionBindingToId(mapFormulaRefsToIndices(this._sheet, value));
+      }
+      this._sheet.cells[idx] = {
+        value
+      };
+    }
+  }
+  /**
+  * Sets values from a simple map.
+  */
+  setValues(values) {
+    Object.entries(values).forEach(([key, { value }]) => {
+      this.setValue((0, import_compute.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) {
+    (0, import_invariant.invariant)((0, import_compute.isFormula)(formula), void 0, {
+      F: __dxlog_file,
+      L: 457,
+      S: this,
+      A: [
+        "isFormula(formula)",
+        ""
+      ]
+    });
+    return formula.replace(/([a-zA-Z0-9]+)@([a-zA-Z0-9]+)/g, (idx) => {
+      return (0, import_compute.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) {
+    (0, import_invariant.invariant)(this._node, void 0, {
+      F: __dxlog_file,
+      L: 478,
+      S: this,
+      A: [
+        "this._node",
+        ""
+      ]
+    });
+    return this._node.graph.hf.numberToDateTime(num);
+  }
+  toDate(num) {
+    (0, import_invariant.invariant)(this._node, void 0, {
+      F: __dxlog_file,
+      L: 483,
+      S: this,
+      A: [
+        "this._node",
+        ""
+      ]
+    });
+    return this._node.graph.hf.numberToDate(num);
+  }
+  toTime(num) {
+    (0, import_invariant.invariant)(this._node, void 0, {
+      F: __dxlog_file,
+      L: 488,
+      S: this,
+      A: [
+        "this._node",
+        ""
+      ]
+    });
+    return this._node.graph.hf.numberToTime(num);
+  }
+};
+var useSheetModel = (graph, sheet, { readonly } = {}) => {
+  const [model, setModel] = (0, import_react.useState)();
+  (0, import_react.useEffect)(() => {
+    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;
+};
+var SheetAction;
+(function(SheetAction2) {
+  const SHEET_ACTION = `${import_chunk_2ZVZI2KJ.SHEET_PLUGIN}/action`;
+  class Create extends import_echo_schema2.S.TaggedClass()(`${SHEET_ACTION}/create`, {
+    input: import_echo_schema2.S.Struct({
+      name: import_echo_schema2.S.optional(import_echo_schema2.S.String)
+    }),
+    output: import_echo_schema2.S.Struct({
+      object: SheetType
+    })
+  }) {
+  }
+  SheetAction2.Create = Create;
+  const Axis = import_echo_schema2.S.Union(import_echo_schema2.S.Literal("row"), import_echo_schema2.S.Literal("col"));
+  class InsertAxis extends import_echo_schema2.S.TaggedClass()(`${SHEET_ACTION}/axis-insert`, {
+    input: import_echo_schema2.S.Struct({
+      // TODO(wittjosiah): S.instanceOf(SheetModel) throws when running tests.
+      model: import_echo_schema2.S.Any.pipe(import_echo_schema2.S.filter((model) => model instanceof SheetModel)),
+      axis: Axis,
+      index: import_echo_schema2.S.Number,
+      count: import_echo_schema2.S.optional(import_echo_schema2.S.Number)
+    }),
+    output: import_echo_schema2.S.Void
+  }) {
+  }
+  SheetAction2.InsertAxis = InsertAxis;
+  SheetAction2.RestoreAxis = import_echo_schema2.S.Struct({
+    axis: Axis,
+    axisIndex: import_echo_schema2.S.String,
+    index: import_echo_schema2.S.Number,
+    axisMeta: RowColumnMeta,
+    values: import_echo_schema2.S.Array(import_echo_schema2.S.Any)
+  });
+  class DropAxis extends import_echo_schema2.S.TaggedClass()(`${SHEET_ACTION}/axis-drop`, {
+    input: import_echo_schema2.S.Struct({
+      // TODO(wittjosiah): S.instanceOf(SheetModel) throws when running tests.
+      model: import_echo_schema2.S.Any.pipe(import_echo_schema2.S.filter((model) => model instanceof SheetModel)),
+      axis: Axis,
+      axisIndex: import_echo_schema2.S.String,
+      deletionData: import_echo_schema2.S.optional(SheetAction2.RestoreAxis)
+    }),
+    output: import_echo_schema2.S.Void
+  }) {
+  }
+  SheetAction2.DropAxis = DropAxis;
+})(SheetAction || (SheetAction = {}));
+var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/plugins/plugin-sheet/src/types/util.ts";
+var MAX_ROWS = 500;
+var MAX_COLS = 676;
+var DEFAULT_ROWS = 50;
+var DEFAULT_COLS = 26;
+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 = (0, import_crypto.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);
+  return idx;
+};
+var initialize = (sheet, { rows = DEFAULT_ROWS, columns = DEFAULT_COLS } = {}) => {
+  if (!sheet.rows.length) {
+    insertIndices(sheet.rows, 0, rows, MAX_ROWS);
+  }
+  if (!sheet.columns.length) {
+    insertIndices(sheet.columns, 0, columns, MAX_COLS);
+  }
+};
+var createSheet = ({ name, cells, ...size } = {}) => {
+  const sheet = (0, import_live_object.create)(SheetType, {
+    name,
+    cells: {},
+    rows: [],
+    columns: [],
+    rowMeta: {},
+    columnMeta: {},
+    ranges: [],
+    threads: []
+  });
+  initialize(sheet, size);
+  if (cells) {
+    Object.entries(cells).forEach(([key, { value }]) => {
+      const idx = addressToIndex(sheet, (0, import_compute2.addressFromA1Notation)(key));
+      if ((0, import_compute2.isFormula)(value)) {
+        value = mapFormulaRefsToIndices(sheet, value);
+      }
+      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 rangeToIndex = (sheet, range) => {
+  return [
+    range.from,
+    range.to ?? range.from
+  ].map((cell) => addressToIndex(sheet, cell)).join(":");
+};
+var rangeFromIndex = (sheet, idx) => {
+  const [from, to] = idx.split(":").map((index) => addressFromIndex(sheet, index));
+  return {
+    from,
+    to
+  };
+};
+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;
+  }
+};
+var mapFormulaRefsToIndices = (sheet, formula) => {
+  (0, import_invariant2.invariant)((0, import_compute2.isFormula)(formula), void 0, {
+    F: __dxlog_file2,
+    L: 153,
+    S: void 0,
+    A: [
+      "isFormula(formula)",
+      ""
+    ]
+  });
+  return formula.replace(/([a-zA-Z]+)([0-9]+)/g, (match) => {
+    return addressToIndex(sheet, (0, import_compute2.addressFromA1Notation)(match));
+  });
+};
+var mapFormulaIndicesToRefs = (sheet, formula) => {
+  (0, import_invariant2.invariant)((0, import_compute2.isFormula)(formula), void 0, {
+    F: __dxlog_file2,
+    L: 163,
+    S: void 0,
+    A: [
+      "isFormula(formula)",
+      ""
+    ]
+  });
+  return formula.replace(/([a-zA-Z0-9]+)@([a-zA-Z0-9]+)/g, (idx) => {
+    return (0, import_compute2.addressToA1Notation)(addressFromIndex(sheet, idx));
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiError,
+  CellValue,
+  DEFAULT_COLS,
+  DEFAULT_ROWS,
+  MAX_COLS,
+  MAX_ROWS,
+  Range,
+  RangeException,
+  ReadonlyException,
+  RowColumnMeta,
+  SheetAction,
+  SheetType,
+  addressFromIndex,
+  addressToIndex,
+  alignKey,
+  cellClassNameForRange,
+  commentKey,
+  compareIndexPositions,
+  createIndex,
+  createIndices,
+  createSheet,
+  initialize,
+  insertIndices,
+  mapFormulaIndicesToRefs,
+  mapFormulaRefsToIndices,
+  rangeFromIndex,
+  rangeToIndex,
+  styleKey,
+  useSheetModel
+});
+//# sourceMappingURL=chunk-TQOJ7DG2.cjs.map