@dxos/plugin-sheet 0.6.8-main.046e6cf

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

@@ -0,0 +1,881 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var chunk_FCKJ4QRM_exports = {};
+__export(chunk_FCKJ4QRM_exports, {
+  ComputeGraphContextProvider: () => ComputeGraphContextProvider,
+  SheetModel: () => SheetModel,
+  addressFromA1Notation: () => addressFromA1Notation,
+  addressToA1Notation: () => addressToA1Notation,
+  columnLetter: () => columnLetter,
+  createComputeGraph: () => createComputeGraph,
+  inRange: () => inRange,
+  posEquals: () => posEquals,
+  rangeToA1Notation: () => rangeToA1Notation,
+  useComputeGraph: () => useComputeGraph
+});
+module.exports = __toCommonJS(chunk_FCKJ4QRM_exports);
+var import_chunk_4CE6FK5Z = require("./chunk-4CE6FK5Z.cjs");
+var import_hyperformula = require("hyperformula");
+var import_async = require("@dxos/async");
+var import_keys = require("@dxos/keys");
+var import_log = require("@dxos/log");
+var import_hyperformula2 = require("hyperformula");
+var import_async2 = require("@dxos/async");
+var import_log2 = require("@dxos/log");
+var import_hyperformula3 = require("hyperformula");
+var import_util = require("@dxos/util");
+var import_hyperformula4 = require("hyperformula");
+var import_echo = require("@dxos/client/echo");
+var import_edge = require("@dxos/plugin-script/edge");
+var import_types = require("@dxos/plugin-script/types");
+var import_react = __toESM(require("react"));
+var import_invariant = require("@dxos/invariant");
+var import_hyperformula5 = require("hyperformula");
+var import_async3 = require("@dxos/async");
+var import_context = require("@dxos/context");
+var import_invariant2 = require("@dxos/invariant");
+var import_keys2 = require("@dxos/keys");
+var import_log3 = require("@dxos/log");
+var import_crypto = require("@dxos/crypto");
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/plugins/plugin-sheet/src/components/ComputeGraph/async-function.ts";
+var defaultFunctionContextOptions = {
+  defaultTtl: 5e3,
+  recalculationDelay: 200
+};
+var FunctionContext = class _FunctionContext {
+  // Mangle name with params.
+  static createInvocationKey(name, ...args) {
+    return JSON.stringify({
+      name,
+      ...args
+    });
+  }
+  constructor(_hf, _space, onUpdate, _options = defaultFunctionContextOptions) {
+    this._hf = _hf;
+    this._space = _space;
+    this._options = _options;
+    this._cache = /* @__PURE__ */ new Map();
+    this._pending = /* @__PURE__ */ new Map();
+    this._invocations = {};
+    this._onUpdate = (0, import_async2.debounce)(() => {
+      this._hf.resumeEvaluation();
+      onUpdate(this);
+    }, this._options.recalculationDelay);
+  }
+  get space() {
+    return this._space;
+  }
+  get info() {
+    return {
+      cache: this._cache.size,
+      invocations: this._invocations
+    };
+  }
+  flush() {
+    this._cache.clear();
+    this._invocations = {};
+  }
+  /**
+  * Exec the function if TTL has expired.
+  * Return the cached value.
+  */
+  invokeFunction(name, state, args, cb, options) {
+    const ttl = options?.ttl ?? this._options.defaultTtl;
+    const { formulaAddress: cell } = state;
+    const invocationKey = _FunctionContext.createInvocationKey(name, ...args);
+    const { value = void 0, ts = 0 } = this._cache.get(invocationKey) ?? {};
+    const now = Date.now();
+    const delta = now - ts;
+    if ((!ts || delta > ttl) && !this._pending.has(invocationKey)) {
+      this._pending.set(invocationKey, now);
+      setTimeout(async () => {
+        this._invocations[name] = (this._invocations[name] ?? 0) + 1;
+        try {
+          const value2 = await cb(...args);
+          this._cache.set(invocationKey, {
+            value: value2,
+            ts: Date.now()
+          });
+          (0, import_log2.log)("set", {
+            cell,
+            value: value2
+          }, {
+            F: __dxlog_file,
+            L: 116,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          this._onUpdate();
+        } catch (err) {
+          import_log2.log.warn("failed", {
+            cell,
+            err
+          }, {
+            F: __dxlog_file,
+            L: 120,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          this._cache.set(invocationKey, {
+            value: new import_hyperformula2.CellError(import_hyperformula2.ErrorType.ERROR, "Function failed."),
+            ts: Date.now()
+          });
+        } finally {
+          this._pending.delete(invocationKey);
+        }
+      });
+    }
+    (0, import_log2.log)("invoke", {
+      cell,
+      name,
+      args,
+      cache: value
+    }, {
+      F: __dxlog_file,
+      L: 128,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    return value;
+  }
+};
+var FunctionPluginAsync = class extends import_hyperformula2.FunctionPlugin {
+  get context() {
+    return this.config.context;
+  }
+  runAsyncFunction(ast, state, cb, options) {
+    const { procedureName } = ast;
+    const metadata = this.metadata(procedureName);
+    return this.runFunction(ast.args, state, metadata, (...args) => {
+      return this.context.invokeFunction(procedureName, state, args, cb, options) ?? import_hyperformula2.EmptyValue;
+    });
+  }
+};
+var parseNumberString = (str) => {
+  return parseFloat(str.replace(/[^\d.]/g, ""));
+};
+var CustomPlugin = class extends FunctionPluginAsync {
+  test(ast, state) {
+    const handler = async () => {
+      return Math.random();
+    };
+    return this.runAsyncFunction(ast, state, handler);
+  }
+  crypto(ast, state) {
+    const handler = async (_currency) => {
+      const currency = (_currency || "USD").toUpperCase();
+      const result = await fetch(`https://api.coindesk.com/v1/bpi/currentprice/${currency}.json`);
+      const data = await result.json();
+      const rate = (0, import_util.getDeep)(data, [
+        "bpi",
+        currency,
+        "rate"
+      ]);
+      if (!rate) {
+        return NaN;
+      }
+      return parseNumberString(rate);
+    };
+    return this.runAsyncFunction(ast, state, handler, {
+      ttl: 1e4
+    });
+  }
+};
+CustomPlugin.implementedFunctions = {
+  TEST: {
+    method: "test",
+    parameters: [],
+    isVolatile: true
+  },
+  CRYPTO: {
+    method: "crypto",
+    parameters: [
+      {
+        argumentType: import_hyperformula3.FunctionArgumentType.STRING,
+        optionalArg: true
+      }
+    ],
+    isVolatile: true
+  }
+};
+var CustomPluginTranslations = {
+  enGB: {
+    TEST: "TEST",
+    CRYPTO: "CRYPTO"
+  },
+  enUS: {
+    TEST: "TEST",
+    CRYPTO: "CRYPTO"
+  }
+};
+var EdgeFunctionPlugin = class extends FunctionPluginAsync {
+  edge(ast, state) {
+    const handler = async (binding) => {
+      const space = this.context.space;
+      if (!space) {
+        return new import_hyperformula4.CellError(import_hyperformula4.ErrorType.VALUE, "No space");
+      }
+      const { objects: [script] } = await space.db.query(import_echo.Filter.schema(import_types.ScriptType, {
+        binding
+      })).run();
+      if (!script) {
+        return new import_hyperformula4.CellError(import_hyperformula4.ErrorType.VALUE, "No script");
+      }
+      const path = (0, import_edge.getUserFunctionUrlInMetadata)((0, import_echo.getMeta)(script));
+      const result = await fetch(`https://functions-staging.dxos.workers.dev${path}`, {
+        method: "POST"
+      });
+      return await result.text();
+    };
+    return this.runAsyncFunction(ast, state, handler, {
+      ttl: 1e4
+    });
+  }
+};
+EdgeFunctionPlugin.implementedFunctions = {
+  EDGE: {
+    method: "edge",
+    parameters: [
+      {
+        argumentType: import_hyperformula4.FunctionArgumentType.STRING
+      }
+    ],
+    isVolatile: true
+  }
+};
+var EdgeFunctionPluginTranslations = {
+  enGB: {
+    EDGE: "EDGE"
+  },
+  enUS: {
+    EDGE: "EDGE"
+  }
+};
+var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/plugins/plugin-sheet/src/components/ComputeGraph/graph.ts";
+var createComputeGraph = (space) => {
+  import_hyperformula.HyperFormula.registerFunctionPlugin(CustomPlugin, CustomPluginTranslations);
+  import_hyperformula.HyperFormula.registerFunctionPlugin(EdgeFunctionPlugin, EdgeFunctionPluginTranslations);
+  const hf = import_hyperformula.HyperFormula.buildEmpty({
+    licenseKey: "gpl-v3"
+  });
+  return new ComputeGraph(hf, space);
+};
+var ComputeGraph = class {
+  constructor(hf, _space) {
+    this.hf = hf;
+    this._space = _space;
+    this.id = `graph-${import_keys.PublicKey.random().truncate()}`;
+    this.update = new import_async.Event();
+    this.context = new FunctionContext(this.hf, this._space, () => {
+      this.refresh();
+    });
+    this.hf.updateConfig({
+      context: this.context
+    });
+  }
+  refresh() {
+    (0, import_log.log)("refresh", {
+      id: this.id
+    }, {
+      F: __dxlog_file2,
+      L: 49,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    this.update.emit();
+  }
+};
+var ComputeGraphContext = /* @__PURE__ */ (0, import_react.createContext)({
+  graphs: {},
+  setGraph: () => {
+  }
+});
+var ComputeGraphContextProvider = ({ children, graphs, setGraph }) => {
+  return /* @__PURE__ */ import_react.default.createElement(ComputeGraphContext.Provider, {
+    value: {
+      graphs,
+      setGraph
+    }
+  }, children);
+};
+var useComputeGraph = (space) => {
+  const { graphs, setGraph } = (0, import_react.useContext)(ComputeGraphContext);
+  const graph = graphs[space.id] ?? createComputeGraph(space);
+  (0, import_react.useEffect)(() => {
+    if (!graphs[space.id]) {
+      setGraph(space.id, graph);
+    }
+  }, [
+    space
+  ]);
+  return graph;
+};
+var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/plugins/plugin-sheet/src/model/types.ts";
+var MAX_COLUMNS = 26 * 26;
+var posEquals = (a, b) => {
+  return a?.column === b?.column && a?.row === b?.row;
+};
+var columnLetter = (column) => {
+  (0, import_invariant.invariant)(column < MAX_COLUMNS, `Invalid column: ${column}`, {
+    F: __dxlog_file3,
+    L: 17,
+    S: void 0,
+    A: [
+      "column < MAX_COLUMNS",
+      "`Invalid column: ${column}`"
+    ]
+  });
+  return (column >= 26 ? String.fromCharCode("A".charCodeAt(0) + Math.floor(column / 26) - 1) : "") + String.fromCharCode("A".charCodeAt(0) + column % 26);
+};
+var addressToA1Notation = ({ column, row }) => {
+  return `${columnLetter(column)}${row + 1}`;
+};
+var addressFromA1Notation = (ref) => {
+  const match = ref.match(/([A-Z]+)(\d+)/);
+  (0, import_invariant.invariant)(match, `Invalid notation: ${ref}`, {
+    F: __dxlog_file3,
+    L: 30,
+    S: void 0,
+    A: [
+      "match",
+      "`Invalid notation: ${ref}`"
+    ]
+  });
+  return {
+    row: parseInt(match[2], 10) - 1,
+    column: match[1].split("").reduce((acc, c) => acc * 26 + c.charCodeAt(0) - "A".charCodeAt(0) + 1, 0) - 1
+  };
+};
+var rangeToA1Notation = (range) => {
+  return [
+    range?.from && addressToA1Notation(range?.from),
+    range?.to && addressToA1Notation(range?.to)
+  ].filter(Boolean).join(":");
+};
+var inRange = (range, cell) => {
+  if (!range) {
+    return false;
+  }
+  const { from, to } = range;
+  if (from && posEquals(from, cell) || to && posEquals(to, cell)) {
+    return true;
+  }
+  if (!from || !to) {
+    return false;
+  }
+  const { column: c1, row: r1 } = from;
+  const { column: c2, row: r2 } = to;
+  const cMin = Math.min(c1, c2);
+  const cMax = Math.max(c1, c2);
+  const rMin = Math.min(r1, r2);
+  const rMax = Math.max(r1, r2);
+  const { column, row } = cell;
+  return column >= cMin && column <= cMax && row >= rMin && row <= rMax;
+};
+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 __dxlog_file4 = "/home/runner/work/dxos/dxos/packages/plugins/plugin-sheet/src/model/model.ts";
+var DEFAULT_ROWS = 500;
+var DEFAULT_COLUMNS = 26 * 2;
+var typeMap = {
+  BOOLEAN: import_chunk_4CE6FK5Z.ValueTypeEnum.Boolean,
+  NUMBER_RAW: import_chunk_4CE6FK5Z.ValueTypeEnum.Number,
+  NUMBER_PERCENT: import_chunk_4CE6FK5Z.ValueTypeEnum.Percent,
+  NUMBER_CURRENCY: import_chunk_4CE6FK5Z.ValueTypeEnum.Currency,
+  NUMBER_DATETIME: import_chunk_4CE6FK5Z.ValueTypeEnum.DateTime,
+  NUMBER_DATE: import_chunk_4CE6FK5Z.ValueTypeEnum.Date,
+  NUMBER_TIME: import_chunk_4CE6FK5Z.ValueTypeEnum.Time
+};
+var defaultOptions = {
+  rows: 50,
+  columns: 26
+};
+var getTopLeft = (range) => {
+  const to = range.to ?? range.from;
+  return {
+    row: Math.min(range.from.row, to.row),
+    column: Math.min(range.from.column, to.column)
+  };
+};
+var toSimpleCellAddress = (sheet, cell) => ({
+  sheet,
+  row: cell.row,
+  col: cell.column
+});
+var toModelRange = (sheet, range) => ({
+  start: toSimpleCellAddress(sheet, range.from),
+  end: toSimpleCellAddress(sheet, range.to ?? range.from)
+});
+var SheetModel = class {
+  constructor(_graph, _sheet, options = {}) {
+    this._graph = _graph;
+    this._sheet = _sheet;
+    this.id = `model-${import_keys2.PublicKey.random().truncate()}`;
+    this._ctx = void 0;
+    this.update = new import_async3.Event();
+    const name = this._sheet.id;
+    if (!this._graph.hf.doesSheetExist(name)) {
+      this._graph.hf.addSheet(name);
+    }
+    this._sheetId = this._graph.hf.getSheetId(name);
+    this._options = {
+      ...defaultOptions,
+      ...options
+    };
+    this.reset();
+  }
+  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
+    };
+  }
+  get functions() {
+    return this._graph.hf.getRegisteredFunctionNames();
+  }
+  get initialized() {
+    return !!this._ctx;
+  }
+  /**
+  * Initialize sheet and engine.
+  */
+  async initialize() {
+    (0, import_log3.log)("initialize", {
+      id: this.id
+    }, {
+      F: __dxlog_file4,
+      L: 130,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    (0, import_invariant2.invariant)(!this.initialized, "Already initialized.", {
+      F: __dxlog_file4,
+      L: 131,
+      S: this,
+      A: [
+        "!this.initialized",
+        "'Already initialized.'"
+      ]
+    });
+    this._ctx = new import_context.Context(void 0, {
+      F: __dxlog_file4,
+      L: 132
+    });
+    if (!this._sheet.rows.length) {
+      this._insertIndices(this._sheet.rows, 0, this._options.rows, DEFAULT_ROWS);
+    }
+    if (!this._sheet.columns.length) {
+      this._insertIndices(this._sheet.columns, 0, this._options.columns, DEFAULT_COLUMNS);
+    }
+    this.reset();
+    const unsubscribe = this._graph.update.on(() => this.update.emit());
+    this._ctx.onDispose(unsubscribe);
+    return this;
+  }
+  async destroy() {
+    (0, import_log3.log)("destroy", {
+      id: this.id
+    }, {
+      F: __dxlog_file4,
+      L: 149,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    if (this._ctx) {
+      await this._ctx.dispose();
+      this._ctx = void 0;
+    }
+  }
+  /**
+  * Update engine.
+  * NOTE: This resets the undo history.
+  * @deprecated
+  */
+  reset() {
+    this._graph.hf.clearSheet(this._sheetId);
+    Object.entries(this._sheet.cells).forEach(([key, { value }]) => {
+      const { column, row } = this.addressFromIndex(key);
+      if (typeof value === "string" && value.charAt(0) === "=") {
+        value = this.mapFormulaIndicesToRefs(value);
+      }
+      this._graph.hf.setCellContents({
+        sheet: this._sheetId,
+        row,
+        col: column
+      }, 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._graph.hf.rebuildAndRecalculate();
+  }
+  insertRows(i, n = 1) {
+    this._insertIndices(this._sheet.rows, i, n, DEFAULT_ROWS);
+    this.reset();
+  }
+  insertColumns(i, n = 1) {
+    this._insertIndices(this._sheet.columns, i, n, DEFAULT_COLUMNS);
+    this.reset();
+  }
+  //
+  // Undoable actions.
+  // TODO(burdon): Group undoable methods; consistently update hf/sheet.
+  //
+  /**
+  * Clear range of values.
+  */
+  clear(range) {
+    const topLeft = getTopLeft(range);
+    const values = this._iterRange(range, () => null);
+    this._graph.hf.setCellContents(toSimpleCellAddress(this._sheetId, topLeft), values);
+    this._iterRange(range, (cell) => {
+      const idx = this.addressToIndex(cell);
+      delete this._sheet.cells[idx];
+    });
+  }
+  cut(range) {
+    this._graph.hf.cut(toModelRange(this._sheetId, range));
+    this._iterRange(range, (cell) => {
+      const idx = this.addressToIndex(cell);
+      delete this._sheet.cells[idx];
+    });
+  }
+  copy(range) {
+    this._graph.hf.copy(toModelRange(this._sheetId, range));
+  }
+  paste(cell) {
+    if (!this._graph.hf.isClipboardEmpty()) {
+      const changes = this._graph.hf.paste(toSimpleCellAddress(this._sheetId, cell));
+      for (const change of changes) {
+        if (change instanceof import_hyperformula5.ExportedCellChange) {
+          const { address, newValue } = change;
+          const idx = this.addressToIndex({
+            row: address.row,
+            column: address.col
+          });
+          this._sheet.cells[idx] = {
+            value: newValue
+          };
+        }
+      }
+    }
+  }
+  // TODO(burdon): Display undo/redo state.
+  undo() {
+    if (this._graph.hf.isThereSomethingToUndo()) {
+      this._graph.hf.undo();
+      this.update.emit();
+    }
+  }
+  redo() {
+    if (this._graph.hf.isThereSomethingToRedo()) {
+      this._graph.hf.redo();
+      this.update.emit();
+    }
+  }
+  /**
+  * Get value from sheet.
+  */
+  getCellValue(cell) {
+    const idx = this.addressToIndex(cell);
+    return this._sheet.cells[idx]?.value ?? null;
+  }
+  /**
+  * Get value as a string for editing.
+  */
+  getCellText(cell) {
+    const value = this.getCellValue(cell);
+    if (value == null) {
+      return void 0;
+    }
+    if (typeof value === "string" && value.charAt(0) === "=") {
+      return this.mapFormulaIndicesToRefs(value);
+    } else {
+      return String(value);
+    }
+  }
+  /**
+  * Get array of raw values from sheet.
+  */
+  getCellValues(range) {
+    return this._iterRange(range, (cell) => this.getCellValue(cell));
+  }
+  /**
+  * Gets the regular or computed value from the engine.
+  */
+  getValue(cell) {
+    const value = this._graph.hf.getCellValue(toSimpleCellAddress(this._sheetId, cell));
+    if (value instanceof import_hyperformula5.DetailedCellError) {
+      return value.toString();
+    }
+    return value;
+  }
+  /**
+  * Get value type.
+  */
+  getValueType(cell) {
+    const addr = toSimpleCellAddress(this._sheetId, cell);
+    const type = this._graph.hf.getCellValueDetailedType(addr);
+    return typeMap[type];
+  }
+  /**
+  * Sets the value, updating the sheet and engine.
+  */
+  setValue(cell, value) {
+    if (this._options.readonly) {
+      throw new ReadonlyException();
+    }
+    let refresh = false;
+    if (cell.row >= this._sheet.rows.length) {
+      this._insertIndices(this._sheet.rows, cell.row, 1, DEFAULT_ROWS);
+      refresh = true;
+    }
+    if (cell.column >= this._sheet.columns.length) {
+      this._insertIndices(this._sheet.columns, cell.column, 1, DEFAULT_COLUMNS);
+      refresh = true;
+    }
+    if (refresh) {
+      this.reset();
+    }
+    this._graph.hf.setCellContents({
+      sheet: this._sheetId,
+      row: cell.row,
+      col: cell.column
+    }, [
+      [
+        value
+      ]
+    ]);
+    const idx = this.addressToIndex(cell);
+    if (value === void 0 || value === null) {
+      delete this._sheet.cells[idx];
+    } else {
+      if (typeof value === "string" && value.charAt(0) === "=") {
+        value = this.mapFormulaRefsToIndices(value);
+      }
+      this._sheet.cells[idx] = {
+        value
+      };
+    }
+  }
+  /**
+  * Sets values from a simple map.
+  */
+  setValues(values) {
+    Object.entries(values).forEach(([key, { value }]) => {
+      this.setValue(addressFromA1Notation(key), value);
+    });
+  }
+  /**
+  * Iterate range.
+  */
+  _iterRange(range, cb) {
+    const to = range.to ?? range.from;
+    const rowRange = [
+      Math.min(range.from.row, to.row),
+      Math.max(range.from.row, to.row)
+    ];
+    const columnRange = [
+      Math.min(range.from.column, to.column),
+      Math.max(range.from.column, to.column)
+    ];
+    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,
+          column
+        });
+        if (value !== void 0) {
+          rowCells.push(value);
+        }
+      }
+      rows.push(rowCells);
+    }
+    return rows;
+  }
+  /**
+  *
+  */
+  // TODO(burdon): Insert indices into sheet.
+  _insertIndices(indices, i, n, max) {
+    if (i + n > max) {
+      throw new RangeException(i + n);
+    }
+    const idx = createIndices(n);
+    indices.splice(i, 0, ...idx);
+  }
+  // TODO(burdon): Delete index.
+  _deleteIndices(indices, i, n) {
+    throw new Error("Not implemented");
+  }
+  // TODO(burdon): Move. Cannot use fractional without changing. Switch back to using unique IDs?
+  _moveIndices(indices, i, j, n) {
+    throw new Error("Not implemented");
+  }
+  //
+  // Indices.
+  //
+  /**
+  * E.g., "A1" => "x1@y1".
+  */
+  addressToIndex(cell) {
+    return `${this._sheet.columns[cell.column]}@${this._sheet.rows[cell.row]}`;
+  }
+  /**
+  * E.g., "x1@y1" => "A1".
+  */
+  addressFromIndex(idx) {
+    const [column, row] = idx.split("@");
+    return {
+      column: this._sheet.columns.indexOf(column),
+      row: this._sheet.rows.indexOf(row)
+    };
+  }
+  /**
+  * E.g., "A1:B2" => "x1@y1:x2@y2".
+  */
+  rangeToIndex(range) {
+    return [
+      range.from,
+      range.to ?? range.from
+    ].map((cell) => this.addressToIndex(cell)).join(":");
+  }
+  /**
+  * E.g., "x1@y1:x2@y2" => "A1:B2".
+  */
+  rangeFromIndex(idx) {
+    const [from, to] = idx.split(":").map((idx2) => this.addressFromIndex(idx2));
+    return {
+      from,
+      to
+    };
+  }
+  /**
+  * Map from A1 notation to indices.
+  */
+  mapFormulaRefsToIndices(formula) {
+    (0, import_invariant2.invariant)(formula.charAt(0) === "=", void 0, {
+      F: __dxlog_file4,
+      L: 439,
+      S: this,
+      A: [
+        "formula.charAt(0) === '='",
+        ""
+      ]
+    });
+    return formula.replace(/([a-zA-Z]+)([0-9]+)/g, (match) => {
+      return this.addressToIndex(addressFromA1Notation(match));
+    });
+  }
+  /**
+  * Map from indices to A1 notation.
+  */
+  mapFormulaIndicesToRefs(formula) {
+    (0, import_invariant2.invariant)(formula.charAt(0) === "=", void 0, {
+      F: __dxlog_file4,
+      L: 449,
+      S: this,
+      A: [
+        "formula.charAt(0) === '='",
+        ""
+      ]
+    });
+    return formula.replace(/([a-zA-Z0-9]+)@([a-zA-Z0-9]+)/g, (idx) => {
+      return addressToA1Notation(this.addressFromIndex(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) {
+    return this._graph.hf.numberToDateTime(num);
+  }
+  toDate(num) {
+    return this._graph.hf.numberToDate(num);
+  }
+  toTime(num) {
+    return this._graph.hf.numberToTime(num);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ComputeGraphContextProvider,
+  SheetModel,
+  addressFromA1Notation,
+  addressToA1Notation,
+  columnLetter,
+  createComputeGraph,
+  inRange,
+  posEquals,
+  rangeToA1Notation,
+  useComputeGraph
+});
+//# sourceMappingURL=chunk-FCKJ4QRM.cjs.map