@dxos/plugin-sheet 0.6.12-main.ed7cda7 → 0.6.12-staging.0b4bb48

package/dist/lib/{node-esm/chunk-D6KU5MI7.mjs → browser/chunk-D5AGLXJP.mjs}

@@ -1,22 +1,19 @@
-import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  ValueTypeEnum
+} from "./chunk-FUAGSXA4.mjs";
 
-// packages/plugins/plugin-sheet/src/graph/compute-graph.ts
-import { Event as Event2 } from "@dxos/async";
-import { Filter as Filter2, fullyQualifiedId } from "@dxos/client/echo";
-import { Resource as Resource2 } from "@dxos/context";
-import { invariant } from "@dxos/invariant";
+// packages/plugins/plugin-sheet/src/components/ComputeGraph/graph.ts
+import { HyperFormula } from "hyperformula";
+import { Event } from "@dxos/async";
 import { PublicKey } from "@dxos/keys";
-import { log as log3 } from "@dxos/log";
-import { FunctionType as FunctionType2 } from "@dxos/plugin-script/types";
-import { nonNullable as nonNullable2 } from "@dxos/util";
-import { HyperFormula } from "#hyperformula";
+import { log as log2 } from "@dxos/log";
 
-// packages/plugins/plugin-sheet/src/graph/async-function.ts
+// packages/plugins/plugin-sheet/src/components/ComputeGraph/async-function.ts
+import { CellError, ErrorType, EmptyValue, FunctionPlugin } from "hyperformula";
 import defaultsDeep from "lodash.defaultsdeep";
 import { debounce } from "@dxos/async";
 import { log } from "@dxos/log";
-import { CellError, ErrorType, EmptyValue, FunctionPlugin } from "#hyperformula";
-var __dxlog_file = "/home/runner/work/dxos/dxos/packages/plugins/plugin-sheet/src/graph/async-function.ts";
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/plugins/plugin-sheet/src/components/ComputeGraph/async-function.ts";
 var defaultFunctionContextOptions = {
   defaultTtl: 5e3,
   recalculationDelay: 200,
@@ -43,7 +40,6 @@ var FunctionContext = class _FunctionContext {
       onUpdate(this);
     }, this._options.recalculationDelay);
   }
-  // TODO(burdon): Remove?
   get space() {
     return this._space;
   }
@@ -92,7 +88,7 @@ var FunctionContext = class _FunctionContext {
             value: value2
           }, {
             F: __dxlog_file,
-            L: 138,
+            L: 136,
             S: this,
             C: (f, a) => f(...a)
           });
@@ -103,7 +99,7 @@ var FunctionContext = class _FunctionContext {
             err
           }, {
             F: __dxlog_file,
-            L: 142,
+            L: 140,
             S: this,
             C: (f, a) => f(...a)
           });
@@ -123,7 +119,7 @@ var FunctionContext = class _FunctionContext {
       cache: value
     }, {
       F: __dxlog_file,
-      L: 150,
+      L: 148,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -143,173 +139,53 @@ var FunctionPluginAsync = class extends FunctionPlugin {
   }
 };
 
-// packages/plugins/plugin-sheet/src/graph/compute-node.ts
-import { Event } from "@dxos/async";
-import { Resource } from "@dxos/context";
-import { DetailedCellError } from "#hyperformula";
-var ComputeNode = class extends Resource {
-  constructor(_graph, sheetId) {
-    super();
-    this._graph = _graph;
-    this.sheetId = sheetId;
+// packages/plugins/plugin-sheet/src/components/ComputeGraph/graph.ts
+var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/plugins/plugin-sheet/src/components/ComputeGraph/graph.ts";
+var createComputeGraph = (functionPlugins = [], space, options) => {
+  functionPlugins.forEach(({ plugin, translations }) => {
+    HyperFormula.registerFunctionPlugin(plugin, translations);
+  });
+  const hf = HyperFormula.buildEmpty({
+    licenseKey: "gpl-v3"
+  });
+  return new ComputeGraph(hf, space, options);
+};
+var ComputeGraph = class {
+  constructor(hf, _space, _options) {
+    this.hf = hf;
+    this._space = _space;
+    this._options = _options;
+    this.id = `graph-${PublicKey.random().truncate()}`;
     this.update = new Event();
-  }
-  // TODO(burdon): Remove?
-  get graph() {
-    return this._graph;
-  }
-  get hf() {
-    return this._graph.hf;
-  }
-  getValue(cell) {
-    const value = this._graph.hf.getCellValue({
-      sheet: this.sheetId,
-      row: cell.row,
-      col: cell.col
+    this.context = new FunctionContext(this.hf, this._space, () => {
+      this.refresh();
+    }, this._options);
+    this.hf.updateConfig({
+      context: this.context
     });
-    if (value instanceof DetailedCellError) {
-      return null;
-    }
-    return value;
-  }
-  setValue(cell, value) {
-    const mappedValue = typeof value === "string" && value.charAt(0) === "=" ? this._graph.mapFormulaToNative(value) : value;
-    this._graph.hf.setCellContents({
-      sheet: this.sheetId,
-      row: cell.row,
-      col: cell.col
-    }, [
-      [
-        mappedValue
-      ]
-    ]);
   }
-};
-
-// packages/plugins/plugin-sheet/src/graph/edge-function.ts
-import { effect } from "@preact/signals-core";
-import { Filter, getMeta } from "@dxos/client/echo";
-import { log as log2 } from "@dxos/log";
-import { getUserFunctionUrlInMetadata } from "@dxos/plugin-script/edge";
-import { FunctionType } from "@dxos/plugin-script/types";
-import { nonNullable } from "@dxos/util";
-import { CellError as CellError2, ErrorType as ErrorType2, FunctionArgumentType } from "#hyperformula";
-var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/plugins/plugin-sheet/src/graph/edge-function.ts";
-var EDGE_FUNCTION_TTL = 1e4;
-var EdgeFunctionPlugin = class extends FunctionPluginAsync {
-  edge(ast, state) {
-    const handler = (subscribe = false) => async (binding, ...args) => {
-      const space = this.context.space;
-      if (!space) {
-        return new CellError2(ErrorType2.REF, "Missing space");
-      }
-      const { objects: [fn] } = await space.db.query(Filter.schema(FunctionType, {
-        binding
-      })).run();
-      if (!fn) {
-        log2.info("Function not found", {
-          binding
-        }, {
-          F: __dxlog_file2,
-          L: 39,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        return new CellError2(ErrorType2.REF, "Function not found");
-      }
-      if (subscribe) {
-        const unsubscribe = effect(() => {
-          log2.info("function changed", {
-            fn
-          }, {
-            F: __dxlog_file2,
-            L: 45,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          const _ = fn?.version;
-          this.runAsyncFunction(ast, state, handler(false), {
-            ttl: EDGE_FUNCTION_TTL
-          });
-        });
-        this.context.createSubscription(ast.procedureName, unsubscribe);
-      }
-      const path = getUserFunctionUrlInMetadata(getMeta(fn));
-      const result = await fetch(`${this.context.remoteFunctionUrl}${path}`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          args: args.filter(nonNullable)
-        })
-      });
-      return await result.text();
-    };
-    return this.runAsyncFunction(ast, state, handler(true), {
-      ttl: EDGE_FUNCTION_TTL
+  refresh() {
+    log2("refresh", {
+      id: this.id
+    }, {
+      F: __dxlog_file2,
+      L: 59,
+      S: this,
+      C: (f, a) => f(...a)
     });
-  }
-};
-EdgeFunctionPlugin.implementedFunctions = {
-  EDGE: {
-    method: "edge",
-    parameters: [
-      // Binding
-      {
-        argumentType: FunctionArgumentType.STRING
-      },
-      // Remote function arguments (currently supporting up to 9).
-      {
-        argumentType: FunctionArgumentType.ANY,
-        optionalArg: true
-      },
-      {
-        argumentType: FunctionArgumentType.ANY,
-        optionalArg: true
-      },
-      {
-        argumentType: FunctionArgumentType.ANY,
-        optionalArg: true
-      },
-      {
-        argumentType: FunctionArgumentType.ANY,
-        optionalArg: true
-      },
-      {
-        argumentType: FunctionArgumentType.ANY,
-        optionalArg: true
-      },
-      {
-        argumentType: FunctionArgumentType.ANY,
-        optionalArg: true
-      },
-      {
-        argumentType: FunctionArgumentType.ANY,
-        optionalArg: true
-      },
-      {
-        argumentType: FunctionArgumentType.ANY,
-        optionalArg: true
-      },
-      {
-        argumentType: FunctionArgumentType.ANY,
-        optionalArg: true
-      }
-    ],
-    isVolatile: true
-  }
-};
-var EdgeFunctionPluginTranslations = {
-  enGB: {
-    EDGE: "EDGE"
-  },
-  enUS: {
-    EDGE: "EDGE"
+    this.update.emit();
   }
 };
 
-// packages/plugins/plugin-sheet/src/graph/function-defs.ts
+// packages/plugins/plugin-sheet/src/model/model.ts
+import { DetailedCellError, ExportedCellChange } from "hyperformula";
+import { Event as Event2 } from "@dxos/async";
+import { Context } from "@dxos/context";
+import { invariant as invariant2 } from "@dxos/invariant";
+import { PublicKey as PublicKey2 } from "@dxos/keys";
+import { log as log3 } from "@dxos/log";
+
+// packages/plugins/plugin-sheet/src/model/functions.ts
 var defaultFunctions = [
   // Array
   {
@@ -2683,243 +2559,677 @@ var defaultFunctions = [
   }
 ];
 
-// packages/plugins/plugin-sheet/src/graph/compute-graph.ts
-var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/plugins/plugin-sheet/src/graph/compute-graph.ts";
-var OBJECT_ID_LENGTH = 60;
-var CUSTOM_FUNCTION = "ECHO";
-var defaultOptions = {
-  licenseKey: "gpl-v3",
-  plugins: [
-    {
-      plugin: EdgeFunctionPlugin,
-      translations: EdgeFunctionPluginTranslations
-    }
-  ]
+// packages/plugins/plugin-sheet/src/model/types.ts
+import { invariant } from "@dxos/invariant";
+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 PREFIX = "__";
-var createSheetName = (id) => `${PREFIX}${id}`;
-var getSheetId = (name) => name.startsWith(PREFIX) ? name.slice(PREFIX.length) : void 0;
-var createComputeGraphRegistry = (options = {}) => {
-  return new ComputeGraphRegistry({
-    ...defaultOptions,
-    ...options
+var columnLetter = (column) => {
+  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 ComputeGraphRegistry = class extends Resource2 {
-  constructor(_options = defaultOptions) {
-    super();
-    this._options = _options;
-    this._registry = /* @__PURE__ */ new Map();
-    this._options.plugins?.forEach(({ plugin, translations }) => {
-      HyperFormula.registerFunctionPlugin(plugin, translations);
-    });
+var addressToA1Notation = ({ column, row }) => {
+  return `${columnLetter(column)}${row + 1}`;
+};
+var addressFromA1Notation = (ref) => {
+  const match = ref.match(/([A-Z]+)(\d+)/);
+  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;
   }
-  getGraph(spaceId) {
-    return this._registry.get(spaceId);
-  }
-  async getOrCreateGraph(space) {
-    let graph = this.getGraph(space.id);
-    if (!graph) {
-      log3.info("create graph", {
-        space: space.id
-      }, {
-        F: __dxlog_file3,
-        L: 95,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      graph = await this.createGraph(space);
-    }
-    return graph;
+  const { from, to } = range;
+  if (from && posEquals(from, cell) || to && posEquals(to, cell)) {
+    return true;
   }
-  async createGraph(space) {
-    invariant(!this._registry.has(space.id), `ComputeGraph already exists for space: ${space.id}`, {
-      F: __dxlog_file3,
-      L: 103,
-      S: this,
-      A: [
-        "!this._registry.has(space.id)",
-        "`ComputeGraph already exists for space: ${space.id}`"
-      ]
-    });
-    const hf = HyperFormula.buildEmpty(this._options);
-    const graph = new ComputeGraph(hf, space, this._options);
-    await graph.open(this._ctx);
-    this._registry.set(space.id, graph);
-    return graph;
+  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;
+};
+
+// packages/plugins/plugin-sheet/src/model/util.ts
+import { randomBytes } from "@dxos/crypto";
+var ApiError = class extends Error {
+};
+var ReadonlyException = class extends ApiError {
 };
-var ComputeGraph = class extends Resource2 {
-  constructor(_hf, _space, _options) {
+var RangeException = class extends ApiError {
+  constructor(n) {
     super();
-    this._hf = _hf;
+  }
+};
+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());
+
+// packages/plugins/plugin-sheet/src/model/model.ts
+var __dxlog_file4 = "/home/runner/work/dxos/dxos/packages/plugins/plugin-sheet/src/model/model.ts";
+var DEFAULT_ROWS = 100;
+var DEFAULT_COLUMNS = 26;
+var typeMap = {
+  BOOLEAN: ValueTypeEnum.Boolean,
+  NUMBER_RAW: ValueTypeEnum.Number,
+  NUMBER_PERCENT: ValueTypeEnum.Percent,
+  NUMBER_CURRENCY: ValueTypeEnum.Currency,
+  NUMBER_DATETIME: ValueTypeEnum.DateTime,
+  NUMBER_DATE: ValueTypeEnum.Date,
+  NUMBER_TIME: ValueTypeEnum.Time
+};
+var defaultOptions = {
+  rows: 50,
+  columns: 26,
+  mapFormulaBindingFromId: () => (formula) => formula,
+  mapFormulaBindingToId: () => (formula) => formula
+};
+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, _space, options = {}) {
+    this._graph = _graph;
+    this._sheet = _sheet;
     this._space = _space;
-    this._options = _options;
-    this.id = `graph-${PublicKey.random().truncate()}`;
-    this._nodes = /* @__PURE__ */ new Map();
+    this.id = `model-${PublicKey2.random().truncate()}`;
+    this._ctx = void 0;
     this._functions = [];
-    this.context = new FunctionContext(this._hf, this._space, this.refresh.bind(this), this._options);
     this.update = new Event2();
-    this._hf.updateConfig({
-      context: this.context
-    });
+    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();
   }
-  // TODO(burdon): Remove.
-  get hf() {
-    return this._hf;
+  get graph() {
+    return this._graph;
   }
-  refresh() {
-    log3("refresh", {
-      id: this.id
-    }, {
-      F: __dxlog_file3,
-      L: 152,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    this.update.emit();
+  get sheet() {
+    return this._sheet;
+  }
+  get readonly() {
+    return this._options.readonly;
+  }
+  get bounds() {
+    return {
+      rows: this._sheet.rows.length,
+      columns: this._sheet.columns.length
+    };
   }
-  getFunctions({ standard = true, echo = true } = {}) {
+  get functions() {
+    const hfFunctions = this._graph.hf.getRegisteredFunctionNames().map((name) => defaultFunctions.find((fn) => fn.name === name) ?? {
+      name
+    });
+    const echoFunctions = this._functions.map((fn) => ({
+      name: fn.binding
+    }));
     return [
-      ...standard ? this._hf.getRegisteredFunctionNames().map((name) => defaultFunctions.find((fn) => fn.name === name) ?? {
-        name
-      }) : [],
-      ...echo ? this._functions.map((fn) => ({
-        name: fn.binding
-      })) : []
+      ...hfFunctions,
+      ...echoFunctions
     ];
   }
+  get initialized() {
+    return !!this._ctx;
+  }
   /**
-  * Get or create cell representing a sheet.
+  * Initialize sheet and engine.
   */
-  // TODO(burdon): Async (open node).
-  //  The graph should be an extensible factory that plugins extend with model constructors.
-  //  This would enable on-the-fly instantiation of new models when then are referenced.
-  //  E.g., Cross-object reference would be stored as "ObjectId!A1"
-  //  The graph would then load the object and create a ComputeNode (model) of the appropriate type.
-  getOrCreateNode(name) {
-    invariant(name.length, void 0, {
-      F: __dxlog_file3,
-      L: 176,
+  async initialize() {
+    log3("initialize", {
+      id: this.id
+    }, {
+      F: __dxlog_file4,
+      L: 142,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    invariant2(!this.initialized, "Already initialized.", {
+      F: __dxlog_file4,
+      L: 143,
       S: this,
       A: [
-        "name.length",
-        ""
+        "!this.initialized",
+        "'Already initialized.'"
       ]
     });
-    if (!this._hf.doesSheetExist(name)) {
-      log3.info("created node", {
-        space: this._space?.id,
-        name
-      }, {
-        F: __dxlog_file3,
-        L: 178,
-        S: this,
-        C: (f, a) => f(...a)
+    this._ctx = new Context(void 0, {
+      F: __dxlog_file4,
+      L: 144
+    });
+    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);
+    if (this._space) {
+      const { Filter } = await import("@dxos/client/echo");
+      const { FunctionType } = await import("@dxos/plugin-script/types");
+      const query = this._space?.db.query(Filter.schema(FunctionType));
+      const unsubscribe2 = query.subscribe(({ objects }) => {
+        this._functions = objects.filter((fn) => fn.binding);
+        this.update.emit();
       });
-      this._hf.addSheet(name);
-      this.update.emit();
+      this._ctx.onDispose(unsubscribe2);
     }
-    const sheetId = this._hf.getSheetId(name);
-    invariant(sheetId !== void 0, void 0, {
-      F: __dxlog_file3,
-      L: 184,
+    return this;
+  }
+  async destroy() {
+    log3("destroy", {
+      id: this.id
+    }, {
+      F: __dxlog_file4,
+      L: 174,
       S: this,
-      A: [
-        "sheetId !== undefined",
-        ""
+      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.mapFormulaBindingToFormula(this.mapFormulaBindingFromId(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 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.mapFormulaBindingFromId(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 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
+    }, [
+      [
+        typeof value === "string" && value.charAt(0) === "=" ? this.mapFormulaBindingToFormula(value) : 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.mapFormulaBindingToId(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);
     });
-    const node = new ComputeNode(this, sheetId);
-    this._nodes.set(sheetId, node);
-    return node;
   }
   /**
-  * Map bound value to custom function invocation.
-  * E.g., "HELLO(...args)" => "EDGE("HELLO", ...args)".
+  * Iterate range.
   */
-  mapFormulaToNative(formula) {
-    return formula.replace(/['"]?([ \w]+)['"]?!/, (_match, name) => {
-      if (name) {
-        const objects = this._hf.getSheetNames().map((name2) => {
-          const id = getSheetId(name2);
-          return id ? this._space?.db.getObjectById(id) : void 0;
-        }).filter(nonNullable2);
-        for (const obj of objects) {
-          if (obj.name === name || obj.title === name) {
-            return `${createSheetName(obj.id)}!`;
-          }
+  _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);
         }
       }
-      return `${name}!`;
-    }).replace(/(\w+)\((.*)\)/g, (match, binding, args) => {
+      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
+    };
+  }
+  /**
+  * E.g., "HELLO()" => "EDGE("HELLO")".
+  */
+  mapFormulaBindingToFormula(formula) {
+    return formula.replace(/([a-zA-Z0-9]+)\((.*)\)/g, (match, binding, args) => {
       const fn = this._functions.find((fn2) => fn2.binding === binding);
       if (!fn) {
         return match;
       }
       if (args.trim() === "") {
-        return `${CUSTOM_FUNCTION}("${binding}")`;
-      } else {
-        return `${CUSTOM_FUNCTION}("${binding}", ${args})`;
+        return `EDGE("${binding}")`;
       }
+      return `EDGE("${binding}", ${args})`;
     });
   }
   /**
-  * Map from binding to fully qualified ECHO ID (to store).
-  * E.g., HELLO() => spaceId:objectId()
+  * E.g., "EDGE("HELLO")" => "HELLO()".
   */
-  mapFunctionBindingToId(formula) {
-    return formula.replace(/(\w+)\((.*)\)/g, (match, binding, args) => {
-      if (binding === CUSTOM_FUNCTION || defaultFunctions.find((fn2) => fn2.name === binding)) {
-        return match;
-      }
-      const fn = this._functions.find((fn2) => fn2.binding === binding);
-      if (fn) {
-        const id = fullyQualifiedId(fn);
-        return `${id}(${args})`;
-      } else {
-        return match;
+  mapFormulaBindingFromFormula(formula) {
+    return formula.replace(/EDGE\("([a-zA-Z0-9]+)"(.*)\)/, (_match, binding, args) => {
+      if (args.trim() === "") {
+        return `${binding}()`;
       }
+      return `${binding}(${args.slice(2)})`;
     });
   }
   /**
-  * Map from fully qualified ECHO ID to binding (from store).
-  * E.g., spaceId:objectId() => HELLO()
+  * Map from binding to fully qualified ECHO ID.
   */
-  mapFunctionBindingFromId(formula) {
-    return formula.replace(/(\w+):([a-zA-Z0-9]+)\((.*)\)/g, (match, spaceId, objectId, args) => {
-      const id = `${spaceId}:${objectId}`;
-      if (id.length !== OBJECT_ID_LENGTH) {
-        return match;
-      }
-      const fn = this._functions.find((fn2) => fullyQualifiedId(fn2) === id);
-      if (fn?.binding) {
-        return `${fn.binding}(${args})`;
-      } else {
-        return match;
+  mapFormulaBindingToId(formula) {
+    return this._options.mapFormulaBindingToId(this._functions)(formula);
+  }
+  /**
+  * Map from fully qualified ECHO ID to binding.
+  */
+  mapFormulaBindingFromId(formula) {
+    return this._options.mapFormulaBindingFromId(this._functions)(formula);
+  }
+  /**
+  * Map from A1 notation to indices.
+  */
+  mapFormulaRefsToIndices(formula) {
+    invariant2(formula.charAt(0) === "=", void 0, {
+      F: __dxlog_file4,
+      L: 509,
+      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) {
+    invariant2(formula.charAt(0) === "=", void 0, {
+      F: __dxlog_file4,
+      L: 519,
+      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);
+  }
+};
+
+// packages/plugins/plugin-sheet/src/components/ComputeGraph/custom.ts
+import { FunctionArgumentType } from "hyperformula";
+import { getDeep } from "@dxos/util";
+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 = getDeep(data, [
+        "bpi",
+        currency,
+        "rate"
+      ]);
+      if (!rate) {
+        return NaN;
       }
+      return parseNumberString(rate);
+    };
+    return this.runAsyncFunction(ast, state, handler, {
+      ttl: 1e4
     });
   }
-  async _open() {
-    if (this._space) {
-      const query = this._space.db.query(Filter2.schema(FunctionType2));
-      const unsubscribe = query.subscribe(({ objects }) => {
-        this._functions = objects.filter(({ binding }) => binding);
-        this.update.emit();
-      });
-      this._ctx.onDispose(unsubscribe);
-    }
+};
+CustomPlugin.implementedFunctions = {
+  TEST: {
+    method: "test",
+    parameters: [],
+    isVolatile: true
+  },
+  CRYPTO: {
+    method: "crypto",
+    parameters: [
+      {
+        argumentType: FunctionArgumentType.STRING,
+        optionalArg: true
+      }
+    ],
+    isVolatile: true
+  }
+};
+var CustomPluginTranslations = {
+  enGB: {
+    TEST: "TEST",
+    CRYPTO: "CRYPTO"
+  },
+  enUS: {
+    TEST: "TEST",
+    CRYPTO: "CRYPTO"
   }
 };
 
 export {
-  ComputeNode,
+  FunctionPluginAsync,
+  CustomPlugin,
+  CustomPluginTranslations,
+  createComputeGraph,
   defaultFunctions,
-  defaultOptions,
-  createSheetName,
-  getSheetId,
-  createComputeGraphRegistry,
-  ComputeGraphRegistry,
-  ComputeGraph
+  posEquals,
+  columnLetter,
+  addressToA1Notation,
+  addressFromA1Notation,
+  rangeToA1Notation,
+  inRange,
+  SheetModel
 };
-//# sourceMappingURL=chunk-D6KU5MI7.mjs.map
+//# sourceMappingURL=chunk-D5AGLXJP.mjs.map