@pagent-libs/core 0.1.0

package/src/features/sort.ts

@@ -0,0 +1,282 @@
+import type { SortOrder, Cell, Sheet } from '../types';
+import { getCellKey, parseCellKey } from '../utils/cell-key';
+
+export class SortManager {
+  static sortRows(sheet: Sheet, sortOrder: SortOrder[], dataRange?: { startRow: number; endRow: number }): void {
+    if (sortOrder.length === 0) return;
+
+    // Determine data range to sort
+    const startRow = dataRange?.startRow ?? this.detectDataStartRow(sheet);
+    const endRow = dataRange?.endRow ?? this.detectDataEndRow(sheet);
+
+    if (startRow >= endRow) return;
+
+    // Extract rows to sort
+    const rowsToSort: Array<{ rowIndex: number; values: unknown[] }> = [];
+
+    for (let row = startRow; row <= endRow; row++) {
+      const rowValues: unknown[] = [];
+      for (let col = 0; col < sheet.colCount; col++) {
+        const cell = sheet.cells.get(getCellKey(row, col));
+        rowValues.push(cell?.value ?? null);
+      }
+      rowsToSort.push({ rowIndex: row, values: rowValues });
+    }
+
+    // Sort rows based on sort order
+    rowsToSort.sort((a, b) => {
+      for (const sort of sortOrder) {
+        const aValue = a.values[sort.column];
+        const bValue = b.values[sort.column];
+
+        let comparison = 0;
+
+        // Handle different value types
+        if (aValue === null && bValue === null) {
+          comparison = 0;
+        } else if (aValue === null) {
+          comparison = sort.direction === 'asc' ? -1 : 1;
+        } else if (bValue === null) {
+          comparison = sort.direction === 'asc' ? 1 : -1;
+        } else {
+          // Both have values, compare based on type
+          if (typeof aValue === 'number' && typeof bValue === 'number') {
+            comparison = aValue - bValue;
+          } else if (typeof aValue === 'string' && typeof bValue === 'string') {
+            comparison = aValue.localeCompare(bValue);
+          } else if (typeof aValue === 'boolean' && typeof bValue === 'boolean') {
+            comparison = aValue === bValue ? 0 : (aValue ? 1 : -1);
+          } else {
+            // Mixed types: convert to strings for comparison
+            const aStr = String(aValue);
+            const bStr = String(bValue);
+            comparison = aStr.localeCompare(bStr);
+          }
+        }
+
+        // Apply sort direction
+        if (sort.direction === 'desc') {
+          comparison = -comparison;
+        }
+
+        if (comparison !== 0) {
+          return comparison;
+        }
+      }
+
+      return 0; // All sort criteria equal
+    });
+
+    // Create mapping from old row to new row
+    const rowMapping = new Map<number, number>();
+    rowsToSort.forEach((row, newIndex) => {
+      rowMapping.set(row.rowIndex, startRow + newIndex);
+    });
+
+    // Move cells to new positions and update formulas
+    const cellsToMove: Array<{ oldKey: string; newKey: string; cell: Cell }> = [];
+    const formulaUpdates: Array<{ oldKey: string; newKey: string; cell: Cell }> = [];
+
+    // Collect all cells that need to be moved
+    for (const [key, cell] of sheet.cells) {
+      const { row } = parseCellKey(key);
+      if (row >= startRow && row <= endRow) {
+        const newRow = rowMapping.get(row);
+        if (newRow !== undefined) {
+          const newKey = getCellKey(newRow, parseCellKey(key).col);
+          cellsToMove.push({ oldKey: key, newKey, cell });
+        }
+      }
+    }
+
+    // Clear old cells
+    for (const { oldKey } of cellsToMove) {
+      sheet.cells.delete(oldKey);
+    }
+
+    // Move cells to new positions
+    for (const { newKey, cell } of cellsToMove) {
+      if (cell.formula) {
+        // Formula needs to be updated based on row movement
+        const adjustedFormula = this.adjustFormulaForRowSort(cell.formula, rowMapping, startRow, endRow);
+        const updatedCell = { ...cell, formula: adjustedFormula };
+        sheet.cells.set(newKey, updatedCell);
+        formulaUpdates.push({ oldKey: '', newKey, cell: updatedCell });
+      } else {
+        sheet.cells.set(newKey, cell);
+      }
+    }
+  }
+
+  private static adjustFormulaForRowSort(
+    formula: string,
+    rowMapping: Map<number, number>,
+    sortStartRow: number,
+    sortEndRow: number
+  ): string {
+    if (!formula.startsWith('=')) {
+      return formula;
+    }
+
+    try {
+      // Remove leading = for processing
+      const expression = formula.slice(1);
+
+      // Adjust cell references in the formula
+      // Match patterns like A1, $A1, A$1, $A$1, and ranges like A1:B10, $A$1:$B$10
+      const adjustedExpression = expression.replace(
+        /(\$?[A-Z]+\$?\d+)(?::(\$?[A-Z]+\$?\d+))?/g,
+        (match, startRef, endRef) => {
+          // Parse the start reference
+          const startCellRef = this.parseCellReference(startRef);
+          if (!startCellRef) return match;
+
+          // Adjust the row if it's within the sorted range and not absolute
+          let adjustedStartRow = startCellRef.row;
+          if (!startCellRef.rowAbsolute && startCellRef.row >= sortStartRow && startCellRef.row <= sortEndRow) {
+            const newRow = rowMapping.get(startCellRef.row);
+            if (newRow !== undefined) {
+              adjustedStartRow = newRow;
+            }
+          }
+
+          // Reconstruct the start reference
+          const startResult = this.reconstructCellReference(startCellRef, adjustedStartRow);
+
+          // If it's a range, adjust the end reference too
+          if (endRef) {
+            const endCellRef = this.parseCellReference(endRef);
+            if (!endCellRef) return match;
+
+            // Adjust the row if it's within the sorted range and not absolute
+            let adjustedEndRow = endCellRef.row;
+            if (!endCellRef.rowAbsolute && endCellRef.row >= sortStartRow && endCellRef.row <= sortEndRow) {
+              const newRow = rowMapping.get(endCellRef.row);
+              if (newRow !== undefined) {
+                adjustedEndRow = newRow;
+              }
+            }
+
+            // Reconstruct the end reference
+            const endResult = this.reconstructCellReference(endCellRef, adjustedEndRow);
+            return `${startResult}:${endResult}`;
+          }
+
+          return startResult;
+        }
+      );
+
+      return '=' + adjustedExpression;
+    } catch (error) {
+      // If formula adjustment fails, return original formula
+      console.warn('Failed to adjust formula during sort:', formula, error);
+      return formula;
+    }
+  }
+
+  private static parseCellReference(ref: string): { row: number; col: number; rowAbsolute: boolean; colAbsolute: boolean } | null {
+    const match = ref.match(/^(\$?)([A-Z]+)(\$?)(\d+)$/);
+    if (!match) return null;
+
+    const [, colDollar, colLetters, rowDollar, rowNumber] = match;
+    const colAbsolute = colDollar === '$';
+    const rowAbsolute = rowDollar === '$';
+
+    // Convert column letters to number (A=0, B=1, ..., Z=25, AA=26, etc.)
+    let col = 0;
+    for (let i = 0; i < colLetters.length; i++) {
+      col = col * 26 + (colLetters.charCodeAt(i) - 'A'.charCodeAt(0) + 1);
+    }
+    col -= 1; // Convert to 0-based
+
+    const row = parseInt(rowNumber, 10) - 1; // Convert to 0-based
+
+    return { row, col, rowAbsolute, colAbsolute };
+  }
+
+  private static reconstructCellReference(
+    cellRef: { col: number; colAbsolute: boolean; rowAbsolute: boolean },
+    adjustedRow: number
+  ): string {
+    // Convert column number to letters (0=A, 1=B, ..., 25=Z, 26=AA, etc.)
+    let colLetters = '';
+    let col = cellRef.col + 1; // Convert to 1-based for calculation
+    while (col > 0) {
+      col -= 1;
+      colLetters = String.fromCharCode('A'.charCodeAt(0) + (col % 26)) + colLetters;
+      col = Math.floor(col / 26);
+    }
+
+    const rowNumber = adjustedRow + 1; // Convert to 1-based
+
+    let result = '';
+    if (cellRef.colAbsolute) result += '$';
+    result += colLetters;
+    if (cellRef.rowAbsolute) result += '$';
+    result += rowNumber;
+
+    return result;
+  }
+
+  private static detectDataStartRow(sheet: Sheet): number {
+    // Start from row 0, find first non-empty row
+    for (let row = 0; row < sheet.rowCount; row++) {
+      for (let col = 0; col < sheet.colCount; col++) {
+        const cell = sheet.cells.get(getCellKey(row, col));
+        if (cell && (cell.value !== null || cell.formula)) {
+          return row;
+        }
+      }
+    }
+    return 0;
+  }
+
+  private static detectDataEndRow(sheet: Sheet): number {
+    // Start from the bottom, find last non-empty row
+    for (let row = sheet.rowCount - 1; row >= 0; row--) {
+      for (let col = 0; col < sheet.colCount; col++) {
+        const cell = sheet.cells.get(getCellKey(row, col));
+        if (cell && (cell.value !== null || cell.formula)) {
+          return row;
+        }
+      }
+    }
+    return Math.max(0, sheet.rowCount - 1);
+  }
+
+  static getColumnSortDirection(column: number, currentSortOrder: SortOrder[]): 'asc' | 'desc' | null {
+    const sort = currentSortOrder.find(s => s.column === column);
+    return sort ? sort.direction : null;
+  }
+
+  static toggleColumnSort(
+    column: number,
+    currentSortOrder: SortOrder[],
+    multiColumn: boolean = false
+  ): SortOrder[] {
+    const existingSortIndex = currentSortOrder.findIndex(s => s.column === column);
+
+    if (existingSortIndex >= 0) {
+      // Column is already in sort order
+      const existingSort = currentSortOrder[existingSortIndex];
+      if (existingSort.direction === 'asc') {
+        // asc -> desc
+        const newSortOrder = [...currentSortOrder];
+        newSortOrder[existingSortIndex] = { ...existingSort, direction: 'desc' };
+        return newSortOrder;
+      } else {
+        // desc -> remove from sort (no sort)
+        return currentSortOrder.filter(s => s.column !== column);
+      }
+    } else {
+      // Column not in sort order
+      if (multiColumn && currentSortOrder.length > 0) {
+        // Add as secondary sort (ascending)
+        return [...currentSortOrder, { column, direction: 'asc' }];
+      } else {
+        // Replace existing sort or start new sort (ascending)
+        return [{ column, direction: 'asc' }];
+      }
+    }
+  }
+}

package/src/format-pool.ts

@@ -0,0 +1,61 @@
+// Format pool for shared format objects
+
+import type { CellFormat } from './types';
+
+export class FormatPool {
+  private formats: Map<string, CellFormat> = new Map();
+  private formatToId: Map<string, string> = new Map();
+  private nextId = 1;
+
+  getOrCreate(format: CellFormat): string {
+    const formatKey = this.getFormatKey(format);
+    const existingId = this.formatToId.get(formatKey);
+    if (existingId) {
+      return existingId;
+    }
+
+    const id = `format_${this.nextId++}`;
+    this.formats.set(id, format);
+    this.formatToId.set(formatKey, id);
+    return id;
+  }
+
+  get(formatId: string): CellFormat | undefined {
+    return this.formats.get(formatId);
+  }
+
+  getFormatKey(format: CellFormat): string {
+    // Create a deterministic key from format properties
+    const keys = Object.keys(format).sort();
+    return keys.map((key) => `${key}:${format[key as keyof CellFormat]}`).join('|');
+  }
+
+  clear(): void {
+    this.formats.clear();
+    this.formatToId.clear();
+    this.nextId = 1;
+  }
+
+  size(): number {
+    return this.formats.size;
+  }
+
+  getAllFormats(): Map<string, CellFormat> {
+    return new Map(this.formats);
+  }
+
+  setFormatToId(formatToId: Map<string, string>): void {
+    this.formatToId = formatToId;
+  }
+  setFormats(formats: Map<string, CellFormat>): void {
+    this.formats = formats;
+  }
+
+  getNextId(): number {
+    return this.nextId;
+  }
+
+  setNextId(nextId: number): void {
+    this.nextId = nextId;
+  }
+}

package/src/formula-graph.ts

@@ -0,0 +1,84 @@
+// Formula dependency graph for incremental recalculation
+
+import type { FormulaGraph, FormulaNode, CellValue } from './types';
+
+export class FormulaGraphImpl implements FormulaGraph {
+  nodes: Map<string, FormulaNode> = new Map();
+
+  addFormula(cellKey: string, formula: string, dependencies: Set<string>): void {
+    const node: FormulaNode = {
+      cellKey,
+      formula,
+      dependencies: new Set(dependencies),
+      dependents: new Set(),
+      isDirty: true,
+    };
+
+    // Update dependents of dependencies
+    for (const depKey of dependencies) {
+      const depNode = this.nodes.get(depKey);
+      if (depNode) {
+        depNode.dependents.add(cellKey);
+      }
+    }
+
+    this.nodes.set(cellKey, node);
+  }
+
+  removeFormula(cellKey: string): void {
+    const node = this.nodes.get(cellKey);
+    if (!node) return;
+
+    // Remove from dependents of dependencies
+    for (const depKey of node.dependencies) {
+      const depNode = this.nodes.get(depKey);
+      if (depNode) {
+        depNode.dependents.delete(cellKey);
+      }
+    }
+
+    this.nodes.delete(cellKey);
+  }
+
+  getDependents(cellKey: string): Set<string> {
+    const node = this.nodes.get(cellKey);
+    return node ? new Set(node.dependents) : new Set();
+  }
+
+  getDependencies(cellKey: string): Set<string> {
+    const node = this.nodes.get(cellKey);
+    return node ? new Set(node.dependencies) : new Set();
+  }
+
+  invalidate(cellKey: string): void {
+    const node = this.nodes.get(cellKey);
+    if (!node) return;
+
+    node.isDirty = true;
+    node.cachedValue = undefined;
+
+    // Invalidate all dependents
+    for (const dependentKey of node.dependents) {
+      this.invalidate(dependentKey);
+    }
+  }
+
+  getDirtyCells(): Set<string> {
+    const dirty = new Set<string>();
+    for (const [key, node] of this.nodes) {
+      if (node.isDirty) {
+        dirty.add(key);
+      }
+    }
+    return dirty;
+  }
+
+  markClean(cellKey: string, value: CellValue): void {
+    const node = this.nodes.get(cellKey);
+    if (node) {
+      node.isDirty = false;
+      node.cachedValue = value;
+    }
+  }
+}
+

package/src/formula-parser/cell-reference.ts

@@ -0,0 +1,99 @@
+// Cell reference parsing utilities
+
+import type { CellReference, RangeReference } from './types';
+
+const COLUMN_LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+
+export function parseCellReference(ref: string): CellReference | null {
+  // Match patterns like A1, $A1, A$1, $A$1, sheetname!A1, 'sheet name'!A1
+  let sheetName: string | undefined;
+  let cellPart = ref;
+
+  // Check for cross-sheet reference (sheetname!A1 or 'sheet name'!A1)
+  const sheetMatch = ref.match(/^(?:'([^']+)'|([^!]+))!(.+)$/);
+  if (sheetMatch) {
+    sheetName = sheetMatch[1] || sheetMatch[2]; // Use quoted name if present, otherwise unquoted
+    cellPart = sheetMatch[3];
+  }
+
+  // Match patterns like A1, $A1, A$1, $A$1
+  const match = cellPart.match(/^(\$?)([A-Z]+)(\$?)(\d+)$/);
+  if (!match) return null;
+
+  const [, colAbs, colStr, rowAbs, rowStr] = match;
+  const col = columnLabelToIndex(colStr);
+  const row = parseInt(rowStr, 10) - 1; // Convert to 0-based
+
+  if (col === -1 || isNaN(row) || row < 0) return null;
+
+  // $ prefix means absolute, no $ means relative
+  return {
+    row,
+    col,
+    rowAbsolute: rowAbs === '$', // Row is absolute if $ is present before row number
+    colAbsolute: colAbs === '$', // Column is absolute if $ is present before column letter
+    sheetName,
+  };
+}
+
+export function parseRangeReference(ref: string): RangeReference | null {
+  // Match patterns like A1:B10, $A$1:$B$10, sheetname!A1:B10, 'sheet name'!A1:B10
+  let sheetName: string | undefined;
+  let rangePart = ref;
+
+  // Check for cross-sheet reference (sheetname!A1:B10 or 'sheet name'!A1:B10)
+  const sheetMatch = ref.match(/^(?:'([^']+)'|([^!]+))!(.+)$/);
+  if (sheetMatch) {
+    sheetName = sheetMatch[1] || sheetMatch[2]; // Use quoted name if present, otherwise unquoted
+    rangePart = sheetMatch[3];
+  }
+
+  // Split by colon, but be careful not to split if colon is inside quotes
+  const colonIndex = rangePart.indexOf(':');
+  if (colonIndex === -1) return null;
+
+  const startPart = rangePart.substring(0, colonIndex);
+  const endPart = rangePart.substring(colonIndex + 1);
+
+  const start = parseCellReference(sheetName ? `${sheetName}!${startPart}` : startPart);
+  const end = parseCellReference(sheetName ? `${sheetName}!${endPart}` : endPart);
+
+  if (!start || !end) return null;
+
+  // Ensure both start and end have the same sheet name
+  if (sheetName) {
+    start.sheetName = sheetName;
+    end.sheetName = sheetName;
+  }
+
+  return { start, end };
+}
+
+export function columnLabelToIndex(label: string): number {
+  let index = 0;
+  for (let i = 0; i < label.length; i++) {
+    const char = label[i].toUpperCase();
+    const charIndex = COLUMN_LETTERS.indexOf(char);
+    if (charIndex === -1) return -1;
+    index = index * 26 + (charIndex + 1);
+  }
+  return index - 1; // Convert to 0-based
+}
+
+export function columnIndexToLabel(index: number): string {
+  let label = '';
+  index += 1; // Convert to 1-based
+  while (index > 0) {
+    index -= 1;
+    label = COLUMN_LETTERS[index % 26] + label;
+    index = Math.floor(index / 26);
+  }
+  return label;
+}
+
+export function cellReferenceToKey(ref: CellReference, currentRow: number, currentCol: number): string {
+  const row = ref.rowAbsolute ? ref.row : currentRow + ref.row;
+  const col = ref.colAbsolute ? ref.col : currentCol + ref.col;
+  return `${row}:${col}`;
+}
+

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

@@ -0,0 +1,129 @@
+// Utility functions for adjusting formulas when copying/filling cells
+
+import { parseCellReference, columnIndexToLabel } from './cell-reference';
+
+/**
+ * Adjusts a formula when copying from source cell to target cell.
+ * Increments relative references (without $) and keeps absolute references (with $) unchanged.
+ * 
+ * @param formula The original formula string
+ * @param sourceRow Source cell row (0-based)
+ * @param sourceCol Source cell column (0-based)
+ * @param targetRow Target cell row (0-based)
+ * @param targetCol Target cell column (0-based)
+ * @returns Adjusted formula string
+ */
+export function adjustFormula(
+  formula: string,
+  sourceRow: number,
+  sourceCol: number,
+  targetRow: number,
+  targetCol: number
+): string {
+  if (!formula.startsWith('=')) {
+    // Not a formula, return as-is
+    return formula;
+  }
+
+  const rowOffset = targetRow - sourceRow;
+  const colOffset = targetCol - sourceCol;
+
+  if (rowOffset === 0 && colOffset === 0) {
+    // Same cell, no adjustment needed
+    return formula;
+  }
+
+  // Remove leading = for processing
+  const expression = formula.slice(1);
+
+  // Adjust cell references in the formula
+  // Match patterns like A1, $A1, A$1, $A$1, and ranges like A1:B10, $A$1:$B$10
+  const adjustedExpression = expression.replace(
+    /(\$?[A-Z]+\$?\d+)(?::(\$?[A-Z]+\$?\d+))?/g,
+    (match, startRef, endRef) => {
+      const startCellRef = parseCellReference(startRef);
+      if (!startCellRef) return match;
+
+      // For relative references, parseCellReference returns the absolute position (e.g., A1 = row 0, col 0)
+      // We need to calculate the offset from the source cell, then apply it to the target cell
+      let newStartRow: number;
+      let newStartCol: number;
+
+      if (startCellRef.rowAbsolute) {
+        // Absolute row: keep the same row
+        newStartRow = startCellRef.row;
+      } else {
+        // Relative row: calculate offset from source and apply to target
+        // The referenced cell's absolute row is startCellRef.row
+        // The offset from source is: startCellRef.row - sourceRow
+        // Apply same offset to target: targetRow + (startCellRef.row - sourceRow)
+        newStartRow = targetRow + (startCellRef.row - sourceRow);
+        if (newStartRow < 0) newStartRow = 0;
+      }
+
+      if (startCellRef.colAbsolute) {
+        // Absolute column: keep the same column
+        newStartCol = startCellRef.col;
+      } else {
+        // Relative column: calculate offset from source and apply to target
+        // The referenced cell's absolute col is startCellRef.col
+        // The offset from source is: startCellRef.col - sourceCol
+        // Apply same offset to target: targetCol + (startCellRef.col - sourceCol)
+        newStartCol = targetCol + (startCellRef.col - sourceCol);
+        if (newStartCol < 0) newStartCol = 0;
+      }
+
+      const startColLabel = columnIndexToLabel(newStartCol);
+      const startRowLabel = (newStartRow + 1).toString();
+
+      let startResult = '';
+      if (startCellRef.colAbsolute) startResult += '$';
+      startResult += startColLabel;
+      if (startCellRef.rowAbsolute) startResult += '$';
+      startResult += startRowLabel;
+
+      // If it's a range, adjust the end cell too
+      if (endRef) {
+        const endCellRef = parseCellReference(endRef);
+        if (!endCellRef) return match;
+
+        let newEndRow: number;
+        let newEndCol: number;
+
+        if (endCellRef.rowAbsolute) {
+          // Absolute row: keep the same row
+          newEndRow = endCellRef.row;
+        } else {
+          // Relative row: calculate offset from source and apply to target
+          newEndRow = targetRow + (endCellRef.row - sourceRow);
+          if (newEndRow < 0) newEndRow = 0;
+        }
+
+        if (endCellRef.colAbsolute) {
+          // Absolute column: keep the same column
+          newEndCol = endCellRef.col;
+        } else {
+          // Relative column: calculate offset from source and apply to target
+          newEndCol = targetCol + (endCellRef.col - sourceCol);
+          if (newEndCol < 0) newEndCol = 0;
+        }
+
+        const endColLabel = columnIndexToLabel(newEndCol);
+        const endRowLabel = (newEndRow + 1).toString();
+
+        let endResult = '';
+        if (endCellRef.colAbsolute) endResult += '$';
+        endResult += endColLabel;
+        if (endCellRef.rowAbsolute) endResult += '$';
+        endResult += endRowLabel;
+
+        return `${startResult}:${endResult}`;
+      }
+
+      return startResult;
+    }
+  );
+
+  return '=' + adjustedExpression;
+}
+