@dxos/plugin-sheet 0.8.4-main.67995b8 → 0.8.4-main.69d29f4

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

@@ -1,893 +0,0 @@
-import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
-import {
-  SHEET_PLUGIN
-} from "./chunk-3K5VNYOF.mjs";
-
-// src/types/schema.ts
-import { Schema } from "effect";
-import { Type } from "@dxos/echo";
-var CellValue = Schema.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: Schema.Any
-});
-var Range = Schema.Struct({
-  range: Schema.String,
-  key: Schema.String,
-  value: Schema.String
-});
-var RowColumnMeta = Schema.Struct({
-  size: Schema.optional(Schema.Number)
-});
-var SheetType = Schema.Struct({
-  name: Schema.optional(Schema.String),
-  // Sparse map of cells referenced by index.
-  cells: Schema.mutable(Schema.Record({
-    key: Schema.String,
-    value: Schema.mutable(CellValue)
-  })),
-  // Ordered row indices.
-  rows: Schema.mutable(Schema.Array(Schema.String)),
-  // Ordered column indices.
-  columns: Schema.mutable(Schema.Array(Schema.String)),
-  // Row metadata referenced by index.
-  rowMeta: Schema.mutable(Schema.Record({
-    key: Schema.String,
-    value: Schema.mutable(RowColumnMeta)
-  })),
-  // Column metadata referenced by index.
-  columnMeta: Schema.mutable(Schema.Record({
-    key: Schema.String,
-    value: Schema.mutable(RowColumnMeta)
-  })),
-  // Cell formatting referenced by indexed range.
-  ranges: Schema.mutable(Schema.Array(Range))
-}).pipe(Type.Obj({
-  typename: "dxos.org/type/Sheet",
-  version: "0.1.0"
-}));
-
-// src/types/sheet-range-types.ts
-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;
-  }
-};
-
-// src/types/types.ts
-import { Schema as Schema2 } from "effect";
-
-// src/model/sheet-model.ts
-import { Event } from "@dxos/async";
-import { addressFromA1Notation, addressToA1Notation, createSheetName, isFormula, DetailedCellError, ExportedCellChange } from "@dxos/compute";
-import { Resource } from "@dxos/context";
-import { Obj } from "@dxos/echo";
-import { FormatEnum, TypeEnum } from "@dxos/echo-schema";
-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: FormatEnum.Percent
-  },
-  NUMBER_CURRENCY: {
-    type: TypeEnum.Number,
-    format: FormatEnum.Currency
-  },
-  NUMBER_DATETIME: {
-    type: TypeEnum.String,
-    format: FormatEnum.DateTime
-  },
-  NUMBER_DATE: {
-    type: TypeEnum.String,
-    format: FormatEnum.Date
-  },
-  NUMBER_TIME: {
-    type: TypeEnum.String,
-    format: 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 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_file,
-      L: 124,
-      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(createSheetName({
-      type: Obj.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: 152,
-      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: 155,
-        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) {
-    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) {
-    invariant(this._node, void 0, {
-      F: __dxlog_file,
-      L: 258,
-      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) {
-    invariant(this._node, void 0, {
-      F: __dxlog_file,
-      L: 269,
-      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) {
-    invariant(this._node, void 0, {
-      F: __dxlog_file,
-      L: 278,
-      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: 283,
-      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() {
-    invariant(this._node, void 0, {
-      F: __dxlog_file,
-      L: 298,
-      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: 306,
-      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: 349,
-      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: 354,
-        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: 365,
-      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: 375,
-      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
-    }, [
-      [
-        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 (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(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: 460,
-      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: 481,
-      S: this,
-      A: [
-        "this._node",
-        ""
-      ]
-    });
-    return this._node.graph.hf.numberToDateTime(num);
-  }
-  toDate(num) {
-    invariant(this._node, void 0, {
-      F: __dxlog_file,
-      L: 486,
-      S: this,
-      A: [
-        "this._node",
-        ""
-      ]
-    });
-    return this._node.graph.hf.numberToDate(num);
-  }
-  toTime(num) {
-    invariant(this._node, void 0, {
-      F: __dxlog_file,
-      L: 491,
-      S: this,
-      A: [
-        "this._node",
-        ""
-      ]
-    });
-    return this._node.graph.hf.numberToTime(num);
-  }
-};
-
-// src/model/useSheetModel.ts
-import { useEffect, useState } from "react";
-var useSheetModel = (graph, sheet, { readonly } = {}) => {
-  const [model, setModel] = useState();
-  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;
-};
-
-// src/types/types.ts
-(function(SheetAction2) {
-  const SHEET_ACTION = `${SHEET_PLUGIN}/action`;
-  class Create extends Schema2.TaggedClass()(`${SHEET_ACTION}/create`, {
-    input: Schema2.Struct({
-      name: Schema2.optional(Schema2.String)
-    }),
-    output: Schema2.Struct({
-      object: SheetType
-    })
-  }) {
-  }
-  SheetAction2.Create = Create;
-  const Axis = Schema2.Union(Schema2.Literal("row"), Schema2.Literal("col"));
-  class InsertAxis extends Schema2.TaggedClass()(`${SHEET_ACTION}/axis-insert`, {
-    input: Schema2.Struct({
-      // TODO(wittjosiah): Schema.instanceOf(SheetModel) throws when running tests.
-      model: Schema2.Any.pipe(Schema2.filter((model) => model instanceof SheetModel)),
-      axis: Axis,
-      index: Schema2.Number,
-      count: Schema2.optional(Schema2.Number)
-    }),
-    output: Schema2.Void
-  }) {
-  }
-  SheetAction2.InsertAxis = InsertAxis;
-  SheetAction2.RestoreAxis = Schema2.Struct({
-    axis: Axis,
-    axisIndex: Schema2.String,
-    index: Schema2.Number,
-    axisMeta: RowColumnMeta,
-    values: Schema2.Array(Schema2.Any)
-  });
-  class DropAxis extends Schema2.TaggedClass()(`${SHEET_ACTION}/axis-drop`, {
-    input: Schema2.Struct({
-      // TODO(wittjosiah): Schema.instanceOf(SheetModel) throws when running tests.
-      model: Schema2.Any.pipe(Schema2.filter((model) => model instanceof SheetModel)),
-      axis: Axis,
-      axisIndex: Schema2.String,
-      deletionData: Schema2.optional(SheetAction2.RestoreAxis)
-    }),
-    output: Schema2.Void
-  }) {
-  }
-  SheetAction2.DropAxis = DropAxis;
-})(SheetAction || (SheetAction = {}));
-var SheetAction;
-
-// src/types/util.ts
-import { addressFromA1Notation as addressFromA1Notation2, addressToA1Notation as addressToA1Notation2, isFormula as isFormula2 } from "@dxos/compute";
-import { randomBytes } from "@dxos/crypto";
-import { Obj as Obj2 } from "@dxos/echo";
-import { invariant as invariant2 } from "@dxos/invariant";
-var __dxlog_file2 = "/__w/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 = 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 = Obj2.make(SheetType, {
-    name,
-    cells: {},
-    rows: [],
-    columns: [],
-    rowMeta: {},
-    columnMeta: {},
-    ranges: []
-  });
-  initialize(sheet, size);
-  if (cells) {
-    Object.entries(cells).forEach(([key, { value }]) => {
-      const idx = addressToIndex(sheet, addressFromA1Notation2(key));
-      if (isFormula2(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) => {
-  invariant2(isFormula2(formula), void 0, {
-    F: __dxlog_file2,
-    L: 152,
-    S: void 0,
-    A: [
-      "isFormula(formula)",
-      ""
-    ]
-  });
-  return formula.replace(/([a-zA-Z]+)([0-9]+)/g, (match) => {
-    return addressToIndex(sheet, addressFromA1Notation2(match));
-  });
-};
-var mapFormulaIndicesToRefs = (sheet, formula) => {
-  invariant2(isFormula2(formula), void 0, {
-    F: __dxlog_file2,
-    L: 162,
-    S: void 0,
-    A: [
-      "isFormula(formula)",
-      ""
-    ]
-  });
-  return formula.replace(/([a-zA-Z0-9]+)@([a-zA-Z0-9]+)/g, (idx) => {
-    return addressToA1Notation2(addressFromIndex(sheet, idx));
-  });
-};
-
-export {
-  CellValue,
-  Range,
-  RowColumnMeta,
-  SheetType,
-  alignKey,
-  commentKey,
-  styleKey,
-  cellClassNameForRange,
-  useSheetModel,
-  SheetAction,
-  MAX_ROWS,
-  MAX_COLS,
-  DEFAULT_ROWS,
-  DEFAULT_COLS,
-  ApiError,
-  ReadonlyException,
-  RangeException,
-  createIndex,
-  createIndices,
-  insertIndices,
-  initialize,
-  createSheet,
-  addressToIndex,
-  addressFromIndex,
-  rangeToIndex,
-  rangeFromIndex,
-  compareIndexPositions,
-  mapFormulaRefsToIndices,
-  mapFormulaIndicesToRefs
-};
-//# sourceMappingURL=chunk-CADTJFAS.mjs.map