@dxos/plugin-sheet 0.6.12 → 0.6.13-main.548ca8d

package/dist/lib/node/{chunk-5KKJ4NPP.cjs → chunk-5XPK2V4A.cjs}

@@ -26,45 +26,97 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var chunk_5KKJ4NPP_exports = {};
-__export(chunk_5KKJ4NPP_exports, {
-  CustomPlugin: () => CustomPlugin,
-  CustomPluginTranslations: () => CustomPluginTranslations,
-  FunctionPluginAsync: () => FunctionPluginAsync,
-  SheetModel: () => SheetModel,
-  addressFromA1Notation: () => addressFromA1Notation,
-  addressToA1Notation: () => addressToA1Notation,
-  columnLetter: () => columnLetter,
-  createComputeGraph: () => createComputeGraph,
+var chunk_5XPK2V4A_exports = {};
+__export(chunk_5XPK2V4A_exports, {
+  AsyncFunctionPlugin: () => AsyncFunctionPlugin,
+  ComputeGraph: () => ComputeGraph,
+  ComputeGraphRegistry: () => ComputeGraphRegistry,
+  ComputeNode: () => ComputeNode,
+  EDGE_FUNCTION_NAME: () => EDGE_FUNCTION_NAME,
+  EdgeFunctionPlugin: () => EdgeFunctionPlugin,
+  EdgeFunctionPluginTranslations: () => EdgeFunctionPluginTranslations,
+  FunctionContext: () => FunctionContext,
+  createSheetName: () => createSheetName,
+  defaultFunctionContextOptions: () => defaultFunctionContextOptions,
   defaultFunctions: () => defaultFunctions,
-  inRange: () => inRange,
-  posEquals: () => posEquals,
-  rangeToA1Notation: () => rangeToA1Notation
+  defaultOptions: () => defaultOptions,
+  defaultPlugins: () => defaultPlugins,
+  parseSheetName: () => parseSheetName
 });
-module.exports = __toCommonJS(chunk_5KKJ4NPP_exports);
-var import_chunk_DSYKOI4E = require("./chunk-DSYKOI4E.cjs");
-var import_hyperformula = require("hyperformula");
+module.exports = __toCommonJS(chunk_5XPK2V4A_exports);
 var import_async = require("@dxos/async");
+var import_echo = require("@dxos/client/echo");
+var import_context = require("@dxos/context");
+var import_echo_schema = require("@dxos/echo-schema");
+var import_invariant = require("@dxos/invariant");
 var import_keys = require("@dxos/keys");
 var import_log = require("@dxos/log");
-var import_hyperformula2 = require("hyperformula");
-var import_lodash = __toESM(require("lodash.defaultsdeep"));
+var import_types = require("@dxos/plugin-script/types");
+var import_util = require("@dxos/util");
+var import_hyperformula = require("#hyperformula");
 var import_async2 = require("@dxos/async");
-var import_log2 = require("@dxos/log");
-var import_hyperformula3 = require("hyperformula");
+var import_context2 = require("@dxos/context");
+var import_hyperformula2 = require("#hyperformula");
+var import_lodash = __toESM(require("lodash.defaultsdeep"));
 var import_async3 = require("@dxos/async");
-var import_context = require("@dxos/context");
-var import_invariant = require("@dxos/invariant");
-var import_keys2 = require("@dxos/keys");
+var import_log2 = require("@dxos/log");
+var import_hyperformula3 = require("#hyperformula");
+var import_signals_core = require("@preact/signals-core");
+var import_echo2 = require("@dxos/client/echo");
 var import_log3 = require("@dxos/log");
+var import_edge = require("@dxos/plugin-script/edge");
+var import_types2 = require("@dxos/plugin-script/types");
+var import_util2 = require("@dxos/util");
+var import_hyperformula4 = require("#hyperformula");
+var import_lodash2 = __toESM(require("lodash.defaultsdeep"));
+var import_context3 = require("@dxos/context");
 var import_invariant2 = require("@dxos/invariant");
-var import_crypto = require("@dxos/crypto");
-var import_hyperformula4 = require("hyperformula");
-var import_util = require("@dxos/util");
-var __dxlog_file = "/home/runner/work/dxos/dxos/packages/plugins/plugin-sheet/src/components/ComputeGraph/async-function.ts";
+var import_log4 = require("@dxos/log");
+var import_hyperformula5 = require("#hyperformula");
+var ComputeNode = class extends import_context2.Resource {
+  constructor(_graph, sheetId) {
+    super();
+    this._graph = _graph;
+    this.sheetId = sheetId;
+    this.update = new import_async2.Event();
+  }
+  get graph() {
+    return this._graph;
+  }
+  clear() {
+    this._graph.hf.clearSheet(this.sheetId);
+  }
+  getValue(cell) {
+    const value = this._graph.hf.getCellValue({
+      sheet: this.sheetId,
+      row: cell.row,
+      col: cell.col
+    });
+    if (value instanceof import_hyperformula2.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
+      ]
+    ]);
+  }
+  // TODO(burdon): Load data into sheet.
+  async _open() {
+  }
+};
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/plugins/plugin-sheet/src/graph/functions/async-function.ts";
 var defaultFunctionContextOptions = {
   defaultTtl: 5e3,
-  recalculationDelay: 200,
+  debounceDelay: 200,
   remoteFunctionUrl: "https://edge.dxos.workers.dev/functions"
 };
 var FunctionContext = class _FunctionContext {
@@ -75,7 +127,7 @@ var FunctionContext = class _FunctionContext {
       ...args
     });
   }
-  constructor(_hf, _space, onUpdate, _options) {
+  constructor(_hf, _space, _options) {
     this._hf = _hf;
     this._space = _space;
     this._cache = /* @__PURE__ */ new Map();
@@ -83,10 +135,10 @@ var FunctionContext = class _FunctionContext {
     this._subscriptions = /* @__PURE__ */ new Map();
     this._invocations = {};
     this._options = (0, import_lodash.default)(_options ?? {}, defaultFunctionContextOptions);
-    this._onUpdate = (0, import_async2.debounce)(() => {
+    this._onUpdate = (0, import_async3.debounce)((update) => {
       this._hf.resumeEvaluation();
-      onUpdate(this);
-    }, this._options.recalculationDelay);
+      this._options.onUpdate?.(update);
+    }, this._options.debounceDelay);
   }
   get space() {
     return this._space;
@@ -136,23 +188,26 @@ var FunctionContext = class _FunctionContext {
             value: value2
           }, {
             F: __dxlog_file,
-            L: 136,
+            L: 143,
             S: this,
             C: (f, a) => f(...a)
           });
-          this._onUpdate();
+          this._onUpdate({
+            name,
+            cell
+          });
         } catch (err) {
           import_log2.log.warn("failed", {
             cell,
             err
           }, {
             F: __dxlog_file,
-            L: 140,
+            L: 147,
             S: this,
             C: (f, a) => f(...a)
           });
           this._cache.set(invocationKey, {
-            value: new import_hyperformula2.CellError(import_hyperformula2.ErrorType.ERROR, "Function failed."),
+            value: new import_hyperformula3.CellError(import_hyperformula3.ErrorType.ERROR, "Function failed."),
             ts: Date.now()
           });
         } finally {
@@ -167,59 +222,137 @@ var FunctionContext = class _FunctionContext {
       cache: value
     }, {
       F: __dxlog_file,
-      L: 148,
+      L: 155,
       S: this,
       C: (f, a) => f(...a)
     });
     return value;
   }
 };
-var FunctionPluginAsync = class extends import_hyperformula2.FunctionPlugin {
+var AsyncFunctionPlugin = class extends import_hyperformula3.FunctionPlugin {
   get context() {
     return this.config.context;
   }
+  /**
+  * Immediately returns cached value then runs the async function.
+  */
   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;
+      return this.context.invokeFunction(procedureName, state, args, cb, options) ?? import_hyperformula3.EmptyValue;
     });
   }
 };
-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 }) => {
-    import_hyperformula.HyperFormula.registerFunctionPlugin(plugin, translations);
-  });
-  const hf = import_hyperformula.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-${import_keys.PublicKey.random().truncate()}`;
-    this.update = new import_async.Event();
-    this.context = new FunctionContext(this.hf, this._space, () => {
-      this.refresh();
-    }, this._options);
-    this.hf.updateConfig({
-      context: this.context
+var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/plugins/plugin-sheet/src/graph/functions/edge-function.ts";
+var EDGE_FUNCTION_NAME = "DX";
+var FUNCTION_TTL = 1e4;
+var EdgeFunctionPlugin = class extends AsyncFunctionPlugin {
+  dx(ast, state) {
+    const handler = (subscribe = false) => async (binding, ...args) => {
+      const space = this.context.space;
+      if (!space) {
+        return new import_hyperformula4.CellError(import_hyperformula4.ErrorType.REF, "Missing space");
+      }
+      const { objects: [fn] } = await space.db.query(import_echo2.Filter.schema(import_types2.FunctionType, {
+        binding
+      })).run();
+      if (!fn) {
+        import_log3.log.info("Function not found", {
+          binding
+        }, {
+          F: __dxlog_file2,
+          L: 41,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        return new import_hyperformula4.CellError(import_hyperformula4.ErrorType.REF, "Function not found");
+      }
+      if (subscribe) {
+        const unsubscribe = (0, import_signals_core.effect)(() => {
+          import_log3.log.info("function changed", {
+            fn
+          }, {
+            F: __dxlog_file2,
+            L: 47,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          const _ = fn?.version;
+          this.runAsyncFunction(ast, state, handler(false), {
+            ttl: FUNCTION_TTL
+          });
+        });
+        this.context.createSubscription(ast.procedureName, unsubscribe);
+      }
+      const path = (0, import_edge.getUserFunctionUrlInMetadata)((0, import_echo2.getMeta)(fn));
+      const result = await fetch(`${this.context.remoteFunctionUrl}${path}`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          args: args.filter(import_util2.nonNullable)
+        })
+      });
+      return await result.text();
+    };
+    return this.runAsyncFunction(ast, state, handler(true), {
+      ttl: FUNCTION_TTL
     });
   }
-  refresh() {
-    (0, import_log.log)("refresh", {
-      id: this.id
-    }, {
-      F: __dxlog_file2,
-      L: 59,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    this.update.emit();
+};
+EdgeFunctionPlugin.implementedFunctions = {
+  [EDGE_FUNCTION_NAME]: {
+    method: "dx",
+    parameters: [
+      // Binding
+      {
+        argumentType: import_hyperformula4.FunctionArgumentType.STRING
+      },
+      // Remote function arguments (currently supporting up to 8).
+      {
+        argumentType: import_hyperformula4.FunctionArgumentType.ANY,
+        optionalArg: true
+      },
+      {
+        argumentType: import_hyperformula4.FunctionArgumentType.ANY,
+        optionalArg: true
+      },
+      {
+        argumentType: import_hyperformula4.FunctionArgumentType.ANY,
+        optionalArg: true
+      },
+      {
+        argumentType: import_hyperformula4.FunctionArgumentType.ANY,
+        optionalArg: true
+      },
+      {
+        argumentType: import_hyperformula4.FunctionArgumentType.ANY,
+        optionalArg: true
+      },
+      {
+        argumentType: import_hyperformula4.FunctionArgumentType.ANY,
+        optionalArg: true
+      },
+      {
+        argumentType: import_hyperformula4.FunctionArgumentType.ANY,
+        optionalArg: true
+      },
+      {
+        argumentType: import_hyperformula4.FunctionArgumentType.ANY,
+        optionalArg: true
+      }
+    ],
+    isVolatile: true
+  }
+};
+var EdgeFunctionPluginTranslations = {
+  enGB: {
+    [EDGE_FUNCTION_NAME]: "Remote function"
+  },
+  enUS: {
+    [EDGE_FUNCTION_NAME]: "Remote function"
   }
 };
 var defaultFunctions = [
@@ -2594,666 +2727,273 @@ var defaultFunctions = [
     section: "Text"
   }
 ];
-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_invariant2.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_invariant2.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 __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/plugins/plugin-sheet/src/graph/compute-graph.ts";
+var OBJECT_ID_LENGTH = 60;
+var createSheetName = ({ type, id }) => `${type}@${id}`;
+var parseSheetName = (name) => {
+  const [type, id] = name.split("@");
+  return id ? {
+    type,
+    id
+  } : {
+    id: type
   };
 };
-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) {
+var ComputeGraph = class extends import_context.Resource {
+  constructor(_hf, _space, _options) {
     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 = 100;
-var DEFAULT_COLUMNS = 26;
-var typeMap = {
-  BOOLEAN: import_chunk_DSYKOI4E.ValueTypeEnum.Boolean,
-  NUMBER_RAW: import_chunk_DSYKOI4E.ValueTypeEnum.Number,
-  NUMBER_PERCENT: import_chunk_DSYKOI4E.ValueTypeEnum.Percent,
-  NUMBER_CURRENCY: import_chunk_DSYKOI4E.ValueTypeEnum.Currency,
-  NUMBER_DATETIME: import_chunk_DSYKOI4E.ValueTypeEnum.DateTime,
-  NUMBER_DATE: import_chunk_DSYKOI4E.ValueTypeEnum.Date,
-  NUMBER_TIME: import_chunk_DSYKOI4E.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._hf = _hf;
     this._space = _space;
-    this.id = `model-${import_keys2.PublicKey.random().truncate()}`;
-    this._ctx = void 0;
-    this._functions = [];
-    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._options = _options;
+    this.id = `graph-${import_keys.PublicKey.random().truncate()}`;
+    this._nodes = /* @__PURE__ */ new Map();
+    this._remoteFunctions = [];
+    this.update = new import_async.Event();
+    this.context = new FunctionContext(this._hf, this._space, this._options);
+    this._hf.updateConfig({
+      context: this.context
+    });
+    const onValuesUpdate = (changes) => {
+      for (const change of changes) {
+        if (change instanceof import_hyperformula.ExportedCellChange) {
+          const { sheet } = change;
+          const node = this._nodes.get(sheet);
+          if (node) {
+            node.update.emit({
+              type: "valuesUpdated",
+              change
+            });
+          }
+        }
+      }
     };
-    this.reset();
-  }
-  get graph() {
-    return this._graph;
-  }
-  get sheet() {
-    return this._sheet;
+    this._hf.on("valuesUpdated", onValuesUpdate);
+    this._ctx.onDispose(() => this._hf.off("valuesUpdated", onValuesUpdate));
   }
-  get readonly() {
-    return this._options.readonly;
+  get hf() {
+    return this._hf;
   }
-  get bounds() {
-    return {
-      rows: this._sheet.rows.length,
-      columns: this._sheet.columns.length
-    };
-  }
-  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
-    }));
+  getFunctions({ standard, echo } = {
+    standard: true,
+    echo: true
+  }) {
     return [
-      ...hfFunctions,
-      ...echoFunctions
+      ...standard ? this._hf.getRegisteredFunctionNames().map((name) => defaultFunctions.find((fn) => fn.name === name) ?? {
+        name
+      }) : [],
+      ...echo ? this._remoteFunctions.map((fn) => ({
+        name: fn.binding
+      })) : []
     ];
   }
-  get initialized() {
-    return !!this._ctx;
-  }
   /**
-  * Initialize sheet and engine.
+  * Get or create cell representing a sheet.
   */
-  async initialize() {
-    (0, import_log3.log)("initialize", {
-      id: this.id
-    }, {
-      F: __dxlog_file4,
-      L: 142,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    (0, import_invariant.invariant)(!this.initialized, "Already initialized.", {
-      F: __dxlog_file4,
-      L: 143,
+  // 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) {
+    (0, import_invariant.invariant)(name.length, void 0, {
+      F: __dxlog_file3,
+      L: 117,
       S: this,
       A: [
-        "!this.initialized",
-        "'Already initialized.'"
+        "name.length",
+        ""
       ]
     });
-    this._ctx = new import_context.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();
+    if (!this._hf.doesSheetExist(name)) {
+      import_log.log.info("created node", {
+        space: this._space?.id,
+        sheet: name
+      }, {
+        F: __dxlog_file3,
+        L: 119,
+        S: this,
+        C: (f, a) => f(...a)
       });
-      this._ctx.onDispose(unsubscribe2);
+      this._hf.addSheet(name);
     }
-    return this;
-  }
-  async destroy() {
-    (0, import_log3.log)("destroy", {
-      id: this.id
-    }, {
-      F: __dxlog_file4,
-      L: 174,
+    const sheetId = this._hf.getSheetId(name);
+    (0, import_invariant.invariant)(sheetId !== void 0, void 0, {
+      F: __dxlog_file3,
+      L: 124,
       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.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 import_hyperformula3.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 import_hyperformula3.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
+      A: [
+        "sheetId !== undefined",
+        ""
       ]
-    ]);
-    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;
   }
   /**
-  * Iterate range.
+  * Map bound value to custom function invocation.
+  * E.g., "HELLO(...args)" => "EDGE("HELLO", ...args)".
   */
-  _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);
+  mapFormulaToNative(formula) {
+    return formula.replace(/['"]?([ \w]+)['"]?!/, (_match, name) => {
+      if (name) {
+        const objects = this._hf.getSheetNames().map((name2) => {
+          const { type, id } = parseSheetName(name2);
+          return type && id ? this._space?.db.getObjectById(id) : void 0;
+        }).filter(import_util.nonNullable);
+        for (const obj of objects) {
+          if (obj.name === name) {
+            const type = (0, import_echo_schema.getTypename)(obj);
+            return `'${createSheetName({
+              type,
+              id: obj.id
+            })}'!`;
+          }
         }
       }
-      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);
+      return `${name}!`;
+    }).replace(/(\w+)\((.*)\)/g, (match, binding, args) => {
+      const fn = this._remoteFunctions.find((fn2) => fn2.binding === binding);
       if (!fn) {
         return match;
       }
       if (args.trim() === "") {
-        return `EDGE("${binding}")`;
+        return `${EDGE_FUNCTION_NAME}("${binding}")`;
+      } else {
+        return `${EDGE_FUNCTION_NAME}("${binding}", ${args})`;
       }
-      return `EDGE("${binding}", ${args})`;
     });
   }
   /**
-  * E.g., "EDGE("HELLO")" => "HELLO()".
+  * Map from binding to fully qualified ECHO ID (to store).
+  * E.g., HELLO() => spaceId:objectId()
   */
-  mapFormulaBindingFromFormula(formula) {
-    return formula.replace(/EDGE\("([a-zA-Z0-9]+)"(.*)\)/, (_match, binding, args) => {
-      if (args.trim() === "") {
-        return `${binding}()`;
+  mapFunctionBindingToId(formula) {
+    return formula.replace(/(\w+)\((.*)\)/g, (match, binding, args) => {
+      if (binding === EDGE_FUNCTION_NAME || defaultFunctions.find((fn2) => fn2.name === binding)) {
+        return match;
+      }
+      const fn = this._remoteFunctions.find((fn2) => fn2.binding === binding);
+      if (fn) {
+        const id = (0, import_echo.fullyQualifiedId)(fn);
+        return `${id}(${args})`;
+      } else {
+        return match;
       }
-      return `${binding}(${args.slice(2)})`;
-    });
-  }
-  /**
-  * Map from binding to fully qualified ECHO ID.
-  */
-  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) {
-    (0, import_invariant.invariant)(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.
+  * Map from fully qualified ECHO ID to binding (from store).
+  * E.g., spaceId:objectId() => HELLO()
   */
-  mapFormulaIndicesToRefs(formula) {
-    (0, import_invariant.invariant)(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));
+  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._remoteFunctions.find((fn2) => (0, import_echo.fullyQualifiedId)(fn2) === id);
+      if (fn?.binding) {
+        return `${fn.binding}(${args})`;
+      } else {
+        return match;
+      }
     });
   }
-  //
-  // 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);
+  async _open() {
+    if (this._space) {
+      const query = this._space.db.query(import_echo.Filter.schema(import_types.FunctionType));
+      const unsubscribe = query.subscribe(({ objects }) => {
+        this._remoteFunctions = objects.filter(({ binding }) => binding);
+        this.update.emit({
+          type: "functionsUpdated"
+        });
+      });
+      this._ctx.onDispose(unsubscribe);
+    }
   }
-  toTime(num) {
-    return this._graph.hf.numberToTime(num);
+  async _close() {
+    for (const node of this._nodes.values()) {
+      await node.close();
+    }
   }
 };
-var parseNumberString = (str) => {
-  return parseFloat(str.replace(/[^\d.]/g, ""));
+var __dxlog_file4 = "/home/runner/work/dxos/dxos/packages/plugins/plugin-sheet/src/graph/compute-graph-registry.ts";
+var defaultOptions = {
+  licenseKey: "gpl-v3"
 };
-var CustomPlugin = class extends FunctionPluginAsync {
-  test(ast, state) {
-    const handler = async () => {
-      return Math.random();
-    };
-    return this.runAsyncFunction(ast, state, handler);
+var defaultPlugins = [
+  {
+    plugin: EdgeFunctionPlugin,
+    translations: EdgeFunctionPluginTranslations
   }
-  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
+];
+var ComputeGraphRegistry = class extends import_context3.Resource {
+  constructor(options = {
+    plugins: defaultPlugins
+  }) {
+    super();
+    this._graphs = /* @__PURE__ */ new Map();
+    this._options = (0, import_lodash2.default)({}, options, defaultOptions);
+    this._options.plugins?.forEach(({ plugin, translations }) => {
+      import_hyperformula5.HyperFormula.registerFunctionPlugin(plugin, translations);
     });
   }
-};
-CustomPlugin.implementedFunctions = {
-  TEST: {
-    method: "test",
-    parameters: [],
-    isVolatile: true
-  },
-  CRYPTO: {
-    method: "crypto",
-    parameters: [
-      {
-        argumentType: import_hyperformula4.FunctionArgumentType.STRING,
-        optionalArg: true
-      }
-    ],
-    isVolatile: true
+  getGraph(spaceId) {
+    return this._graphs.get(spaceId);
+  }
+  getOrCreateGraph(space) {
+    let graph = this._graphs.get(space.id);
+    if (!graph) {
+      (0, import_log4.log)("create graph", {
+        space: space.id
+      }, {
+        F: __dxlog_file4,
+        L: 69,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      graph = this.createGraph(space);
+    }
+    return graph;
   }
-};
-var CustomPluginTranslations = {
-  enGB: {
-    TEST: "TEST",
-    CRYPTO: "CRYPTO"
-  },
-  enUS: {
-    TEST: "TEST",
-    CRYPTO: "CRYPTO"
+  createGraph(space) {
+    (0, import_invariant2.invariant)(!this._graphs.has(space.id), `ComputeGraph already exists for space: ${space.id}`, {
+      F: __dxlog_file4,
+      L: 77,
+      S: this,
+      A: [
+        "!this._graphs.has(space.id)",
+        "`ComputeGraph already exists for space: ${space.id}`"
+      ]
+    });
+    const hf = import_hyperformula5.HyperFormula.buildEmpty(this._options);
+    const graph = new ComputeGraph(hf, space, this._options);
+    this._graphs.set(space.id, graph);
+    return graph;
+  }
+  async _close() {
+    for (const graph of this._graphs.values()) {
+      await graph.close();
+    }
+    this._graphs.clear();
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  CustomPlugin,
-  CustomPluginTranslations,
-  FunctionPluginAsync,
-  SheetModel,
-  addressFromA1Notation,
-  addressToA1Notation,
-  columnLetter,
-  createComputeGraph,
+  AsyncFunctionPlugin,
+  ComputeGraph,
+  ComputeGraphRegistry,
+  ComputeNode,
+  EDGE_FUNCTION_NAME,
+  EdgeFunctionPlugin,
+  EdgeFunctionPluginTranslations,
+  FunctionContext,
+  createSheetName,
+  defaultFunctionContextOptions,
   defaultFunctions,
-  inRange,
-  posEquals,
-  rangeToA1Notation
+  defaultOptions,
+  defaultPlugins,
+  parseSheetName
 });
-//# sourceMappingURL=chunk-5KKJ4NPP.cjs.map
+//# sourceMappingURL=chunk-5XPK2V4A.cjs.map