@lotics/xlsx 0.1.0

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@lotics/xlsx",
+  "version": "0.1.0",
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts",
+    "./*": "./src/*.ts"
+  },
+  "files": [
+    "src"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "typecheck": "tsgo --noEmit",
+    "lint": "oxlint",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@formulajs/formulajs": "^4.5.6",
+    "fast-formula-parser": "^1.0.19",
+    "fast-xml-parser": "^5.5.6",
+    "fflate": "^0.8.2"
+  },
+  "devDependencies": {
+    "exceljs": "^4.4.0",
+    "vitest": "^4.1.7"
+  }
+}

package/src/auto_sum.test.ts

@@ -0,0 +1,71 @@
+import { computeAutoSumFormula } from "./auto_sum";
+import { WorkbookModel, SheetModel, StyleRegistry } from "./workbook_model";
+
+function makeWorkbook(): WorkbookModel {
+  const styles = new StyleRegistry();
+  const sheet = new SheetModel("Sheet1");
+  return new WorkbookModel({ sheets: [sheet], activeSheetIndex: 0, styles });
+}
+
+describe("computeAutoSumFormula", () => {
+  test("detects contiguous numeric cells above", () => {
+    const wb = makeWorkbook();
+    wb.sheets[0].set("A1", 10);
+    wb.sheets[0].set("A2", 20);
+    wb.sheets[0].set("A3", 30);
+    // Active cell is A4 (row 4, col 1)
+    const result = computeAutoSumFormula(wb, 0, 4, 1);
+    expect(result).toBe("=SUM(A1:A3)");
+  });
+
+  test("detects contiguous numeric cells to the left", () => {
+    const wb = makeWorkbook();
+    wb.sheets[0].set("A1", 10);
+    wb.sheets[0].set("B1", 20);
+    wb.sheets[0].set("C1", 30);
+    // Active cell is D1 (row 1, col 4)
+    const result = computeAutoSumFormula(wb, 0, 1, 4);
+    expect(result).toBe("=SUM(A1:C1)");
+  });
+
+  test("prefers upward over leftward", () => {
+    const wb = makeWorkbook();
+    wb.sheets[0].set("B1", 10);
+    wb.sheets[0].set("B2", 20);
+    wb.sheets[0].set("A3", 5);
+    // Active cell is B3: has cells above AND to the left
+    const result = computeAutoSumFormula(wb, 0, 3, 2);
+    expect(result).toBe("=SUM(B1:B2)");
+  });
+
+  test("returns null when no contiguous numeric cells", () => {
+    const wb = makeWorkbook();
+    // A1 has text, not numeric
+    wb.sheets[0].set("A1", "hello");
+    const result = computeAutoSumFormula(wb, 0, 2, 1);
+    expect(result).toBeNull();
+  });
+
+  test("returns null for empty surroundings", () => {
+    const wb = makeWorkbook();
+    const result = computeAutoSumFormula(wb, 0, 5, 5);
+    expect(result).toBeNull();
+  });
+
+  test("single numeric cell above", () => {
+    const wb = makeWorkbook();
+    wb.sheets[0].set("A1", 42);
+    const result = computeAutoSumFormula(wb, 0, 2, 1);
+    expect(result).toBe("=SUM(A1:A1)");
+  });
+
+  test("stops at non-numeric cell", () => {
+    const wb = makeWorkbook();
+    wb.sheets[0].set("A1", "header");
+    wb.sheets[0].set("A2", 10);
+    wb.sheets[0].set("A3", 20);
+    // Active cell is A4 — should detect A2:A3 only
+    const result = computeAutoSumFormula(wb, 0, 4, 1);
+    expect(result).toBe("=SUM(A2:A3)");
+  });
+});

package/src/auto_sum.ts

@@ -0,0 +1,83 @@
+// =============================================================================
+// AutoSum
+// =============================================================================
+//
+// Detects a contiguous numeric range above or to the left of the active cell
+// and returns a SUM formula string. Returns null if no range is found.
+// =============================================================================
+
+import type { WorkbookModel } from "./workbook_model";
+import { rowColToRef } from "./excel_utils";
+
+/**
+ * Compute an AutoSum formula for the given cell position.
+ * Looks upward first for contiguous numeric cells, then left.
+ * Returns a formula string like "=SUM(A1:A5)" or null if no range found.
+ */
+export function computeAutoSumFormula(
+  workbook: WorkbookModel,
+  sheetIndex: number,
+  row: number,
+  col: number,
+): string | null {
+  const sheet = workbook.sheets[sheetIndex];
+
+  // Look upward for contiguous numeric cells
+  const upRange = findContiguousNumericRange(sheet, row, col, -1, 0);
+  if (upRange) {
+    return `=SUM(${rowColToRef(upRange.startRow, upRange.startCol)}:${rowColToRef(upRange.endRow, upRange.endCol)})`;
+  }
+
+  // Look left for contiguous numeric cells
+  const leftRange = findContiguousNumericRange(sheet, row, col, 0, -1);
+  if (leftRange) {
+    return `=SUM(${rowColToRef(leftRange.startRow, leftRange.startCol)}:${rowColToRef(leftRange.endRow, leftRange.endCol)})`;
+  }
+
+  return null;
+}
+
+function findContiguousNumericRange(
+  sheet: { getCell(ref: string): { value: unknown } | undefined },
+  row: number,
+  col: number,
+  dRow: number,
+  dCol: number,
+): { startRow: number; startCol: number; endRow: number; endCol: number } | null {
+  let r = row + dRow;
+  let c = col + dCol;
+  let endR = -1;
+  let endC = -1;
+
+  // Walk in the direction, collecting contiguous numeric cells
+  while (r >= 1 && c >= 1) {
+    const ref = rowColToRef(r, c);
+    const cell = sheet.getCell(ref);
+    if (!cell || typeof cell.value !== "number") break;
+    if (endR === -1) {
+      endR = r;
+      endC = c;
+    }
+    r += dRow;
+    c += dCol;
+  }
+
+  if (endR === -1) return null;
+
+  // The range goes from the farthest cell found to the cell adjacent to the target
+  const startR = dRow !== 0 ? r - dRow : row;
+  const startC = dCol !== 0 ? c - dCol : col;
+
+  // Ensure we have at least one cell
+  if (startR === endR && startC === endC) {
+    return { startRow: startR, startCol: startC, endRow: endR, endCol: endC };
+  }
+
+  // Order so start < end
+  return {
+    startRow: Math.min(startR, endR),
+    startCol: Math.min(startC, endC),
+    endRow: Math.max(startR, endR),
+    endCol: Math.max(startC, endC),
+  };
+}

package/src/canvas_cf.ts

@@ -0,0 +1,135 @@
+// =============================================================================
+// Canvas Conditional Formatting Renderer
+// =============================================================================
+//
+// Draws conditional formatting overlays on the canvas:
+// - Data bars (gradient or solid fill within cell)
+// - Icon sets (SVG→Image→drawImage)
+// - Color scale backgrounds (handled by CfOverlay.backgroundColor in cell draw)
+// - Style overrides (font color/bold/italic from CF rules)
+// =============================================================================
+
+import type { CfOverlay } from "./excel_cf_evaluate";
+
+// =============================================================================
+// Data bar rendering
+// =============================================================================
+
+export function drawDataBar(
+  ctx: CanvasRenderingContext2D,
+  overlay: CfOverlay,
+  cellX: number,
+  cellY: number,
+  cellW: number,
+  cellH: number,
+): void {
+  if (overlay.dataBarWidth === undefined || overlay.dataBarColor === undefined) return;
+
+  const barHeight = Math.max(cellH - 6, 4);
+  const barY = cellY + (cellH - barHeight) / 2;
+  const barWidth = (overlay.dataBarWidth / 100) * (cellW - 4);
+
+  // Draw bar with gradient
+  const gradient = ctx.createLinearGradient(cellX + 2, barY, cellX + 2 + barWidth, barY);
+  gradient.addColorStop(0, overlay.dataBarColor);
+  gradient.addColorStop(1, adjustAlpha(overlay.dataBarColor, 0.3));
+  ctx.fillStyle = gradient;
+  ctx.fillRect(cellX + 2, barY, barWidth, barHeight);
+
+  // Border around bar
+  ctx.strokeStyle = overlay.dataBarColor;
+  ctx.lineWidth = 0.5;
+  ctx.strokeRect(cellX + 2, barY, barWidth, barHeight);
+}
+
+// =============================================================================
+// Icon rendering
+// =============================================================================
+
+// Cache for parsed SVG → ImageBitmap
+const iconCache = new Map<string, HTMLImageElement>();
+
+export function drawIcon(
+  ctx: CanvasRenderingContext2D,
+  overlay: CfOverlay,
+  cellX: number,
+  cellY: number,
+  cellH: number,
+): void {
+  if (!overlay.iconSvg) return;
+
+  const iconSize = Math.min(cellH - 4, 16);
+  const iconY = cellY + (cellH - iconSize) / 2;
+  const iconX = cellX + 2;
+
+  // Try to draw from cache
+  let img = iconCache.get(overlay.iconSvg);
+  if (img && img.complete) {
+    ctx.drawImage(img, iconX, iconY, iconSize, iconSize);
+    return;
+  }
+
+  // Create and cache image element from SVG
+  if (!img) {
+    img = new Image();
+    const svgBlob = new Blob([overlay.iconSvg], { type: "image/svg+xml" });
+    img.src = URL.createObjectURL(svgBlob);
+    iconCache.set(overlay.iconSvg, img);
+    img.onload = () => {
+      // Redraw will pick up the cached image next frame
+      URL.revokeObjectURL(img!.src);
+    };
+  }
+}
+
+/**
+ * Returns the horizontal offset needed if an icon is present,
+ * so cell text can be shifted right.
+ */
+export function getIconOffset(overlay: CfOverlay | undefined, cellH: number): number {
+  if (!overlay?.iconSvg) return 0;
+  return Math.min(cellH - 4, 16) + 4; // icon width + gap
+}
+
+// =============================================================================
+// Apply CF style overrides
+// =============================================================================
+
+/**
+ * Returns modified style properties from CF overlay.
+ * Call this before drawing cell text to apply CF color/bold/italic.
+ */
+export function applyCfStyleOverrides(
+  overlay: CfOverlay | undefined,
+  fontColor: string,
+  fontBold: boolean,
+  fontItalic: boolean,
+): { fontColor: string; fontBold: boolean; fontItalic: boolean } {
+  if (!overlay) return { fontColor, fontBold, fontItalic };
+  return {
+    fontColor: overlay.fontColor ?? fontColor,
+    fontBold: overlay.fontBold ?? fontBold,
+    fontItalic: overlay.fontItalic ?? fontItalic,
+  };
+}
+
+// =============================================================================
+// Helpers
+// =============================================================================
+
+function adjustAlpha(color: string, alpha: number): string {
+  // Parse rgb/rgba and return with new alpha
+  const match = color.match(/rgba?\((\d+),\s*(\d+),\s*(\d+)/);
+  if (match) {
+    return `rgba(${match[1]}, ${match[2]}, ${match[3]}, ${alpha})`;
+  }
+  // Hex color
+  const hexMatch = color.match(/^#([0-9a-fA-F]{6})/);
+  if (hexMatch) {
+    const r = parseInt(hexMatch[1].slice(0, 2), 16);
+    const g = parseInt(hexMatch[1].slice(2, 4), 16);
+    const b = parseInt(hexMatch[1].slice(4, 6), 16);
+    return `rgba(${r}, ${g}, ${b}, ${alpha})`;
+  }
+  return color;
+}