mulmoclaude 2.7.0 → 2.8.1

package/src/plugins/spreadsheet/engine/spreadsheet-errors.ts

@@ -1,82 +0,0 @@
-/**
- * Formula errors as a distinct VALUE type.
- *
- * A `#NUM!` produced by `SQRT(-1)` and the text `"#NUM!"` produced by
- * `CONCAT("#N","UM!")` used to be the same string, so IFERROR could not tell a
- * real error from text that merely spells one (#2451). An error is now its own
- * value carrying the code, which is what the error-aware functions check; the
- * display pass renders it back to `#NUM!` so cells look unchanged.
- */
-
-export const SPREADSHEET_ERRORS = ["#NULL!", "#DIV/0!", "#VALUE!", "#REF!", "#NAME?", "#NUM!", "#N/A", "#ERROR!"] as const;
-
-export type SpreadsheetErrorCode = (typeof SPREADSHEET_ERRORS)[number];
-
-/** A formula error, distinct from any string. `toString` yields the code so the
- *  value renders as `#NUM!` wherever the engine coerces a cell value to text. */
-export class SpreadsheetError {
-  constructor(readonly code: SpreadsheetErrorCode) {}
-
-  toString(): string {
-    return this.code;
-  }
-
-  toJSON(): string {
-    return this.code;
-  }
-}
-
-export const NULL_ERROR = new SpreadsheetError("#NULL!");
-export const DIV_ZERO_ERROR = new SpreadsheetError("#DIV/0!");
-export const VALUE_ERROR = new SpreadsheetError("#VALUE!");
-export const REF_ERROR = new SpreadsheetError("#REF!");
-export const NAME_ERROR = new SpreadsheetError("#NAME?");
-export const NUM_ERROR = new SpreadsheetError("#NUM!");
-export const NA_ERROR = new SpreadsheetError("#N/A");
-export const UNKNOWN_ERROR = new SpreadsheetError("#ERROR!");
-
-// One instance per code: two errors of the same kind compare equal, which is how
-// error strings behaved and what the condition/comparison paths still rely on.
-const ERROR_VALUES: Record<SpreadsheetErrorCode, SpreadsheetError> = {
-  "#NULL!": NULL_ERROR,
-  "#DIV/0!": DIV_ZERO_ERROR,
-  "#VALUE!": VALUE_ERROR,
-  "#REF!": REF_ERROR,
-  "#NAME?": NAME_ERROR,
-  "#NUM!": NUM_ERROR,
-  "#N/A": NA_ERROR,
-  "#ERROR!": UNKNOWN_ERROR,
-};
-
-/** The error value for a code. */
-export const spreadsheetError = (code: SpreadsheetErrorCode): SpreadsheetError => ERROR_VALUES[code];
-
-const errorSet: ReadonlySet<string> = new Set(SPREADSHEET_ERRORS);
-
-/** Whether a value is one of the error CODES as a plain string. Text that spells
- *  an error is not an error value — see `isSpreadsheetErrorValue`. */
-export function isSpreadsheetError(value: unknown): value is SpreadsheetErrorCode {
-  return typeof value === "string" && errorSet.has(value);
-}
-
-/** Whether a value IS a formula error, as opposed to text that spells one. */
-export function isSpreadsheetErrorValue(value: unknown): value is SpreadsheetError {
-  return value instanceof SpreadsheetError;
-}
-
-/** The code behind a value: an error value's own code, or the code a plain
- *  string spells. Used where a literal `#REF!` written into a cell must still
- *  poison the arithmetic that reads it, provenance aside. */
-export function errorCodeOf(value: unknown): SpreadsheetErrorCode | null {
-  if (isSpreadsheetErrorValue(value)) return value.code;
-  return isSpreadsheetError(value) ? value : null;
-}
-
-/** Whether an evaluated result should be treated as an error: a formula error
- *  VALUE, a NaN / infinite number, or a missing value. This is what IFERROR
- *  catches — deliberately NOT a look-alike string, which is ordinary text. */
-export function isErrorResult(value: unknown): boolean {
-  if (value === null || value === undefined) return true;
-  if (typeof value === "number") return Number.isNaN(value) || !Number.isFinite(value);
-  return isSpreadsheetErrorValue(value);
-}

package/src/plugins/spreadsheet/engine/textFormat.ts

@@ -1,108 +0,0 @@
-/**
- * Excel number-format patterns for the TEXT function.
- *
- * Deliberately separate from `formatter.formatNumber`, which renders CELL
- * display values: the two disagree on defaults — Excel's `TEXT(0.5,"0%")` is
- * `"50%"`, while a cell carrying the format `0%` has always displayed
- * `"50.00%"` — so sharing the whole path would move every formatted cell in
- * every stored workbook. Only the digit-grouping primitive is shared.
- */
-
-import { groupThousands } from "./formatter";
-
-const PERCENT_SCALE = 100;
-
-// Characters that introduce an Excel format feature this module does not
-// render (quoted literals, fill/skip, fractions, dates, text placeholder,
-// negative/zero sections). Seeing one means the caller keeps its own fallback.
-const UNSUPPORTED_LITERAL_CHARS = `?\\*_[]"@;/`;
-
-// One run of digit placeholders, optionally carrying grouping commas and a
-// decimal point: the `#,##0.00` family.
-const NUMERIC_CORE_RE = /[#0][#0,.]*/;
-const PLACEHOLDER_RE = /[#0]/;
-const TRAILING_ZEROS_RE = /0+$/;
-
-export interface NumberPattern {
-  prefix: string;
-  suffix: string;
-  useGrouping: boolean;
-  integerMinDigits: number;
-  minDecimals: number;
-  maxDecimals: number;
-  isPercent: boolean;
-}
-
-const countOf = (text: string, chars: string): number => Array.from(text).filter((char) => chars.includes(char)).length;
-
-const hasUnsupportedLiteral = (text: string): boolean => Array.from(text).some((char) => UNSUPPORTED_LITERAL_CHARS.includes(char));
-
-/**
- * Split a format code into a leading literal, one numeric core and a trailing
- * literal, or `null` when the code uses a feature this module does not render.
- */
-export const parseNumberPattern = (pattern: string): NumberPattern | null => {
-  const core = NUMERIC_CORE_RE.exec(pattern);
-  if (!core) return null;
-  // A comma AFTER the last placeholder scales by a thousand in Excel.
-  if (core[0].endsWith(",")) return null;
-
-  const prefix = pattern.slice(0, core.index);
-  const suffix = pattern.slice(core.index + core[0].length);
-  // A second placeholder run (`0.00E+00`, `# ?/?`) is a format of its own kind.
-  if (PLACEHOLDER_RE.test(suffix)) return null;
-  if (hasUnsupportedLiteral(prefix) || hasUnsupportedLiteral(suffix)) return null;
-
-  const [integerPart, decimalPart = "", ...extraParts] = core[0].split(".");
-  if (integerPart === undefined || extraParts.length > 0) return null;
-
-  return {
-    prefix,
-    suffix,
-    useGrouping: integerPart.includes(","),
-    integerMinDigits: countOf(integerPart, "0"),
-    minDecimals: countOf(decimalPart, "0"),
-    maxDecimals: countOf(decimalPart, "#0"),
-    isPercent: prefix.includes("%") || suffix.includes("%"),
-  };
-};
-
-// `0` keeps a decimal digit, `#` drops it once it is a trailing zero — so
-// `0.0#` renders 0.5 as "0.5" but 0.25 as "0.25".
-const trimOptionalZeros = (decimals: string, minDecimals: number): string => {
-  const kept = decimals.replace(TRAILING_ZEROS_RE, "");
-  return kept.length >= minDecimals ? kept : decimals.slice(0, minDecimals);
-};
-
-const renderDigits = (absValue: number, pattern: NumberPattern): string => {
-  const fixed = absValue.toFixed(pattern.maxDecimals);
-  const point = fixed.indexOf(".");
-  const wholeDigits = point === -1 ? fixed : fixed.slice(0, point);
-  const decimalDigits = point === -1 ? "" : fixed.slice(point + 1);
-  const padded = wholeDigits.padStart(pattern.integerMinDigits, "0");
-  const whole = pattern.useGrouping ? groupThousands(padded) : padded;
-  const decimals = trimOptionalZeros(decimalDigits, pattern.minDecimals);
-  return decimals ? `${whole}.${decimals}` : whole;
-};
-
-const isZeroText = (digits: string): boolean => Array.from(digits).every((char) => char === "0" || char === "," || char === ".");
-
-/**
- * Render a number the way Excel's TEXT does for the common numeric format
- * codes: `#,##0` grouping, `0.00` fixed decimals, `0.##` optional decimals, a
- * literal prefix/suffix such as `$`, and a `%` that scales by 100.
- *
- * Returns `null` for a format code it does not render, so the caller can keep
- * its own fallback rather than inventing a plausible wrong string.
- */
-export const formatWithPattern = (value: number, pattern: string): string | null => {
-  if (!Number.isFinite(value)) return null;
-  const spec = parseNumberPattern(pattern);
-  if (!spec) return null;
-
-  const scaled = spec.isPercent ? value * PERCENT_SCALE : value;
-  const digits = renderDigits(Math.abs(scaled), spec);
-  // The sign follows the ROUNDED digits: -0.001 under "0.00" reads "0.00", not "-0.00".
-  const sign = scaled < 0 && !isZeroText(digits) ? "-" : "";
-  return `${sign}${spec.prefix}${digits}${spec.suffix}`;
-};

package/src/plugins/spreadsheet/engine/translateFormula.ts

@@ -1,69 +0,0 @@
-/**
- * Excel-formula → JS-expression translation
- *
- * Pure string transforms that turn the Excel-operator form of an
- * already-substituted expression (cell references resolved, functions replaced)
- * into the JavaScript form handed to `new Function`, plus the character
- * allowlists that gate that evaluation. No engine or evaluator state is
- * captured — every function here is input → output only.
- */
-
-/** Excel `^` exponentiation → JS `**`.
- *
- * Excel's `^` is left-associative (`2^3^2` = `(2^3)^2` = 64); JS `**` is
- * right-associative (`2**3**2` = `2**(3**2)` = 512). This transform does not
- * bridge that difference, so a chained `^` still evaluates the JS way — a known
- * limitation tracked separately (#2359), pinned by the tests. */
-export function caretToPow(expr: string): string {
-  return expr.replace(/\^/g, "**");
-}
-
-/** Move the "inside a string literal" marker across one quote character.
- * Empty marker means "not in a literal"; otherwise it holds the opening quote. */
-function toggleQuote(openQuote: string, char: string): string {
-  if (openQuote === "") return char;
-  return char === openQuote ? "" : openQuote;
-}
-
-/** Excel `&` string concatenation → JS `+`, leaving any `&` inside a quoted
- *  string literal untouched. A quote toggles the "inside a literal" state only
- *  when it is not backslash-escaped. */
-export function replaceConcatOperator(expr: string): string {
-  const chars = expr.split("");
-  const out: string[] = [];
-  let openQuote = "";
-  chars.forEach((char, index) => {
-    const escaped = index > 0 && chars[index - 1] === "\\";
-    if (!escaped && (char === '"' || char === "'")) {
-      openQuote = toggleQuote(openQuote, char);
-    }
-    out.push(char === "&" && openQuote === "" ? "+" : char);
-  });
-  return out.join("");
-}
-
-/** Excel `=` equality → JS `==`, without disturbing `<=`, `>=` or `!=`. A single
- *  `=` is rewritten only when flanked by a non-`<>!` char on the left and a
- *  non-`=` on the right.
- *
- * Known limitations, pinned by the tests and tracked separately (#2359): the
- * match consumes both flanking characters so replacements do not overlap
- * (`5=6=7` → `5==6=7`, only the first rewritten); a `=` at either end of the
- * expression has no left/right neighbour and is left alone (`5=` → `5=`); and a
- * hand-typed `==` becomes `===` (its second `=` matches). Excel never emits the
- * last two, so they only bite malformed input. */
-export function rewriteComparisonEq(expr: string): string {
-  return expr.replace(/([^<>!])=([^=])/g, "$1==$2");
-}
-
-/** Whether an expression contains only the characters an arithmetic evaluation
- *  may see: digits, ` + - * / ( ) . ` and spaces. Gates `new Function`. */
-export function isSafeArithmetic(expr: string): boolean {
-  return /^[\d+\-*/(). ]+$/.test(expr);
-}
-
-/** Whether an expression contains only the characters a comparison evaluation
- *  may see: the arithmetic set plus ` < > ! = `. Gates `new Function`. */
-export function isSafeComparison(expr: string): boolean {
-  return /^[\d+\-*/(). <>!=]+$/.test(expr);
-}

package/src/plugins/spreadsheet/engine/types.ts

@@ -1,81 +0,0 @@
-/**
- * Spreadsheet Engine Type Definitions
- */
-
-import type { SpreadsheetError } from "./spreadsheet-errors";
-
-/** A value as it is STORED in a cell and serialized to the workbook JSON. A
- *  formula error is never stored — it only exists as a computed result. */
-export type StoredCellValue = number | string | boolean;
-
-/** A value as the engine COMPUTES it: a stored value, or a formula error. */
-export type CellValue = StoredCellValue | SpreadsheetError;
-
-export interface SpreadsheetCell {
-  v: StoredCellValue; // Value or formula (formulas start with "=")
-  f?: string; // Format code (e.g., "$#,##0.00")
-}
-
-export interface SheetData {
-  name: string;
-  data: SpreadsheetCell[][];
-}
-
-export interface CalculatedSheet {
-  name: string;
-  data: CellValue[][]; // Calculated values
-  formulas: FormulaInfo[]; // Formula metadata
-  errors: CalculationError[]; // Any errors encountered
-}
-
-export interface CellRef {
-  row: number;
-  col: number;
-  sheet?: string; // For cross-sheet refs
-  absolute?: {
-    // For $A$1 style
-    row: boolean;
-    col: boolean;
-  };
-}
-
-export interface RangeRef {
-  start: CellRef;
-  end: CellRef;
-}
-
-export interface EvaluationContext {
-  currentSheet: string;
-  sheets: Map<string, SpreadsheetCell[][]>;
-  calculatedValues?: Map<string, CellValue>; // Cache
-}
-
-export interface FormulaInfo {
-  cell: CellRef;
-  formula: string;
-  dependencies: CellRef[];
-  result: CellValue;
-}
-
-export interface CalculationError {
-  cell: CellRef;
-  formula: string;
-  error: string;
-  type: "circular" | "invalid_ref" | "div_zero" | "syntax" | "unknown";
-}
-
-/** Per-calculation settings that change how cell CONTENT is read, as opposed
- *  to how the engine runs. Passed down explicitly so the engine stays pure —
- *  no ambient locale, no import-time state. */
-export interface CalculateOptions {
-  /** Read an ambiguous `A/B/YYYY` date as day-first. Only affects dates whose
-   *  two leading numbers are both 12 or under; anything else decides itself.
-   *  See engine/date-locale.ts for how a locale maps onto this. */
-  preferDDMMYYYY?: boolean;
-}
-
-export interface EngineOptions extends CalculateOptions {
-  maxIterations?: number; // For circular reference detection
-  enableCrossSheetRefs?: boolean; // Default: true
-  strictMode?: boolean; // Throw on errors vs. return 0
-}

package/src/plugins/spreadsheet/keyboardNav.ts

@@ -1,38 +0,0 @@
-// Pure helpers behind the spreadsheet mini-editor's arrow-key
-// navigation. Lifted out of View.vue so each rule can be unit-tested
-// without spinning up Vue or a DOM.
-
-export interface CellPosition {
-  row: number;
-  col: number;
-}
-
-// Sheet shape we actually rely on — the mini-editor only reads
-// `data` as a 2D array, so the type is intentionally loose to match
-// what arrives from `JSON.parse(editableData.value)`.
-export interface SheetLike {
-  data?: unknown[][];
-}
-
-export function getArrowKeyOffset(key: string, row: number, col: number): CellPosition | null {
-  switch (key) {
-    case "ArrowUp":
-      return { row: Math.max(0, row - 1), col };
-    case "ArrowDown":
-      return { row: row + 1, col };
-    case "ArrowLeft":
-      return { row, col: Math.max(0, col - 1) };
-    case "ArrowRight":
-      return { row, col: col + 1 };
-    default:
-      return null;
-  }
-}
-
-export function isWithinSheetBounds(sheet: SheetLike | null | undefined, row: number, col: number): boolean {
-  if (!sheet?.data) return false;
-  if (row < 0 || row >= sheet.data.length) return false;
-  const rowData = sheet.data[row];
-  if (!rowData) return false;
-  return col >= 0 && col < rowData.length;
-}