@ricsam/formula-engine 0.0.1

package/README.md

@@ -0,0 +1,100 @@
+# FormulaEngine
+
+A TypeScript-based spreadsheet formula evaluation library designed for high-performance calculation of formulas across sparse datasets.
+
+## Features
+
+- **Sparse-aware architecture** - Only populated cells consume memory
+- **Map-based storage** - O(1) cell access with automatic sparse handling
+- **Excel-compatible** addressing (A1 notation)
+- **Multi-sheet support** with sheet management
+- **Named expressions** with global and sheet-level scoping
+- **Undo/redo system** with command pattern
+- **Copy/paste operations** with clipboard support
+- **TypeScript-first** design with comprehensive type safety
+
+## Installation
+
+```bash
+bun install
+```
+
+## Quick Start
+
+```typescript
+import { FormulaEngine } from 'formula-engine';
+
+// Create a new engine
+const engine = FormulaEngine.buildEmpty();
+
+// Add a sheet
+const sheetName = engine.addSheet('Sheet1');
+const sheetId = engine.getSheetId(sheetName);
+
+// Set cell values
+engine.setCellContent({ sheet: sheetId, col: 0, row: 0 }, 42);
+engine.setCellContent({ sheet: sheetId, col: 1, row: 0 }, 58);
+
+// Set a formula (evaluation not yet implemented)
+engine.setCellContent({ sheet: sheetId, col: 2, row: 0 }, '=A1+B1');
+
+// Get cell value
+const value = engine.getCellValue({ sheet: sheetId, col: 0, row: 0 }); // 42
+
+// Set multiple values at once
+engine.setCellContent({ sheet: sheetId, col: 0, row: 2 }, [
+  [1, 2, 3],
+  [4, 5, 6],
+  [7, 8, 9]
+]);
+
+// Get range values
+const range = {
+  start: { sheet: sheetId, col: 0, row: 2 },
+  end: { sheet: sheetId, col: 2, row: 4 }
+};
+const values = engine.getRangeValues(range); // [[1,2,3],[4,5,6],[7,8,9]]
+```
+
+## Development Status
+
+### ✅ Completed
+- Core type system and interfaces
+- Basic engine structure with sheet management
+- Cell addressing system (A1 notation)
+- Sparse data storage with Map-based implementation
+- Copy/paste operations
+- Named expressions (storage only)
+- Undo/redo infrastructure
+
+### 🚧 In Progress
+- Formula parser and lexer
+- Formula evaluation engine
+- Dependency tracking system
+- Array formula support
+
+### 📋 Planned
+- Function library (SUM, AVERAGE, etc.)
+- Array formulas with broadcasting
+- Comprehensive error handling
+- React hooks for integration
+- Performance optimizations
+
+## Running Tests
+
+```bash
+bun test
+```
+
+## Architecture
+
+FormulaEngine uses a sparse-aware architecture optimized for spreadsheets where most cells are empty:
+
+- **Sheets** store cells in a `Map<string, Cell>` structure
+- **Addresses** use zero-based indexing internally, A1 notation externally
+- **Formulas** will be parsed into ASTs for efficient evaluation
+- **Dependencies** will be tracked in a directed acyclic graph
+
+## License
+
+MIT

package/dist/cjs/core/ast-traverser.cjs

@@ -0,0 +1,124 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/core/ast-traverser.ts
+var exports_ast_traverser = {};
+__export(exports_ast_traverser, {
+  traverseAST: () => traverseAST,
+  transformAST: () => transformAST,
+  findNodesByType: () => findNodesByType
+});
+module.exports = __toCommonJS(exports_ast_traverser);
+function traverseAST(node, visitor, parent) {
+  visitor(node, parent);
+  switch (node.type) {
+    case "binary-op":
+      traverseAST(node.left, visitor, node);
+      traverseAST(node.right, visitor, node);
+      break;
+    case "unary-op":
+      traverseAST(node.operand, visitor, node);
+      break;
+    case "function":
+      node.args.forEach((arg) => traverseAST(arg, visitor, node));
+      break;
+    case "array":
+      node.elements.forEach((row) => row.forEach((element) => traverseAST(element, visitor, node)));
+      break;
+    case "range":
+      break;
+    case "3d-range":
+      traverseAST(node.reference, visitor, node);
+      break;
+    case "structured-reference":
+    case "reference":
+    case "value":
+    case "named-expression":
+    case "error":
+    case "empty":
+    case "infinity":
+      break;
+    default:
+      console.warn(`Unknown AST node type: ${node.type}`);
+      break;
+  }
+}
+function findNodesByType(node, nodeType) {
+  const results = [];
+  traverseAST(node, (currentNode) => {
+    if (currentNode.type === nodeType) {
+      results.push(currentNode);
+    }
+  });
+  return results;
+}
+function transformAST(node, transformer) {
+  const transform = (currentNode, parent) => {
+    let transformedNode;
+    switch (currentNode.type) {
+      case "binary-op":
+        transformedNode = {
+          ...currentNode,
+          left: transform(currentNode.left, currentNode),
+          right: transform(currentNode.right, currentNode)
+        };
+        break;
+      case "unary-op":
+        transformedNode = {
+          ...currentNode,
+          operand: transform(currentNode.operand, currentNode)
+        };
+        break;
+      case "function":
+        transformedNode = {
+          ...currentNode,
+          args: currentNode.args.map((arg) => transform(arg, currentNode))
+        };
+        break;
+      case "array":
+        transformedNode = {
+          ...currentNode,
+          elements: currentNode.elements.map((row) => row.map((element) => transform(element, currentNode)))
+        };
+        break;
+      case "3d-range":
+        transformedNode = {
+          ...currentNode,
+          reference: transform(currentNode.reference, currentNode)
+        };
+        break;
+      default:
+        transformedNode = { ...currentNode };
+        break;
+    }
+    return transformer(transformedNode, parent);
+  };
+  return transform(node);
+}
+
+//# debugId=72C5270156299F0064756E2164756E21

package/dist/cjs/core/ast-traverser.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../src/core/ast-traverser.ts"],
+  "sourcesContent": [
+    "import type { ASTNode } from \"../parser/ast.cjs\";\n\n/**\n * Visitor function type for AST traversal\n */\nexport type ASTVisitor<T = void> = (node: ASTNode, parent?: ASTNode) => T;\n\n/**\n * Traverses an AST node and all its children, calling the visitor function for each node\n * @param node - The AST node to traverse\n * @param visitor - Function called for each node during traversal\n * @param parent - The parent node (used internally for recursion)\n */\nexport function traverseAST<T = void>(\n  node: ASTNode,\n  visitor: ASTVisitor<T>,\n  parent?: ASTNode\n): void {\n  // Visit the current node\n  visitor(node, parent);\n\n  // Recursively traverse children based on node type\n  switch (node.type) {\n    case \"binary-op\":\n      traverseAST(node.left, visitor, node);\n      traverseAST(node.right, visitor, node);\n      break;\n\n    case \"unary-op\":\n      traverseAST(node.operand, visitor, node);\n      break;\n\n    case \"function\":\n      node.args.forEach((arg) => traverseAST(arg, visitor, node));\n      break;\n\n    case \"array\":\n      node.elements.forEach((row) =>\n        row.forEach((element) => traverseAST(element, visitor, node))\n      );\n      break;\n\n    case \"range\":\n      // Range nodes don't have start/end child nodes in this AST structure\n      // They have a range property with coordinates\n      break;\n\n    case \"3d-range\":\n      traverseAST(node.reference, visitor, node);\n      break;\n\n    case \"structured-reference\":\n    case \"reference\":\n    case \"value\":\n    case \"named-expression\":\n    case \"error\":\n    case \"empty\":\n    case \"infinity\":\n      // These are leaf nodes, no children to traverse\n      break;\n\n    default:\n      // Handle any unknown node types gracefully\n      console.warn(`Unknown AST node type: ${(node as any).type}`);\n      break;\n  }\n}\n\n/**\n * Finds all nodes of a specific type in an AST\n * @param node - The root AST node to search\n * @param nodeType - The type of nodes to find\n * @returns Array of nodes matching the specified type\n */\nexport function findNodesByType<T extends ASTNode[\"type\"]>(\n  node: ASTNode,\n  nodeType: T\n): Extract<ASTNode, { type: T }>[] {\n  const results: Extract<ASTNode, { type: T }>[] = [];\n\n  traverseAST(node, (currentNode) => {\n    if (currentNode.type === nodeType) {\n      results.push(currentNode as Extract<ASTNode, { type: T }>);\n    }\n  });\n\n  return results;\n}\n\n/**\n * Transforms an AST by applying a transformation function to each node\n * @param node - The AST node to transform\n * @param transformer - Function that transforms each node\n * @returns The transformed AST\n */\nexport function transformAST(\n  node: ASTNode,\n  transformer: (node: ASTNode, parent?: ASTNode) => ASTNode\n): ASTNode {\n  const transform = (currentNode: ASTNode, parent?: ASTNode): ASTNode => {\n    // First transform children\n    let transformedNode: ASTNode;\n\n    switch (currentNode.type) {\n      case \"binary-op\":\n        transformedNode = {\n          ...currentNode,\n          left: transform(currentNode.left, currentNode),\n          right: transform(currentNode.right, currentNode),\n        };\n        break;\n\n      case \"unary-op\":\n        transformedNode = {\n          ...currentNode,\n          operand: transform(currentNode.operand, currentNode),\n        };\n        break;\n\n      case \"function\":\n        transformedNode = {\n          ...currentNode,\n          args: currentNode.args.map((arg) => transform(arg, currentNode)),\n        };\n        break;\n\n      case \"array\":\n        transformedNode = {\n          ...currentNode,\n          elements: currentNode.elements.map((row) =>\n            row.map((element) => transform(element, currentNode))\n          ),\n        };\n        break;\n\n      case \"3d-range\":\n        transformedNode = {\n          ...currentNode,\n          reference: transform(currentNode.reference, currentNode) as typeof currentNode.reference,\n        };\n        break;\n\n      default:\n        // Leaf nodes or unknown types - return as is\n        transformedNode = { ...currentNode };\n        break;\n    }\n\n    // Then apply the transformer to the current node\n    return transformer(transformedNode, parent);\n  };\n\n  return transform(node);\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAaO,SAAS,WAAqB,CACnC,MACA,SACA,QACM;AAAA,EAEN,QAAQ,MAAM,MAAM;AAAA,EAGpB,QAAQ,KAAK;AAAA,SACN;AAAA,MACH,YAAY,KAAK,MAAM,SAAS,IAAI;AAAA,MACpC,YAAY,KAAK,OAAO,SAAS,IAAI;AAAA,MACrC;AAAA,SAEG;AAAA,MACH,YAAY,KAAK,SAAS,SAAS,IAAI;AAAA,MACvC;AAAA,SAEG;AAAA,MACH,KAAK,KAAK,QAAQ,CAAC,QAAQ,YAAY,KAAK,SAAS,IAAI,CAAC;AAAA,MAC1D;AAAA,SAEG;AAAA,MACH,KAAK,SAAS,QAAQ,CAAC,QACrB,IAAI,QAAQ,CAAC,YAAY,YAAY,SAAS,SAAS,IAAI,CAAC,CAC9D;AAAA,MACA;AAAA,SAEG;AAAA,MAGH;AAAA,SAEG;AAAA,MACH,YAAY,KAAK,WAAW,SAAS,IAAI;AAAA,MACzC;AAAA,SAEG;AAAA,SACA;AAAA,SACA;AAAA,SACA;AAAA,SACA;AAAA,SACA;AAAA,SACA;AAAA,MAEH;AAAA;AAAA,MAIA,QAAQ,KAAK,0BAA2B,KAAa,MAAM;AAAA,MAC3D;AAAA;AAAA;AAUC,SAAS,eAA0C,CACxD,MACA,UACiC;AAAA,EACjC,MAAM,UAA2C,CAAC;AAAA,EAElD,YAAY,MAAM,CAAC,gBAAgB;AAAA,IACjC,IAAI,YAAY,SAAS,UAAU;AAAA,MACjC,QAAQ,KAAK,WAA4C;AAAA,IAC3D;AAAA,GACD;AAAA,EAED,OAAO;AAAA;AASF,SAAS,YAAY,CAC1B,MACA,aACS;AAAA,EACT,MAAM,YAAY,CAAC,aAAsB,WAA8B;AAAA,IAErE,IAAI;AAAA,IAEJ,QAAQ,YAAY;AAAA,WACb;AAAA,QACH,kBAAkB;AAAA,aACb;AAAA,UACH,MAAM,UAAU,YAAY,MAAM,WAAW;AAAA,UAC7C,OAAO,UAAU,YAAY,OAAO,WAAW;AAAA,QACjD;AAAA,QACA;AAAA,WAEG;AAAA,QACH,kBAAkB;AAAA,aACb;AAAA,UACH,SAAS,UAAU,YAAY,SAAS,WAAW;AAAA,QACrD;AAAA,QACA;AAAA,WAEG;AAAA,QACH,kBAAkB;AAAA,aACb;AAAA,UACH,MAAM,YAAY,KAAK,IAAI,CAAC,QAAQ,UAAU,KAAK,WAAW,CAAC;AAAA,QACjE;AAAA,QACA;AAAA,WAEG;AAAA,QACH,kBAAkB;AAAA,aACb;AAAA,UACH,UAAU,YAAY,SAAS,IAAI,CAAC,QAClC,IAAI,IAAI,CAAC,YAAY,UAAU,SAAS,WAAW,CAAC,CACtD;AAAA,QACF;AAAA,QACA;AAAA,WAEG;AAAA,QACH,kBAAkB;AAAA,aACb;AAAA,UACH,WAAW,UAAU,YAAY,WAAW,WAAW;AAAA,QACzD;AAAA,QACA;AAAA;AAAA,QAIA,kBAAkB,KAAK,YAAY;AAAA,QACnC;AAAA;AAAA,IAIJ,OAAO,YAAY,iBAAiB,MAAM;AAAA;AAAA,EAG5C,OAAO,UAAU,IAAI;AAAA;",
+  "debugId": "72C5270156299F0064756E2164756E21",
+  "names": []
+}

package/dist/cjs/core/autofill-utils.cjs

@@ -0,0 +1,304 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/core/autofill-utils.ts
+var exports_autofill_utils = {};
+__export(exports_autofill_utils, {
+  AutoFill: () => AutoFill
+});
+module.exports = __toCommonJS(exports_autofill_utils);
+var import_parser = require("../parser/parser.cjs");
+var import_formatter = require("../parser/formatter.cjs");
+var import_ast_traverser = require("./ast-traverser.cjs");
+var import_utils = require("./utils.cjs");
+
+class AutoFill {
+  workbookManager;
+  engine;
+  constructor(workbookManager, engine) {
+    this.workbookManager = workbookManager;
+    this.engine = engine;
+  }
+  toFiniteRange(range) {
+    if (range.end.col.type === "infinity" || range.end.row.type === "infinity") {
+      throw new Error("AutoFill with infinite ranges is not supported");
+    }
+    return {
+      start: range.start,
+      end: {
+        col: range.end.col.value,
+        row: range.end.row.value
+      }
+    };
+  }
+  getCellContent(address) {
+    const sheet = this.workbookManager.getSheet(address);
+    if (!sheet) {
+      throw new Error("Sheet not found");
+    }
+    return sheet.content.get(import_utils.getCellReference(address));
+  }
+  fill(opts, seedRange, fillRange, direction) {
+    const finiteSeedRange = this.toFiniteRange(seedRange);
+    const finiteFillRange = this.toFiniteRange(fillRange);
+    const seedCells = this.getSeedCells(opts, finiteSeedRange);
+    const changes = new Map;
+    const isSingleCell = seedCells.length === 1;
+    if (isSingleCell) {
+      const seedCell = seedCells[0];
+      if (seedCell) {
+        this.collectSingleCellPattern(seedCell, finiteFillRange, direction, changes);
+      }
+    } else {
+      this.collectMultiCellPattern(seedCells, finiteSeedRange, finiteFillRange, direction, changes);
+    }
+    const currentContent = this.workbookManager.getSheetSerialized(opts);
+    const newContent = new Map(currentContent);
+    changes.forEach((value, key) => {
+      if (value === undefined) {
+        newContent.delete(key);
+      } else {
+        newContent.set(key, value);
+      }
+    });
+    this.engine.setSheetContent(opts, newContent);
+  }
+  getSeedCells(opts, seedRange) {
+    const cells = [];
+    const startCol = seedRange.start.col;
+    const startRow = seedRange.start.row;
+    const endCol = seedRange.end.col;
+    const endRow = seedRange.end.row;
+    for (let row = startRow;row <= endRow; row++) {
+      for (let col = startCol;col <= endCol; col++) {
+        const address = {
+          sheetName: opts.sheetName,
+          workbookName: opts.workbookName,
+          colIndex: col,
+          rowIndex: row
+        };
+        const content = this.getCellContent(address);
+        cells.push({
+          address,
+          content,
+          rowOffset: row - startRow,
+          colOffset: col - startCol
+        });
+      }
+    }
+    return cells;
+  }
+  collectSingleCellPattern(seedCell, fillRange, direction, changes) {
+    const { content } = seedCell;
+    const startCol = fillRange.start.col;
+    const startRow = fillRange.start.row;
+    const endCol = fillRange.end.col;
+    const endRow = fillRange.end.row;
+    for (let row = startRow;row <= endRow; row++) {
+      for (let col = startCol;col <= endCol; col++) {
+        const targetAddress = {
+          sheetName: seedCell.address.sheetName,
+          workbookName: seedCell.address.workbookName,
+          colIndex: col,
+          rowIndex: row
+        };
+        let newContent;
+        if (content === undefined || content === "") {
+          newContent = undefined;
+        } else if (typeof content === "string" && content.startsWith("=")) {
+          newContent = this.adjustFormulaReferences(content, seedCell.address, targetAddress);
+        } else {
+          newContent = content;
+        }
+        changes.set(import_utils.getCellReference(targetAddress), newContent);
+      }
+    }
+  }
+  collectMultiCellPattern(seedCells, seedRange, fillRange, direction, changes) {
+    const step = this.inferLinearStep(seedCells, direction);
+    const startCol = fillRange.start.col;
+    const startRow = fillRange.start.row;
+    const endCol = fillRange.end.col;
+    const endRow = fillRange.end.row;
+    const seedWidth = seedRange.end.col - seedRange.start.col + 1;
+    const seedHeight = seedRange.end.row - seedRange.start.row + 1;
+    for (let row = startRow;row <= endRow; row++) {
+      for (let col = startCol;col <= endCol; col++) {
+        const targetAddress = {
+          colIndex: col,
+          rowIndex: row
+        };
+        let newContent;
+        if (step !== null) {
+          newContent = this.applyLinearStep(seedCells, targetAddress, seedRange, step, direction);
+        } else {
+          const seedColOffset = (col - startCol) % seedWidth;
+          const seedRowOffset = (row - startRow) % seedHeight;
+          const seedCell = seedCells.find((cell) => cell.colOffset === seedColOffset && cell.rowOffset === seedRowOffset);
+          if (seedCell) {
+            if (typeof seedCell.content === "string" && seedCell.content.startsWith("=")) {
+              newContent = this.adjustFormulaReferences(seedCell.content, seedCell.address, targetAddress);
+            } else {
+              newContent = seedCell.content;
+            }
+          } else {
+            newContent = undefined;
+          }
+        }
+        changes.set(import_utils.getCellReference(targetAddress), newContent);
+      }
+    }
+  }
+  inferLinearStep(seedCells, direction) {
+    const values = [];
+    if (direction === "down" || direction === "up") {
+      const firstColCells = seedCells.filter((cell) => cell.colOffset === 0).sort((a, b) => a.rowOffset - b.rowOffset);
+      for (const cell of firstColCells) {
+        if (typeof cell.content === "number") {
+          values.push(cell.content);
+        } else if (typeof cell.content === "string") {
+          const num = parseFloat(cell.content);
+          if (!isNaN(num)) {
+            values.push(num);
+          } else {
+            return null;
+          }
+        } else {
+          return null;
+        }
+      }
+    } else {
+      const firstRowCells = seedCells.filter((cell) => cell.rowOffset === 0).sort((a, b) => a.colOffset - b.colOffset);
+      for (const cell of firstRowCells) {
+        if (typeof cell.content === "number") {
+          values.push(cell.content);
+        } else if (typeof cell.content === "string") {
+          const num = parseFloat(cell.content);
+          if (!isNaN(num)) {
+            values.push(num);
+          } else {
+            return null;
+          }
+        } else {
+          return null;
+        }
+      }
+    }
+    if (values.length < 2) {
+      return null;
+    }
+    const step = values[1] - values[0];
+    for (let i = 2;i < values.length; i++) {
+      if (Math.abs(values[i] - values[i - 1] - step) > 0.0000000001) {
+        return null;
+      }
+    }
+    return step;
+  }
+  applyLinearStep(seedCells, targetAddress, seedRange, step, direction) {
+    let positionInSequence;
+    let baseValue;
+    if (direction === "down") {
+      positionInSequence = targetAddress.rowIndex - seedRange.start.row;
+      const baseCell = seedCells.find((cell) => cell.colOffset === targetAddress.colIndex - seedRange.start.col && cell.rowOffset === 0);
+      if (!baseCell)
+        return;
+      baseValue = typeof baseCell.content === "number" ? baseCell.content : parseFloat(String(baseCell.content || "0"));
+    } else if (direction === "up") {
+      positionInSequence = targetAddress.rowIndex - seedRange.start.row;
+      const baseCell = seedCells.find((cell) => cell.colOffset === targetAddress.colIndex - seedRange.start.col && cell.rowOffset === 0);
+      if (!baseCell)
+        return;
+      baseValue = typeof baseCell.content === "number" ? baseCell.content : parseFloat(String(baseCell.content || "0"));
+    } else if (direction === "right") {
+      positionInSequence = targetAddress.colIndex - seedRange.start.col;
+      const baseCell = seedCells.find((cell) => cell.rowOffset === targetAddress.rowIndex - seedRange.start.row && cell.colOffset === 0);
+      if (!baseCell)
+        return;
+      baseValue = typeof baseCell.content === "number" ? baseCell.content : parseFloat(String(baseCell.content || "0"));
+    } else {
+      positionInSequence = targetAddress.colIndex - seedRange.start.col;
+      const baseCell = seedCells.find((cell) => cell.rowOffset === targetAddress.rowIndex - seedRange.start.row && cell.colOffset === 0);
+      if (!baseCell)
+        return;
+      baseValue = typeof baseCell.content === "number" ? baseCell.content : parseFloat(String(baseCell.content || "0"));
+    }
+    if (isNaN(baseValue)) {
+      return;
+    }
+    const result = baseValue + step * positionInSequence;
+    return typeof seedCells[0]?.content === "string" ? result.toString() : result;
+  }
+  adjustFormulaReferences(formula, sourceAddress, targetAddress) {
+    try {
+      const ast = import_parser.parseFormula(formula.slice(1));
+      const rowDelta = targetAddress.rowIndex - sourceAddress.rowIndex;
+      const colDelta = targetAddress.colIndex - sourceAddress.colIndex;
+      const adjustedAst = import_ast_traverser.transformAST(ast, (node) => {
+        if (node.type === "reference") {
+          const refNode = node;
+          return {
+            ...refNode,
+            address: {
+              colIndex: refNode.isAbsolute.col ? refNode.address.colIndex : refNode.address.colIndex + colDelta,
+              rowIndex: refNode.isAbsolute.row ? refNode.address.rowIndex : refNode.address.rowIndex + rowDelta
+            }
+          };
+        } else if (node.type === "range") {
+          const rangeNode = node;
+          return {
+            ...rangeNode,
+            range: {
+              start: {
+                col: rangeNode.isAbsolute.start.col ? rangeNode.range.start.col : rangeNode.range.start.col + colDelta,
+                row: rangeNode.isAbsolute.start.row ? rangeNode.range.start.row : rangeNode.range.start.row + rowDelta
+              },
+              end: {
+                col: rangeNode.range.end.col.type === "number" ? rangeNode.isAbsolute.end.col ? rangeNode.range.end.col : {
+                  type: "number",
+                  value: rangeNode.range.end.col.value + colDelta
+                } : rangeNode.range.end.col,
+                row: rangeNode.range.end.row.type === "number" ? rangeNode.isAbsolute.end.row ? rangeNode.range.end.row : {
+                  type: "number",
+                  value: rangeNode.range.end.row.value + rowDelta
+                } : rangeNode.range.end.row
+              }
+            }
+          };
+        }
+        return node;
+      });
+      return `=${import_formatter.astToString(adjustedAst)}`;
+    } catch (error) {
+      console.warn("Failed to adjust formula references:", error);
+      return formula;
+    }
+  }
+}
+
+//# debugId=A2FA1CBFF9C51E2264756E2164756E21

package/dist/cjs/core/autofill-utils.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../src/core/autofill-utils.ts"],
+  "sourcesContent": [
+    "/**\n * AutoFill class for handling spreadsheet autofill functionality\n */\n\nimport type {\n  CellAddress,\n  SerializedCellValue,\n  SpreadsheetRange,\n  FiniteSpreadsheetRange,\n  LocalCellAddress,\n} from \"./types.cjs\";\nimport type { FillDirection } from \"@ricsam/selection-manager\";\nimport { parseFormula } from \"../parser/parser.cjs\";\nimport { astToString } from \"../parser/formatter.cjs\";\nimport { transformAST } from \"./ast-traverser.cjs\";\nimport type { ReferenceNode, RangeNode } from \"../parser/ast.cjs\";\nimport { getCellReference } from \"./utils.cjs\";\nimport type { WorkbookManager } from \"./managers/workbook-manager.cjs\";\n\nexport class AutoFill {\n  constructor(\n    private workbookManager: WorkbookManager,\n    private engine: {\n      setCellContent: (\n        address: CellAddress,\n        content: SerializedCellValue\n      ) => void;\n      setSheetContent: (\n        opts: { sheetName: string; workbookName: string },\n        content: Map<string, SerializedCellValue>\n      ) => void;\n    }\n  ) {}\n\n  /**\n   * Converts a SpreadsheetRange to FiniteSpreadsheetRange, throwing an error if infinite\n   */\n  private toFiniteRange(range: SpreadsheetRange): FiniteSpreadsheetRange {\n    if (\n      range.end.col.type === \"infinity\" ||\n      range.end.row.type === \"infinity\"\n    ) {\n      throw new Error(\"AutoFill with infinite ranges is not supported\");\n    }\n\n    return {\n      start: range.start,\n      end: {\n        col: range.end.col.value,\n        row: range.end.row.value,\n      },\n    };\n  }\n\n  private getCellContent(address: CellAddress): SerializedCellValue {\n    const sheet = this.workbookManager.getSheet(address);\n    if (!sheet) {\n      throw new Error(\"Sheet not found\");\n    }\n    return sheet.content.get(getCellReference(address));\n  }\n\n  fill(\n    opts: { sheetName: string; workbookName: string },\n    seedRange: SpreadsheetRange,\n    fillRange: SpreadsheetRange,\n    direction: FillDirection\n  ) {\n    // Convert to finite ranges (throws error if infinite)\n    const finiteSeedRange = this.toFiniteRange(seedRange);\n    const finiteFillRange = this.toFiniteRange(fillRange);\n\n    // Get seed cells data\n    const seedCells = this.getSeedCells(opts, finiteSeedRange);\n\n    // Collect all changes to apply in a single batch\n    const changes = new Map<string, SerializedCellValue>();\n\n    // Determine if we have a single cell or multi-cell seed\n    const isSingleCell = seedCells.length === 1;\n\n    if (isSingleCell) {\n      const seedCell = seedCells[0];\n      if (seedCell) {\n        this.collectSingleCellPattern(\n          seedCell,\n          finiteFillRange,\n          direction,\n          changes\n        );\n      }\n    } else {\n      this.collectMultiCellPattern(\n        seedCells,\n        finiteSeedRange,\n        finiteFillRange,\n        direction,\n        changes\n      );\n    }\n\n    // Get current sheet content and merge with changes\n    const currentContent = this.workbookManager.getSheetSerialized(opts);\n    const newContent = new Map(currentContent);\n\n    // Apply all changes\n    changes.forEach((value, key) => {\n      if (value === undefined) {\n        newContent.delete(key);\n      } else {\n        newContent.set(key, value);\n      }\n    });\n\n    // Update sheet content in a single operation\n    this.engine.setSheetContent(opts, newContent);\n  }\n\n  private getSeedCells(\n    opts: { sheetName: string; workbookName: string },\n    seedRange: FiniteSpreadsheetRange\n  ) {\n    const cells: Array<{\n      address: CellAddress;\n      content: SerializedCellValue;\n      rowOffset: number;\n      colOffset: number;\n    }> = [];\n\n    const startCol = seedRange.start.col;\n    const startRow = seedRange.start.row;\n    const endCol = seedRange.end.col;\n    const endRow = seedRange.end.row;\n\n    for (let row = startRow; row <= endRow; row++) {\n      for (let col = startCol; col <= endCol; col++) {\n        const address: CellAddress = {\n          sheetName: opts.sheetName,\n          workbookName: opts.workbookName,\n          colIndex: col,\n          rowIndex: row,\n        };\n        const content = this.getCellContent(address);\n        cells.push({\n          address,\n          content,\n          rowOffset: row - startRow,\n          colOffset: col - startCol,\n        });\n      }\n    }\n\n    return cells;\n  }\n\n  private collectSingleCellPattern(\n    seedCell: { address: CellAddress; content: SerializedCellValue },\n    fillRange: FiniteSpreadsheetRange,\n    direction: FillDirection,\n    changes: Map<string, SerializedCellValue>\n  ) {\n    const { content } = seedCell;\n\n    const startCol = fillRange.start.col;\n    const startRow = fillRange.start.row;\n    const endCol = fillRange.end.col;\n    const endRow = fillRange.end.row;\n\n    for (let row = startRow; row <= endRow; row++) {\n      for (let col = startCol; col <= endCol; col++) {\n        const targetAddress: CellAddress = {\n          sheetName: seedCell.address.sheetName,\n          workbookName: seedCell.address.workbookName,\n          colIndex: col,\n          rowIndex: row,\n        };\n\n        let newContent: SerializedCellValue;\n\n        if (content === undefined || content === \"\") {\n          // Blank cell - fills blanks (effectively clears targets)\n          newContent = undefined;\n        } else if (typeof content === \"string\" && content.startsWith(\"=\")) {\n          // Formula - adjust relative references\n          newContent = this.adjustFormulaReferences(\n            content,\n            seedCell.address,\n            targetAddress\n          );\n        } else {\n          // Number or text - copy by default\n          newContent = content;\n        }\n\n        changes.set(getCellReference(targetAddress), newContent);\n      }\n    }\n  }\n\n  private collectMultiCellPattern(\n    seedCells: Array<{\n      address: CellAddress;\n      content: SerializedCellValue;\n      rowOffset: number;\n      colOffset: number;\n    }>,\n    seedRange: FiniteSpreadsheetRange,\n    fillRange: FiniteSpreadsheetRange,\n    direction: FillDirection,\n    changes: Map<string, SerializedCellValue>\n  ) {\n    // Try to infer linear step from numbers\n    const step = this.inferLinearStep(seedCells, direction);\n\n    const startCol = fillRange.start.col;\n    const startRow = fillRange.start.row;\n    const endCol = fillRange.end.col;\n    const endRow = fillRange.end.row;\n\n    const seedWidth = seedRange.end.col - seedRange.start.col + 1;\n    const seedHeight = seedRange.end.row - seedRange.start.row + 1;\n\n    for (let row = startRow; row <= endRow; row++) {\n      for (let col = startCol; col <= endCol; col++) {\n        const targetAddress: LocalCellAddress = {\n          colIndex: col,\n          rowIndex: row,\n        };\n\n        let newContent: SerializedCellValue;\n\n        if (step !== null) {\n          // Use linear progression\n          newContent = this.applyLinearStep(\n            seedCells,\n            targetAddress,\n            seedRange,\n            step,\n            direction\n          );\n        } else {\n          // Repeat pattern (cycle through seed block)\n          const seedColOffset = (col - startCol) % seedWidth;\n          const seedRowOffset = (row - startRow) % seedHeight;\n\n          const seedCell = seedCells.find(\n            (cell) =>\n              cell.colOffset === seedColOffset &&\n              cell.rowOffset === seedRowOffset\n          );\n\n          if (seedCell) {\n            if (\n              typeof seedCell.content === \"string\" &&\n              seedCell.content.startsWith(\"=\")\n            ) {\n              // Formula - adjust relative references\n              newContent = this.adjustFormulaReferences(\n                seedCell.content,\n                seedCell.address,\n                targetAddress\n              );\n            } else {\n              newContent = seedCell.content;\n            }\n          } else {\n            newContent = undefined;\n          }\n        }\n\n        changes.set(getCellReference(targetAddress), newContent);\n      }\n    }\n  }\n\n  private inferLinearStep(\n    seedCells: Array<{\n      content: SerializedCellValue;\n      rowOffset: number;\n      colOffset: number;\n    }>,\n    direction: FillDirection\n  ): number | null {\n    // Extract numeric values in the direction of fill\n    const values: number[] = [];\n\n    if (direction === \"down\" || direction === \"up\") {\n      // Look at first column, different rows\n      const firstColCells = seedCells\n        .filter((cell) => cell.colOffset === 0)\n        .sort((a, b) => a.rowOffset - b.rowOffset);\n\n      for (const cell of firstColCells) {\n        if (typeof cell.content === \"number\") {\n          values.push(cell.content);\n        } else if (typeof cell.content === \"string\") {\n          const num = parseFloat(cell.content);\n          if (!isNaN(num)) {\n            values.push(num);\n          } else {\n            return null; // Non-numeric content, can't infer step\n          }\n        } else {\n          return null;\n        }\n      }\n    } else {\n      // Look at first row, different columns\n      const firstRowCells = seedCells\n        .filter((cell) => cell.rowOffset === 0)\n        .sort((a, b) => a.colOffset - b.colOffset);\n\n      for (const cell of firstRowCells) {\n        if (typeof cell.content === \"number\") {\n          values.push(cell.content);\n        } else if (typeof cell.content === \"string\") {\n          const num = parseFloat(cell.content);\n          if (!isNaN(num)) {\n            values.push(num);\n          } else {\n            return null; // Non-numeric content, can't infer step\n          }\n        } else {\n          return null;\n        }\n      }\n    }\n\n    if (values.length < 2) {\n      return null;\n    }\n\n    // Check if there's a consistent step\n    const step = values[1]! - values[0]!;\n    for (let i = 2; i < values.length; i++) {\n      if (Math.abs(values[i]! - values[i - 1]! - step) > 1e-10) {\n        return null; // Inconsistent step\n      }\n    }\n\n    return step;\n  }\n\n  private applyLinearStep(\n    seedCells: Array<{\n      content: SerializedCellValue;\n      rowOffset: number;\n      colOffset: number;\n    }>,\n    targetAddress: LocalCellAddress,\n    seedRange: FiniteSpreadsheetRange,\n    step: number,\n    direction: FillDirection\n  ): SerializedCellValue {\n    // Calculate the position in the overall sequence\n    let positionInSequence: number;\n    let baseValue: number;\n\n    if (direction === \"down\") {\n      positionInSequence = targetAddress.rowIndex - seedRange.start.row;\n\n      // Find the base value from the first row of the seed\n      const baseCell = seedCells.find(\n        (cell) =>\n          cell.colOffset === targetAddress.colIndex - seedRange.start.col &&\n          cell.rowOffset === 0\n      );\n\n      if (!baseCell) return undefined;\n      baseValue =\n        typeof baseCell.content === \"number\"\n          ? baseCell.content\n          : parseFloat(String(baseCell.content || \"0\"));\n    } else if (direction === \"up\") {\n      positionInSequence = targetAddress.rowIndex - seedRange.start.row;\n\n      // Find the base value from the first row of the seed (same as down direction)\n      const baseCell = seedCells.find(\n        (cell) =>\n          cell.colOffset === targetAddress.colIndex - seedRange.start.col &&\n          cell.rowOffset === 0\n      );\n\n      if (!baseCell) return undefined;\n      baseValue =\n        typeof baseCell.content === \"number\"\n          ? baseCell.content\n          : parseFloat(String(baseCell.content || \"0\"));\n    } else if (direction === \"right\") {\n      positionInSequence = targetAddress.colIndex - seedRange.start.col;\n\n      // Find the base value from the first column of the seed\n      const baseCell = seedCells.find(\n        (cell) =>\n          cell.rowOffset === targetAddress.rowIndex - seedRange.start.row &&\n          cell.colOffset === 0\n      );\n\n      if (!baseCell) return undefined;\n      baseValue =\n        typeof baseCell.content === \"number\"\n          ? baseCell.content\n          : parseFloat(String(baseCell.content || \"0\"));\n    } else {\n      // left\n      positionInSequence = targetAddress.colIndex - seedRange.start.col;\n\n      // Find the base value from the first column of the seed (same as right direction)\n      const baseCell = seedCells.find(\n        (cell) =>\n          cell.rowOffset === targetAddress.rowIndex - seedRange.start.row &&\n          cell.colOffset === 0\n      );\n\n      if (!baseCell) return undefined;\n      baseValue =\n        typeof baseCell.content === \"number\"\n          ? baseCell.content\n          : parseFloat(String(baseCell.content || \"0\"));\n    }\n\n    if (isNaN(baseValue)) {\n      return undefined;\n    }\n\n    const result = baseValue + step * positionInSequence;\n    return typeof seedCells[0]?.content === \"string\"\n      ? result.toString()\n      : result;\n  }\n\n  private adjustFormulaReferences(\n    formula: string,\n    sourceAddress: LocalCellAddress,\n    targetAddress: LocalCellAddress\n  ): string {\n    try {\n      const ast = parseFormula(formula.slice(1)); // Remove the \"=\" sign\n\n      const rowDelta = targetAddress.rowIndex - sourceAddress.rowIndex;\n      const colDelta = targetAddress.colIndex - sourceAddress.colIndex;\n\n      const adjustedAst = transformAST(ast, (node) => {\n        if (node.type === \"reference\") {\n          const refNode = node as ReferenceNode;\n          return {\n            ...refNode,\n            address: {\n              colIndex: refNode.isAbsolute.col\n                ? refNode.address.colIndex\n                : refNode.address.colIndex + colDelta,\n              rowIndex: refNode.isAbsolute.row\n                ? refNode.address.rowIndex\n                : refNode.address.rowIndex + rowDelta,\n            },\n          };\n        } else if (node.type === \"range\") {\n          const rangeNode = node as RangeNode;\n          return {\n            ...rangeNode,\n            range: {\n              start: {\n                col: rangeNode.isAbsolute.start.col\n                  ? rangeNode.range.start.col\n                  : rangeNode.range.start.col + colDelta,\n                row: rangeNode.isAbsolute.start.row\n                  ? rangeNode.range.start.row\n                  : rangeNode.range.start.row + rowDelta,\n              },\n              end: {\n                col:\n                  rangeNode.range.end.col.type === \"number\"\n                    ? rangeNode.isAbsolute.end.col\n                      ? rangeNode.range.end.col\n                      : {\n                          type: \"number\" as const,\n                          value: rangeNode.range.end.col.value + colDelta,\n                        }\n                    : rangeNode.range.end.col,\n                row:\n                  rangeNode.range.end.row.type === \"number\"\n                    ? rangeNode.isAbsolute.end.row\n                      ? rangeNode.range.end.row\n                      : {\n                          type: \"number\" as const,\n                          value: rangeNode.range.end.row.value + rowDelta,\n                        }\n                    : rangeNode.range.end.row,\n              },\n            },\n          };\n        }\n        return node;\n      });\n\n      return `=${astToString(adjustedAst)}`;\n    } catch (error) {\n      // If parsing fails, return the original formula\n      console.warn(\"Failed to adjust formula references:\", error);\n      return formula;\n    }\n  }\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "A2FA1CBFF9C51E2264756E2164756E21",
+  "names": []
+}