@pagent-libs/core 0.1.0

package/src/formula-parser/formula-ranges.ts

@@ -0,0 +1,159 @@
+// Utility to extract cell references and ranges from formula strings
+
+import { parseCellReference, parseRangeReference } from './cell-reference';
+import type { CellReference, RangeReference } from './types';
+
+export interface FormulaRange {
+  type: 'cell' | 'range';
+  cellRef?: CellReference;
+  rangeRef?: RangeReference;
+  startRow: number;
+  startCol: number;
+  endRow: number;
+  endCol: number;
+  sheetName?: string; // Sheet name if this is a cross-sheet reference
+}
+
+/**
+ * Extracts all cell references and ranges from a formula string.
+ * Returns an array of ranges, where each range represents either:
+ * - A single cell (startRow === endRow && startCol === endCol)
+ * - A range of cells (e.g., A1:A5)
+ * 
+ * @param formula The formula string (e.g., "=SUM(A1:A5)+B2")
+ * @returns Array of FormulaRange objects
+ */
+export function extractFormulaRanges(formula: string): FormulaRange[] {
+  if (!formula.startsWith('=')) {
+    return [];
+  }
+
+  const expression = formula.slice(1); // Remove leading =
+  const ranges: FormulaRange[] = [];
+
+  // Match patterns like:
+  // - Single cells: A1, $A1, A$1, $A$1, Sheet1!A1, 'Sheet 1'!A1
+  // - Ranges: A1:A5, $A$1:$B$10, Sheet1!A1:A5, 'Sheet 1'!A1:A5
+  // This regex matches cell references and ranges, including cross-sheet references
+  // We need to match cross-sheet references first, then same-sheet references
+  // Pattern for cross-sheet: ('sheet name'|sheetname)!cellref(:cellref)?
+  // Pattern for same-sheet: cellref(:cellref)?
+  
+  // First, try to match cross-sheet references
+  const crossSheetPattern = /(?:'([^']+)'|([^!'"]+))!(\$?[A-Z]+\$?\d+)(?::(\$?[A-Z]+\$?\d+))?/g;
+  let match;
+  const processedIndices = new Set<number>();
+  
+  // Process cross-sheet references first
+  while ((match = crossSheetPattern.exec(expression)) !== null) {
+    const sheetName = match[1] || match[2]; // Use quoted name if present, otherwise unquoted
+    const startRef = match[3];
+    const endRef = match[4]; // undefined for single cells, defined for ranges
+    const matchIndex = match.index;
+
+    if (endRef) {
+      // It's a range (e.g., Sheet1!A1:A5)
+      const rangeRef = parseRangeReference(`${sheetName}!${startRef}:${endRef}`);
+      if (rangeRef) {
+        const { start, end } = rangeRef;
+        const startRow = start.row;
+        const startCol = start.col;
+        const endRow = end.row;
+        const endCol = end.col;
+
+        ranges.push({
+          type: 'range',
+          rangeRef,
+          startRow: Math.min(startRow, endRow),
+          startCol: Math.min(startCol, endCol),
+          endRow: Math.max(startRow, endRow),
+          endCol: Math.max(startCol, endCol),
+          sheetName,
+        });
+        processedIndices.add(matchIndex);
+      }
+    } else {
+      // It's a single cell (e.g., Sheet1!A1)
+      const cellRef = parseCellReference(`${sheetName}!${startRef}`);
+      if (cellRef) {
+        const row = cellRef.row;
+        const col = cellRef.col;
+
+        ranges.push({
+          type: 'cell',
+          cellRef,
+          startRow: row,
+          startCol: col,
+          endRow: row,
+          endCol: col,
+          sheetName,
+        });
+        processedIndices.add(matchIndex);
+      }
+    }
+  }
+
+  // Now match same-sheet references (those not already processed)
+  const sameSheetPattern = /(\$?[A-Z]+\$?\d+)(?::(\$?[A-Z]+\$?\d+))?/g;
+  while ((match = sameSheetPattern.exec(expression)) !== null) {
+    // Skip if this position was already processed as part of a cross-sheet reference
+    // Check if there's a ! before this match (indicating it's part of a cross-sheet ref)
+    const beforeMatch = expression.substring(Math.max(0, match.index - 100), match.index);
+    // Look for ! that's not inside quotes (simple check: ! not followed by quote)
+    const lastExclamation = beforeMatch.lastIndexOf('!');
+    if (lastExclamation !== -1) {
+      const afterExclamation = beforeMatch.substring(lastExclamation + 1);
+      // If there's no quote after the !, this is likely part of a cross-sheet reference
+      // But we need to be more careful - check if the ! is part of a sheet name pattern
+      if (!afterExclamation.match(/^['"]/)) {
+        // This is likely part of a cross-sheet reference, skip it
+        continue;
+      }
+    }
+
+    const startRef = match[1];
+    const endRef = match[2]; // undefined for single cells, defined for ranges
+
+    if (endRef) {
+      // It's a range (e.g., A1:A5)
+      const rangeRef = parseRangeReference(`${startRef}:${endRef}`);
+      if (rangeRef) {
+        const { start, end } = rangeRef;
+        const startRow = start.row;
+        const startCol = start.col;
+        const endRow = end.row;
+        const endCol = end.col;
+
+        ranges.push({
+          type: 'range',
+          rangeRef,
+          startRow: Math.min(startRow, endRow),
+          startCol: Math.min(startCol, endCol),
+          endRow: Math.max(startRow, endRow),
+          endCol: Math.max(startCol, endCol),
+          // No sheetName means it's on the same sheet as the formula
+        });
+      }
+    } else {
+      // It's a single cell (e.g., A1)
+      const cellRef = parseCellReference(startRef);
+      if (cellRef) {
+        const row = cellRef.row;
+        const col = cellRef.col;
+
+        ranges.push({
+          type: 'cell',
+          cellRef,
+          startRow: row,
+          startCol: col,
+          endRow: row,
+          endCol: col,
+          // No sheetName means it's on the same sheet as the formula
+        });
+      }
+    }
+  }
+
+  return ranges;
+}
+

package/src/formula-parser/index.ts

@@ -0,0 +1,8 @@
+// Formula parser exports
+
+export * from './types';
+export * from './parser';
+export * from './cell-reference';
+export * from './formula-adjust';
+export * from './formula-ranges';
+

package/src/formula-parser/parser.ts

@@ -0,0 +1,438 @@
+// Formula parser - simplified but functional
+
+import type { ParsedFormulaNode, ParseResult, EvaluationContext, RangeReference } from './types';
+import { parseCellReference, parseRangeReference, cellReferenceToKey } from './cell-reference';
+
+export class FormulaParser {
+  private functions: Map<string, (args: unknown[], ctx: EvaluationContext) => unknown> = new Map();
+
+  constructor() {
+    this.registerBuiltInFunctions();
+  }
+
+  private registerBuiltInFunctions(): void {
+    // SUM function
+    this.functions.set('SUM', (args, ctx) => {
+      const values = this.flattenArgs(args, ctx);
+      return values.reduce((sum: number, val) => {
+        const num = Number(val);
+        return sum + (isNaN(num) ? 0 : num);
+      }, 0);
+    });
+
+    // AVERAGE function
+    this.functions.set('AVERAGE', (args, ctx) => {
+      const values = this.flattenArgs(args, ctx);
+      const numbers = values.map(Number).filter((n) => !isNaN(n));
+      return numbers.length > 0 ? numbers.reduce((a, b) => a + b, 0) / numbers.length : 0;
+    });
+
+    // COUNT function
+    this.functions.set('COUNT', (args, ctx) => {
+      const values = this.flattenArgs(args, ctx);
+      return values.filter((v) => v != null && v !== '').length;
+    });
+
+    // MAX function
+    this.functions.set('MAX', (args, ctx) => {
+      const values = this.flattenArgs(args, ctx);
+      const numbers = values.map(Number).filter((n) => !isNaN(n));
+      return numbers.length > 0 ? Math.max(...numbers) : 0;
+    });
+
+    // MIN function
+    this.functions.set('MIN', (args, ctx) => {
+      const values = this.flattenArgs(args, ctx);
+      const numbers = values.map(Number).filter((n) => !isNaN(n));
+      return numbers.length > 0 ? Math.min(...numbers) : 0;
+    });
+
+    // IF function - args are already evaluated when passed to functions
+    this.functions.set('IF', (args, _ctx) => {
+      void _ctx;
+      if (args.length < 2) return null;
+      const condition = args[0];
+      const truthy = Boolean(condition);
+      return truthy ? args[1] : (args.length > 2 ? args[2] : null);
+    });
+  }
+
+  parse(formula: string, currentRow: number = 0, currentCol: number = 0): ParseResult {
+    const dependencies = new Set<string>();
+    let error: string | undefined;
+
+    try {
+      // Remove leading = if present
+      const expression = formula.startsWith('=') ? formula.slice(1) : formula;
+
+      // Simple parser - handles basic cases
+      const ast = this.parseExpression(expression, currentRow, currentCol, dependencies);
+
+      return { ast, dependencies, error };
+    } catch (e) {
+      error = e instanceof Error ? e.message : '#ERROR!';
+      return {
+        ast: { type: 'string', value: '' },
+        dependencies,
+        error,
+      };
+    }
+  }
+
+  private parseExpression(
+    expr: string,
+    currentRow: number,
+    currentCol: number,
+    dependencies: Set<string>
+  ): ParsedFormulaNode {
+    expr = expr.trim();
+
+    // Try to parse as arithmetic/comparison expression
+    const operatorMatch = this.findLowestPrecedenceOperator(expr);
+    if (operatorMatch) {
+      const { operator, index } = operatorMatch;
+      const leftExpr = expr.substring(0, index).trim();
+      const rightExpr = expr.substring(index + operator.length).trim();
+      
+      return {
+        type: 'operator',
+        operator,
+        left: this.parseExpression(leftExpr, currentRow, currentCol, dependencies),
+        right: this.parseExpression(rightExpr, currentRow, currentCol, dependencies),
+      };
+    }
+
+    // Try to parse as cell reference
+    const cellRef = parseCellReference(expr);
+    if (cellRef) {
+      // For relative references, convert absolute position to offset
+      if (!cellRef.rowAbsolute || !cellRef.colAbsolute) {
+        // Calculate offset from current cell
+        const rowOffset = cellRef.row - currentRow;
+        const colOffset = cellRef.col - currentCol;
+        // Store as offset for relative references
+        const adjustedRef = {
+          row: cellRef.rowAbsolute ? cellRef.row : rowOffset,
+          col: cellRef.colAbsolute ? cellRef.col : colOffset,
+          rowAbsolute: cellRef.rowAbsolute,
+          colAbsolute: cellRef.colAbsolute,
+          sheetName: cellRef.sheetName, // Preserve sheet name
+        };
+        const key = cellReferenceToKey(adjustedRef, currentRow, currentCol);
+        // For cross-sheet references, include sheet name in dependency key
+        const depKey = cellRef.sheetName ? `${cellRef.sheetName}!${key}` : key;
+        dependencies.add(depKey);
+        return { type: 'cell', cellRef: adjustedRef };
+      }
+      // Absolute reference - use as-is
+      const key = cellReferenceToKey(cellRef, currentRow, currentCol);
+      // For cross-sheet references, include sheet name in dependency key
+      const depKey = cellRef.sheetName ? `${cellRef.sheetName}!${key}` : key;
+      dependencies.add(depKey);
+      return { type: 'cell', cellRef };
+    }
+
+    // Try to parse as range
+    const rangeRef = parseRangeReference(expr);
+    if (rangeRef) {
+      // Add all cells in range to dependencies
+      const { start, end } = rangeRef;
+      
+      // For relative references, convert absolute position to offset (like we do for single cells)
+      // parseCellReference returns absolute positions, so we need to calculate the offset
+      const startRowOffset = start.rowAbsolute ? 0 : start.row - currentRow;
+      const startColOffset = start.colAbsolute ? 0 : start.col - currentCol;
+      const endRowOffset = end.rowAbsolute ? 0 : end.row - currentRow;
+      const endColOffset = end.colAbsolute ? 0 : end.col - currentCol;
+      
+      // Create adjusted range reference with offsets for relative refs
+      const sheetName = start.sheetName || end.sheetName; // Get sheet name from either start or end
+      const adjustedRangeRef: RangeReference = {
+        start: {
+          row: start.rowAbsolute ? start.row : startRowOffset,
+          col: start.colAbsolute ? start.col : startColOffset,
+          rowAbsolute: start.rowAbsolute,
+          colAbsolute: start.colAbsolute,
+          sheetName: sheetName, // Preserve sheet name
+        },
+        end: {
+          row: end.rowAbsolute ? end.row : endRowOffset,
+          col: end.colAbsolute ? end.col : endColOffset,
+          rowAbsolute: end.rowAbsolute,
+          colAbsolute: end.colAbsolute,
+          sheetName: sheetName, // Preserve sheet name
+        },
+      };
+      
+      // Calculate absolute positions for dependency tracking
+      const startRow = adjustedRangeRef.start.rowAbsolute 
+        ? adjustedRangeRef.start.row 
+        : currentRow + adjustedRangeRef.start.row;
+      const endRow = adjustedRangeRef.end.rowAbsolute 
+        ? adjustedRangeRef.end.row 
+        : currentRow + adjustedRangeRef.end.row;
+      const startCol = adjustedRangeRef.start.colAbsolute 
+        ? adjustedRangeRef.start.col 
+        : currentCol + adjustedRangeRef.start.col;
+      const endCol = adjustedRangeRef.end.colAbsolute 
+        ? adjustedRangeRef.end.col 
+        : currentCol + adjustedRangeRef.end.col;
+
+      // Add dependencies with sheet name prefix if it's a cross-sheet reference
+      const sheetPrefix = sheetName ? `${sheetName}!` : '';
+      for (let r = Math.min(startRow, endRow); r <= Math.max(startRow, endRow); r++) {
+        for (let c = Math.min(startCol, endCol); c <= Math.max(startCol, endCol); c++) {
+          dependencies.add(`${sheetPrefix}${r}:${c}`);
+        }
+      }
+
+      return { type: 'range', rangeRef: adjustedRangeRef };
+    }
+
+    // Try to parse as function call (e.g., SUM(A1:A10))
+    const functionMatch = expr.match(/^([A-Z]+)\s*\((.*)\)$/);
+    if (functionMatch) {
+      const [, funcName, argsStr] = functionMatch;
+      const args = this.parseArguments(argsStr, currentRow, currentCol, dependencies);
+      return {
+        type: 'function',
+        functionName: funcName.toUpperCase(),
+        args,
+      };
+    }
+
+    // Try to parse as number
+    const num = Number(expr);
+    if (!isNaN(num) && expr.trim() !== '') {
+      return { type: 'number', value: num };
+    }
+
+    // Try to parse as string (quoted)
+    if ((expr.startsWith('"') && expr.endsWith('"')) || (expr.startsWith("'") && expr.endsWith("'"))) {
+      return { type: 'string', value: expr.slice(1, -1) };
+    }
+
+    // Default to string
+    return { type: 'string', value: expr };
+  }
+
+  /**
+   * Find the operator with lowest precedence (to parse correctly)
+   * Returns the rightmost operator of lowest precedence to handle left-associativity
+   */
+  private findLowestPrecedenceOperator(expr: string): { operator: string; index: number } | null {
+    let depth = 0;
+    let lowestPrecOp: { operator: string; index: number } | null = null;
+    let lowestPrec = Infinity;
+
+    // Operator precedence (lower number = lower precedence, evaluated later):
+    // Comparison operators (precedence 0) < +, - (precedence 1) < *, / (precedence 2)
+    const operators = [
+      { op: '>=', prec: 0 },
+      { op: '<=', prec: 0 },
+      { op: '<>', prec: 0 },
+      { op: '>', prec: 0 },
+      { op: '<', prec: 0 },
+      { op: '=', prec: 0 },
+      { op: '+', prec: 1 },
+      { op: '-', prec: 1 },
+      { op: '*', prec: 2 },
+      { op: '/', prec: 2 },
+    ];
+
+    for (let i = 0; i < expr.length; i++) {
+      const char = expr[i];
+      
+      // Track parentheses depth
+      if (char === '(') depth++;
+      else if (char === ')') depth--;
+      // Skip if inside parentheses or quotes
+      else if (depth > 0) continue;
+      else if (char === '"' || char === "'") {
+        // Skip quoted strings
+        const quote = char;
+        i++;
+        while (i < expr.length && expr[i] !== quote) {
+          if (expr[i] === '\\') i++; // Skip escaped characters
+          i++;
+        }
+        continue;
+      }
+      // Check for operators (but not at start, and not part of a number or cell reference)
+      else {
+        for (const { op, prec } of operators) {
+          // Check for multi-character operators first
+          if (op.length === 2 && i < expr.length - 1) {
+            const twoChars = expr.substring(i, i + 2);
+            if (twoChars === op) {
+              if (prec < lowestPrec || (prec === lowestPrec && i > (lowestPrecOp?.index ?? -1))) {
+                lowestPrec = prec;
+                lowestPrecOp = { operator: op, index: i };
+              }
+              continue;
+            }
+          }
+          
+          // Single character operators
+          if (op.length === 1 && char === op) {
+            // Make sure it's not part of a number (e.g., -5 or 1e-5)
+            const prevChar = i > 0 ? expr[i - 1] : '';
+            const isPartOfNumber = 
+              (op === '-' && (prevChar === 'e' || prevChar === 'E')) ||
+              (op === '+' && (prevChar === 'e' || prevChar === 'E'));
+            
+            // Make sure single < or > isn't part of a two-char operator
+            const nextChar = i < expr.length - 1 ? expr[i + 1] : '';
+            const isTwoCharOp = 
+              (op === '<' && (nextChar === '>' || nextChar === '=')) ||
+              (op === '>' && nextChar === '=');
+            
+            if (!isPartOfNumber && !isTwoCharOp && (prec < lowestPrec || (prec === lowestPrec && i > (lowestPrecOp?.index ?? -1)))) {
+              lowestPrec = prec;
+              lowestPrecOp = { operator: op, index: i };
+            }
+          }
+        }
+      }
+    }
+
+    return lowestPrecOp;
+  }
+
+  private parseArguments(
+    argsStr: string,
+    currentRow: number,
+    currentCol: number,
+    dependencies: Set<string>
+  ): ParsedFormulaNode[] {
+    if (!argsStr.trim()) return [];
+
+    const args: ParsedFormulaNode[] = [];
+    let depth = 0;
+    let current = '';
+
+    for (const char of argsStr) {
+      if (char === '(') depth++;
+      else if (char === ')') depth--;
+      else if (char === ',' && depth === 0) {
+        if (current.trim()) {
+          args.push(this.parseExpression(current.trim(), currentRow, currentCol, dependencies));
+        }
+        current = '';
+        continue;
+      }
+      current += char;
+    }
+
+    if (current.trim()) {
+      args.push(this.parseExpression(current.trim(), currentRow, currentCol, dependencies));
+    }
+
+    return args;
+  }
+
+  evaluate(ast: ParsedFormulaNode, ctx: EvaluationContext, currentRow: number = 0, currentCol: number = 0): unknown {
+    return this.evaluateNode(ast, ctx, currentRow, currentCol);
+  }
+
+  private evaluateNode(
+    node: ParsedFormulaNode,
+    ctx: EvaluationContext,
+    currentRow: number = 0,
+    currentCol: number = 0
+  ): unknown {
+    switch (node.type) {
+      case 'number':
+        return node.value;
+      case 'string':
+        return node.value;
+      case 'cell':
+        if (node.cellRef) {
+          const ref = node.cellRef;
+          const row = ref.rowAbsolute ? ref.row : currentRow + ref.row;
+          const col = ref.colAbsolute ? ref.col : currentCol + ref.col;
+          // Use sheet name if provided, otherwise use sheetId from context
+          return ctx.getCellValue(row, col, undefined, ref.sheetName);
+        }
+        return null;
+      case 'range':
+        if (node.rangeRef) {
+          const sheetName = node.rangeRef.start.sheetName || node.rangeRef.end.sheetName;
+          return ctx.getRangeValues(node.rangeRef, undefined, sheetName);
+        }
+        return null;
+      case 'operator':
+        if (node.operator && node.left && node.right) {
+          const leftVal = this.evaluateNode(node.left, ctx, currentRow, currentCol);
+          const rightVal = this.evaluateNode(node.right, ctx, currentRow, currentCol);
+          
+          // Comparison operators work with any types
+          switch (node.operator) {
+            case '>':
+              return Number(leftVal) > Number(rightVal);
+            case '<':
+              return Number(leftVal) < Number(rightVal);
+            case '>=':
+              return Number(leftVal) >= Number(rightVal);
+            case '<=':
+              return Number(leftVal) <= Number(rightVal);
+            case '=':
+              // Excel-style equality: compare values directly
+              return leftVal === rightVal || Number(leftVal) === Number(rightVal);
+            case '<>':
+              return leftVal !== rightVal && Number(leftVal) !== Number(rightVal);
+          }
+          
+          // Arithmetic operators require numbers
+          const leftNum = Number(leftVal);
+          const rightNum = Number(rightVal);
+          
+          if (isNaN(leftNum) || isNaN(rightNum)) {
+            throw new Error('#VALUE!');
+          }
+          
+          switch (node.operator) {
+            case '+':
+              return leftNum + rightNum;
+            case '-':
+              return leftNum - rightNum;
+            case '*':
+              return leftNum * rightNum;
+            case '/':
+              if (rightNum === 0) {
+                throw new Error('#DIV/0!');
+              }
+              return leftNum / rightNum;
+            default:
+              throw new Error(`#ERROR! Unknown operator: ${node.operator}`);
+          }
+        }
+        return null;
+      case 'function':
+        if (node.functionName && node.args) {
+          const func = this.functions.get(node.functionName);
+          if (!func) {
+            throw new Error(`#NAME? Function ${node.functionName} not found`);
+          }
+          const evaluatedArgs = node.args.map((arg) => this.evaluateNode(arg, ctx, currentRow, currentCol));
+          return func(evaluatedArgs, ctx);
+        }
+        return null;
+      default:
+        return null;
+    }
+  }
+
+  private flattenArgs(args: unknown[], ctx: EvaluationContext): unknown[] {
+    const result: unknown[] = [];
+    for (const arg of args) {
+      if (Array.isArray(arg)) {
+        result.push(...this.flattenArgs(arg, ctx));
+      } else {
+        result.push(arg);
+      }
+    }
+    return result;
+  }
+}
+

package/src/formula-parser/types.ts

@@ -0,0 +1,39 @@
+// Formula parser types
+
+export interface CellReference {
+  row: number;
+  col: number;
+  rowAbsolute: boolean;
+  colAbsolute: boolean;
+  sheetName?: string; // Optional sheet name for cross-sheet references
+}
+
+export interface RangeReference {
+  start: CellReference;
+  end: CellReference;
+}
+
+export interface ParsedFormulaNode {
+  type: 'number' | 'string' | 'cell' | 'range' | 'function' | 'operator' | 'variable';
+  value?: unknown;
+  cellRef?: CellReference;
+  rangeRef?: RangeReference;
+  functionName?: string;
+  args?: ParsedFormulaNode[];
+  operator?: string;
+  left?: ParsedFormulaNode;
+  right?: ParsedFormulaNode;
+}
+
+export interface ParseResult {
+  ast: ParsedFormulaNode;
+  dependencies: Set<string>; // cellKeys
+  error?: string;
+}
+
+export interface EvaluationContext {
+  getCellValue: (row: number, col: number, sheetId?: string, sheetName?: string) => unknown;
+  getRangeValues: (range: RangeReference, sheetId?: string, sheetName?: string) => unknown[][];
+  getSheetIdByName?: (sheetName: string) => string | undefined; // Helper to resolve sheet name to sheet ID
+}
+

package/src/index.ts

@@ -0,0 +1,25 @@
+// Core library exports
+
+export * from './types';
+export { WorkbookImpl } from './workbook';
+export { SheetImpl } from './sheet';
+export { StylePool } from './style-pool';
+export { FormulaGraphImpl } from './formula-graph';
+export { EventEmitter } from './event-emitter';
+export * from './utils/cell-key';
+export * from './utils/range';
+export * from './utils/format-utils';
+export * from './export';
+
+// Canvas rendering module
+export * from './canvas';
+
+// Features module
+export * from './features';
+
+// Formula parser module
+export * from './formula-parser';
+
+// Collaboration module
+export * from './collaboration';
+