@pixerate/editor 0.22.0 → 0.24.0

package/dist/{chunk-RU52I7QO.js → chunk-U5KWZU4X.js}

@@ -1,18 +1,33 @@
+import {
+  parseCsv,
+  parseTsv,
+  serializeCsv,
+  serializeTsv
+} from "./chunk-664LQYFJ.js";
 import {
   FormulaEvaluator,
+  NumberFormat,
   WHOLE_COLUMN_END_ROW,
   colNameToIndex,
+  compareValues,
   describeFormulaError,
+  formatTextFunction,
   getFormulaArgumentSpecIndex,
   getFormulaFunction,
   getFormulaSignature,
   getFormulaSignatureParts,
   indexToColName,
+  isBlank,
   isFormulaError,
+  numericValue,
+  parseCellInput,
   parseFormula,
+  parseIsoDate,
   searchFormulaFunctions,
+  sortCompareValues,
+  toText,
   tokenizeFormula
-} from "./chunk-DENSCKFC.js";
+} from "./chunk-3CN2WD3X.js";
 
 // src/spreadsheet/formula/dependency-graph.ts
 var columnDependencyKey = (col) => `${col.toUpperCase()}:`;
@@ -560,6 +575,68 @@ function applyFormulaSuggestion(input, caret, name) {
   return { value, caret: start + insert.length + (hasParen ? 1 : 0) };
 }
 
+// src/spreadsheet/numfmt/presets.ts
+var NUMBER_FORMAT_PRESETS = [
+  { id: "general", label: "General", code: "General" },
+  { id: "number", label: "Number (0.00)", code: "0.00" },
+  { id: "currency", label: "Currency ($1,234.50)", code: '"$"#,##0.00' },
+  { id: "percent", label: "Percent (12.5%)", code: "0.0%" },
+  { id: "date", label: "Date (3/14/2026)", code: "m/d/yyyy" },
+  { id: "time", label: "Time (1:30 PM)", code: "h:mm AM/PM" }
+];
+function numberFormatForCellFormat(format) {
+  switch (format) {
+    case "currency":
+      return '"$"#,##0.00';
+    case "percentage":
+      return "0%";
+    case "date":
+      return "m/d/yyyy";
+    default:
+      return void 0;
+  }
+}
+function cellFormatForNumberFormat(code) {
+  switch (NumberFormat.parseCached(code).kind()) {
+    case "number":
+    case "fraction":
+    case "scientific":
+    case "special":
+      return "number";
+    case "currency":
+    case "accounting":
+      return "currency";
+    case "percentage":
+      return "percentage";
+    case "date":
+      return "date";
+    case "text":
+      return "text";
+    default:
+      return void 0;
+  }
+}
+var isGeneralNumberFormat = (code) => code === void 0 || NumberFormat.parseCached(code).isGeneral();
+
+// src/spreadsheet/formula/format.ts
+function formatCellForDisplay(cell) {
+  if (!cell) return { text: "", numeric: false };
+  if (cell.error) return { text: cell.error, numeric: false };
+  const { value } = cell;
+  const code = cell.numberFormat ?? (typeof value === "number" ? numberFormatForCellFormat(cell.format) : void 0);
+  if (code !== void 0 && !isGeneralNumberFormat(code) && !isBlank(value) && typeof value !== "boolean") {
+    return NumberFormat.parseCached(code).format(value);
+  }
+  return { text: toText(value), numeric: typeof value === "number" };
+}
+function formatCellDisplay(cell) {
+  return formatCellForDisplay(cell).text;
+}
+function formatValueWithCode(value, format) {
+  const result = formatTextFunction(value, format);
+  return "text" in result ? result.text : null;
+}
+
 // src/spreadsheet/datasource/index.ts
 var DataSourceBinder = class {
   dataSources = /* @__PURE__ */ new Map();
@@ -678,28 +755,41 @@ function compareCellValues(a, b, direction = "asc") {
   const aBlank = isBlankValue(a);
   const bBlank = isBlankValue(b);
   if (aBlank || bBlank) return aBlank === bBlank ? 0 : aBlank ? 1 : -1;
-  const aNum = toNumber(a);
-  const bNum = toNumber(b);
   let result;
-  if (aNum !== null && bNum !== null) result = aNum - bNum;
-  else if (aNum !== null) result = -1;
-  else if (bNum !== null) result = 1;
-  else result = compareText(String(a), String(b));
+  if (isPlainText(a) && isPlainText(b) && !(parseIsoDate(a) && parseIsoDate(b))) {
+    result = compareText(a, b);
+  } else {
+    result = sortCompareValues(a, b);
+  }
   if (result === 0) return 0;
   return direction === "desc" ? -Math.sign(result) : Math.sign(result);
 }
+var isPlainText = (value) => typeof value === "string" && !isFormulaError(value);
+function filterValue(value) {
+  if (isBlankValue(value) || isFormulaError(value)) return null;
+  if (typeof value === "number") return Number.isFinite(value) ? { value, kind: "number" } : null;
+  if (typeof value === "boolean") return { value, kind: "boolean" };
+  const num = numericValue(value);
+  if (num !== null) return { value: num, kind: "number" };
+  const text = String(value);
+  return { value: text, kind: parseIsoDate(text) ? "number" : "text" };
+}
+function filterOperand(operand) {
+  if (typeof operand !== "string") return filterValue(operand);
+  if (operand.trim() === "") return null;
+  const parsed = parseCellInput(operand.trim());
+  if (parsed.type === "number" || parsed.type === "date" || parsed.type === "boolean") return filterValue(parsed.value);
+  return { value: operand, kind: "text" };
+}
 function compareForFilter(value, operand) {
-  if (isBlankValue(value) || isBlankValue(operand)) return null;
-  const a = toNumber(value);
-  const b = toNumber(operand);
-  if (a !== null && b !== null) return a - b;
-  if (a !== null || b !== null) return null;
-  return compareText(String(value), String(operand));
+  const a = filterValue(value);
+  const b = filterOperand(operand);
+  if (!a || !b || a.kind !== b.kind) return null;
+  return compareValues(a.value, b.value);
 }
 function looselyEquals(value, operand) {
-  const a = toNumber(value);
-  const b = toNumber(operand);
-  if (a !== null && b !== null) return a === b;
+  const c = compareForFilter(value, operand);
+  if (c !== null) return c === 0;
   return String(value ?? "").trim().toLowerCase() === String(operand ?? "").trim().toLowerCase();
 }
 function matchesFilterRule(value, rule) {
@@ -774,7 +864,8 @@ function classifyFillValue(raw) {
   if (raw.trim() === "") return { kind: "blank" };
   const num = toNumber(raw);
   if (num !== null) return { kind: "number", value: num };
-  const date = ISO_DATE_PATTERN.exec(raw.trim());
+  const typed = parseCellInput(raw);
+  const date = ISO_DATE_PATTERN.exec(typed.type === "date" ? String(typed.value) : raw.trim());
   if (date) {
     const [year, month, day] = [Number(date[1]), Number(date[2]), Number(date[3])];
     const time = Date.UTC(year, month - 1, day);
@@ -892,113 +983,6 @@ function getFillDirection(source, target) {
   return null;
 }
 
-// src/spreadsheet/csv.ts
-var BOM = "\uFEFF";
-function parseCsv(text, options = {}) {
-  const delimiter = options.delimiter ?? ",";
-  if (delimiter.length !== 1 || delimiter === '"' || delimiter === "\n" || delimiter === "\r") {
-    throw new Error(`Invalid CSV delimiter: ${JSON.stringify(delimiter)}`);
-  }
-  const input = text.startsWith(BOM) ? text.slice(1) : text;
-  const records = [];
-  let record = [];
-  let field = "";
-  let i = 0;
-  let recordStarted = false;
-  const endField = () => {
-    record.push(field);
-    field = "";
-  };
-  const endRecord = () => {
-    endField();
-    records.push(record);
-    record = [];
-    recordStarted = false;
-  };
-  let atFieldStart = true;
-  while (i < input.length) {
-    const char = input[i];
-    if (char === '"' && atFieldStart) {
-      const quoted = readQuoted(input, i, delimiter);
-      if (quoted.wellFormed || !options.requireWellFormedQuotes) {
-        recordStarted = true;
-        atFieldStart = false;
-        field += quoted.value;
-        i = quoted.end;
-        continue;
-      }
-    }
-    if (char === delimiter) {
-      recordStarted = true;
-      endField();
-      atFieldStart = true;
-      i++;
-      continue;
-    }
-    if (char === "\r" || char === "\n") {
-      endRecord();
-      atFieldStart = true;
-      i += char === "\r" && input[i + 1] === "\n" ? 2 : 1;
-      continue;
-    }
-    recordStarted = true;
-    atFieldStart = false;
-    field += char;
-    i++;
-  }
-  if (recordStarted || field !== "" || record.length > 0) endRecord();
-  return records;
-}
-function readQuoted(input, start, delimiter) {
-  let value = "";
-  let i = start + 1;
-  while (i < input.length) {
-    if (input[i] === '"') {
-      if (input[i + 1] === '"') {
-        value += '"';
-        i += 2;
-        continue;
-      }
-      const next = input[i + 1];
-      const wellFormed = next === void 0 || next === delimiter || next === "\r" || next === "\n";
-      return { value, end: i + 1, wellFormed };
-    }
-    value += input[i];
-    i++;
-  }
-  return { value, end: i, wellFormed: false };
-}
-function escapeCsvField(value, delimiter = ",", quoteAll = false) {
-  if (quoteAll || value.includes(delimiter) || /["\r\n]/.test(value)) {
-    return `"${value.replace(/"/g, '""')}"`;
-  }
-  return value;
-}
-function serializeCsv(rows, options = {}) {
-  const delimiter = options.delimiter ?? ",";
-  const lineEnding = options.lineEnding ?? "\r\n";
-  const body = rows.map(
-    (row) => row.map((value) => escapeCsvField(value == null ? "" : String(value), delimiter, options.quoteAll)).join(delimiter)
-  ).join(lineEnding);
-  return options.bom ? BOM + body : body;
-}
-function parseTsv(text) {
-  const normalized = text.startsWith(BOM) ? text.slice(1) : text;
-  if (!normalized.includes('"')) {
-    const body = normalized.replace(/\r\n?/g, "\n").replace(/\n$/, "");
-    return body === "" ? [] : body.split("\n").map((line) => line.split("	"));
-  }
-  return parseCsv(normalized, { delimiter: "	", requireWellFormedQuotes: true });
-}
-function serializeTsv(rows) {
-  return rows.map(
-    (row) => row.map((value) => {
-      const text = value == null ? "" : String(value);
-      return /[\t\r\n]/.test(text) || text.startsWith('"') ? `"${text.replace(/"/g, '""')}"` : text;
-    }).join("	")
-  ).join("\n");
-}
-
 // src/spreadsheet/clipboard.ts
 var SPREADSHEET_CLIPBOARD_MIME = "application/x.pixerate.spreadsheet+json";
 var displayText = (value) => value === null || value === void 0 ? "" : String(value);
@@ -1071,11 +1055,16 @@ function parseHtmlTable(html) {
   return rows.length > 0 ? rows : null;
 }
 function createSpreadsheetClipboardData(cells, origin) {
-  const values = cells.map((row) => row.map((cell) => cell.value));
-  const payload = { type: "pixerate-spreadsheet", version: 1, origin, cells };
+  const texts = cells.map((row) => row.map((cell) => cell.text ?? displayText(cell.value)));
+  const payload = {
+    type: "pixerate-spreadsheet",
+    version: 1,
+    origin,
+    cells: cells.map((row) => row.map(({ raw, value }) => ({ raw, value })))
+  };
   return {
-    "text/plain": serializeTsv(values.map((row) => row.map(displayText))),
-    "text/html": serializeHtmlTable(values),
+    "text/plain": serializeTsv(texts),
+    "text/html": serializeHtmlTable(texts),
     [SPREADSHEET_CLIPBOARD_MIME]: JSON.stringify(payload)
   };
 }
@@ -1289,6 +1278,7 @@ function buildSpreadsheetView(doc, getValue) {
 
 // src/spreadsheet/controller.ts
 var nextIdSequence = 0;
+var DEFAULT_MAX_HISTORY_BYTES = 64 * 1024 * 1024;
 var MAX_SPILL_PASSES = 25;
 var spillCellId = (rowId, colId) => `${rowId}\0${colId}`;
 var SpreadsheetController = class {
@@ -1308,6 +1298,7 @@ var SpreadsheetController = class {
   undoStack = [];
   redoStack = [];
   isApplyingHistory = false;
+  maxHistoryBytes;
   // Set while importing TSV: history and recalculation are done once at the end.
   batching = false;
   pendingCommits = [];
@@ -1349,6 +1340,7 @@ var SpreadsheetController = class {
       ...options.document?.table ? { table: options.document.table } : {}
     };
     this.primaryDataSourceId = options.primaryDataSourceId;
+    this.maxHistoryBytes = Math.max(0, options.maxHistoryBytes ?? DEFAULT_MAX_HISTORY_BYTES);
     this.onDocumentChange = options.onDocumentChange;
     this.onSelectionChange = options.onSelectionChange;
     this.onCellCommit = options.onCellCommit;
@@ -1363,6 +1355,7 @@ var SpreadsheetController = class {
       getFormulaCell: () => this.evaluatingCell
     });
     this.syncWithDataSource();
+    this.rederiveTypedValues();
     this.recalculateAll();
   }
   loadDocument(document) {
@@ -1374,9 +1367,80 @@ var SpreadsheetController = class {
     this.undoStack = [];
     this.redoStack = [];
     this.syncWithDataSource();
+    this.rederiveTypedValues();
     this.recalculateAll();
     this.notifyChange();
   }
+  /**
+   * Re-parses the value of every stored typed (non-formula) cell from its
+   * `raw` input, so documents saved before typed input was parsed (whose
+   * values are text such as `"120"`) compare and sort as numbers. Cells of
+   * bound columns in record rows keep their value: it belongs to the data
+   * source.
+   */
+  rederiveTypedValues() {
+    for (const row of this.document.rows) {
+      const cells = this.document.cells[row.id];
+      if (!cells) continue;
+      for (const col of this.document.columns) {
+        const cell = cells[col.id];
+        if (!cell || typeof cell.raw !== "string" || cell.raw.startsWith("=")) continue;
+        if (col.type === "bound" && col.binding && row.recordId) continue;
+        const typed = this.typedCell(cell.raw, cell.format, col, cell);
+        cell.value = typed.value;
+        if (typed.numberFormat) cell.numberFormat = typed.numberFormat;
+        else delete cell.numberFormat;
+        if (typed.format) cell.format = typed.format;
+      }
+    }
+  }
+  /**
+   * Value of typed (non-formula) input: a number, boolean, ISO date, error
+   * or text (see `parseCellInput`), its automatic number format, and the
+   * `CellFormat` to use: the automatic one (currency, percentage, date,
+   * number) when `format` is unset or `text` (the default of new columns).
+   */
+  typedCell(raw, format, col, existing) {
+    const parsed = parseCellInput(raw);
+    const fixed = this.fixedNumberFormat(col, existing);
+    const numberFormat = fixed ?? parsed.numberFormat;
+    return {
+      value: parsed.value,
+      ...numberFormat ? { numberFormat } : {},
+      ...existing?.explicitNumberFormat ? { explicitNumberFormat: true } : {},
+      format: fixed === void 0 && parsed.cellFormat && (!format || format === "text") ? parsed.cellFormat : format
+    };
+  }
+  /**
+   * The number format a cell keeps whatever is typed into it: its explicit
+   * one, else its column's. Undefined lets typed input choose one.
+   */
+  fixedNumberFormat(col, existing) {
+    if (existing?.explicitNumberFormat && existing.numberFormat !== void 0) return existing.numberFormat;
+    return col?.numberFormat && !isGeneralNumberFormat(col.numberFormat) ? col.numberFormat : void 0;
+  }
+  /** `numberFormat` / `explicitNumberFormat` fields for a formula, bound or spilled cell. */
+  fixedNumberFormatFields(col, existing) {
+    const numberFormat = this.fixedNumberFormat(col, existing);
+    if (numberFormat === void 0) return {};
+    return existing?.explicitNumberFormat ? { numberFormat, explicitNumberFormat: true } : { numberFormat };
+  }
+  /**
+   * Typed input for a bound field, coerced by the field's declared type:
+   * number, boolean and date fields get a number, boolean or ISO date when
+   * the input parses as one; string and enum fields (and unknown fields)
+   * keep the text exactly as typed.
+   */
+  boundInputValue(dataSourceId, field, raw) {
+    if (raw.startsWith("=")) return raw;
+    const type = this.binder.getDataSource(dataSourceId)?.getFields().find((f) => f.key === field)?.type;
+    if (type !== "number" && type !== "boolean" && type !== "date") return raw;
+    const parsed = parseCellInput(raw);
+    if (type === "number" && parsed.type === "number") return parsed.value;
+    if (type === "boolean" && parsed.type === "boolean") return parsed.value;
+    if (type === "date" && parsed.type === "date") return parsed.value;
+    return raw;
+  }
   registerDataSource(ds) {
     this.binder.register(ds);
     this.syncWithDataSource();
@@ -1418,10 +1482,13 @@ var SpreadsheetController = class {
       const spilled = this.spillCells.get(spillCellId(rowId, colId));
       if (spilled) return spilled;
     }
-    if (existing) return existing;
+    if (existing && !existing.explicitNumberFormat) return existing;
     const col = this.document.columns.find((c) => c.id === colId);
     const row = this.document.rows.find((r) => r.id === rowId);
-    return this.getDerivedCell(row, col);
+    const derived = this.getDerivedCell(row, col);
+    if (!existing) return derived;
+    if (derived.raw === "") return existing;
+    return { ...derived, numberFormat: existing.numberFormat, explicitNumberFormat: true };
   }
   /** Value of a cell with no stored data: bound record value, column formula, or blank. */
   getDerivedCell(row, col) {
@@ -1434,17 +1501,19 @@ var SpreadsheetController = class {
       return {
         raw: boundVal !== void 0 ? String(boundVal) : "",
         value: boundVal ?? "",
-        format: col.format
+        format: col.format,
+        ...this.fixedNumberFormatFields(col, void 0)
       };
     }
     if (col && col.type === "formula" && col.formula) {
       return {
         raw: col.formula,
         value: "",
-        format: col.format
+        format: col.format,
+        ...this.fixedNumberFormatFields(col, void 0)
       };
     }
-    return { raw: "", value: "", format: col?.format };
+    return { raw: "", value: "", format: col?.format, ...this.fixedNumberFormatFields(col, void 0) };
   }
   setCellValue(rowId, colId, raw) {
     this.recordSnapshot();
@@ -1453,21 +1522,21 @@ var SpreadsheetController = class {
     }
     const col = this.document.columns.find((c) => c.id === colId);
     const row = this.document.rows.find((r) => r.id === rowId);
+    const isFormula = raw.startsWith("=");
+    const existing = this.document.cells[rowId][colId];
+    let cell;
     if (col?.type === "bound" && col.binding && row?.recordId) {
-      this.binder.commitBoundValue(
-        col.binding.dataSource,
-        row.recordId,
-        col.binding.field,
-        raw
-      );
+      const value = this.boundInputValue(col.binding.dataSource, col.binding.field, raw);
+      this.binder.commitBoundValue(col.binding.dataSource, row.recordId, col.binding.field, value);
+      cell = { raw, value, format: col.format, ...this.fixedNumberFormatFields(col, existing) };
+    } else if (isFormula) {
+      cell = { raw, value: raw, format: col?.format, ...this.fixedNumberFormatFields(col, existing) };
+    } else {
+      cell = { raw, ...this.typedCell(raw, col?.format, col, existing) };
     }
     const cellKey = this.getCellKey(rowId, colId);
-    this.depGraph.setCellFormula(cellKey, raw.startsWith("=") ? raw : null);
-    this.document.cells[rowId][colId] = {
-      raw,
-      value: raw,
-      format: col?.format
-    };
+    this.depGraph.setCellFormula(cellKey, isFormula ? raw : null);
+    this.document.cells[rowId][colId] = cell;
     this.document.updatedAt = Date.now();
     if (this.batching) {
       this.pendingCommits.push([rowId, colId, raw]);
@@ -1666,7 +1735,13 @@ var SpreadsheetController = class {
         const rowObj = this.document.rows[row + r];
         const key = `${column.key}${row + r + 1}`.toUpperCase();
         const value = array.values[c * rows + r] ?? "";
-        const display = { raw: "", value, format: column.format, spillAnchor: anchor };
+        const display = {
+          raw: "",
+          value,
+          format: column.format,
+          spillAnchor: anchor,
+          ...this.fixedNumberFormatFields(column, this.document.cells[rowObj.id]?.[column.id])
+        };
         if (isFormulaError(value)) {
           display.error = value;
           display.errorMessage = describeFormulaError(value);
@@ -1891,6 +1966,7 @@ var SpreadsheetController = class {
       binding: config?.binding,
       formula: config?.formula,
       format: config?.format || "text",
+      ...config?.numberFormat ? { numberFormat: config.numberFormat } : {},
       readOnly: config?.readOnly
     };
     this.shiftReferences({ axis: "col", index, type: "insert" });
@@ -1983,7 +2059,7 @@ var SpreadsheetController = class {
     let maxLen = (col.title || "").length + (col.key ? col.key.length + 3 : 0);
     for (const row of this.document.rows) {
       const cell = this.getCell(row.id, col.id);
-      const valStr = cell.value != null ? String(cell.value) : "";
+      const valStr = formatCellDisplay(cell);
       if (valStr.length > maxLen) {
         maxLen = valStr.length;
       }
@@ -2007,8 +2083,7 @@ var SpreadsheetController = class {
     ) : this.document.columns;
     return rows.map(
       (row) => columns.map((col) => {
-        const cell = this.getCell(row.id, col.id);
-        return String(cell.value ?? "").replace(/\t/g, " ");
+        return formatCellDisplay(this.getCell(row.id, col.id)).replace(/\t/g, " ");
       }).join("	")
     ).join("\n");
   }
@@ -2085,7 +2160,7 @@ var SpreadsheetController = class {
    */
   exportToCsv(options = {}) {
     const matrix = this.readMatrix(options.range ?? null).map(
-      (row) => row.map((cell) => options.formulas ? cell.raw : String(cell.value ?? ""))
+      (row) => row.map((cell) => options.formulas ? cell.raw : formatCellDisplay(cell))
     );
     return serializeCsv(matrix, {
       delimiter: options.delimiter,
@@ -2126,10 +2201,11 @@ var SpreadsheetController = class {
     const cells = this.readMatrix(r).map(
       (row) => row.map((cell) => {
         const value = cell.error || cell.value;
+        const text = formatCellDisplay(cell);
         if (cell.spillAnchor && !this.spillAnchorInRange(cell.spillAnchor, r)) {
-          return { raw: value === null || value === void 0 ? "" : String(value), value };
+          return { raw: text, value, text };
         }
-        return { raw: cell.raw, value };
+        return { raw: cell.raw, value, text };
       })
     );
     return createSpreadsheetClipboardData(cells, { row: r.startRow, col: r.startCol });
@@ -2378,6 +2454,94 @@ var SpreadsheetController = class {
       this.table[key] = value;
     });
   }
+  // --- Number formats ---
+  //
+  // Cells are replaced, never mutated in place: framework bindings compare
+  // cell objects by identity to decide what to re-render.
+  /**
+   * Sets an explicit number format code (e.g. `0.00`, `"$"#,##0.00`,
+   * `m/d/yyyy`, `[Red]0;[Blue]-0`) on every cell in `range`, including blank
+   * cells, so values typed later keep it. `null` removes explicit formats: the
+   * cells go back to their column's format or the one chosen for typed input.
+   * Undoable as one step. Returns false when there is no range.
+   */
+  setCellNumberFormat(range, code) {
+    if (!range) return false;
+    const r = normalizeRange(range);
+    this.recordSnapshot();
+    const kind = code === null ? void 0 : cellFormatForNumberFormat(code);
+    for (let ri = r.startRow; ri <= r.endRow; ri++) {
+      const row = this.document.rows[ri];
+      if (!row) continue;
+      for (let ci = r.startCol; ci <= r.endCol; ci++) {
+        const col = this.document.columns[ci];
+        if (!col) continue;
+        const cells = this.document.cells[row.id] ??= {};
+        const existing = cells[col.id];
+        if (code === null) {
+          if (!existing?.explicitNumberFormat) continue;
+          if (existing.raw === "" && existing.value === "" && !existing.error) {
+            delete cells[col.id];
+          } else {
+            const { explicitNumberFormat: _explicit, ...rest } = existing;
+            cells[col.id] = this.withNumberFormat(rest, this.implicitNumberFormat(rest, col, row));
+          }
+        } else {
+          cells[col.id] = {
+            ...existing ?? { raw: "", value: "" },
+            format: kind ?? existing?.format ?? col.format,
+            numberFormat: code,
+            explicitNumberFormat: true
+          };
+        }
+        this.refreshSpilledNumberFormat(row, col);
+      }
+    }
+    this.document.updatedAt = Date.now();
+    this.notifyChange();
+    return true;
+  }
+  /**
+   * Sets the number format code of a column (`null` or `General` clears it).
+   * Its cells without an explicit format of their own use it, including
+   * values typed later; when cleared they go back to the format chosen for
+   * typed input. Undoable.
+   */
+  setColumnNumberFormat(colId, code) {
+    const col = this.getColumn(colId);
+    if (!col) return;
+    this.recordSnapshot();
+    if (code === null || isGeneralNumberFormat(code)) delete col.numberFormat;
+    else col.numberFormat = code;
+    for (const row of this.document.rows) {
+      const cells = this.document.cells[row.id];
+      const cell = cells?.[col.id];
+      if (cells && cell && !cell.explicitNumberFormat) {
+        cells[col.id] = this.withNumberFormat(cell, this.implicitNumberFormat(cell, col, row));
+      }
+      this.refreshSpilledNumberFormat(row, col);
+    }
+    this.document.updatedAt = Date.now();
+    this.notifyChange();
+  }
+  /** The column's format, or the one typed input chose (typed cells only). */
+  implicitNumberFormat(cell, col, row) {
+    const typed = cell.raw !== "" && !cell.raw.startsWith("=") && !(col.type === "bound" && col.binding && row.recordId);
+    return this.fixedNumberFormat(col, void 0) ?? (typed ? parseCellInput(cell.raw).numberFormat : void 0);
+  }
+  /** A copy of `cell` with `numberFormat` set, or removed when undefined. */
+  withNumberFormat(cell, numberFormat) {
+    const { numberFormat: _old, ...rest } = cell;
+    return numberFormat === void 0 ? rest : { ...rest, numberFormat };
+  }
+  /** Re-applies the stored cell's (or the column's) format to a spilled value shown there. */
+  refreshSpilledNumberFormat(row, col) {
+    const id = spillCellId(row.id, col.id);
+    const spilled = this.spillCells.get(id);
+    if (!spilled) return;
+    const { numberFormat: _old, explicitNumberFormat: _explicit, ...rest } = spilled;
+    this.spillCells.set(id, { ...rest, ...this.fixedNumberFormatFields(col, this.document.cells[row.id]?.[col.id]) });
+  }
   // --- Hide / unhide ---
   hideRows(indices) {
     this.setHidden("row", indices, true);
@@ -2648,6 +2812,28 @@ var SpreadsheetController = class {
     this.undoStack.push(JSON.stringify(this.document));
     if (this.undoStack.length > 50) this.undoStack.shift();
     this.redoStack = [];
+    this.trimHistory();
+  }
+  /** Drops the oldest snapshots beyond `maxHistoryBytes`, always keeping the newest. */
+  trimHistory() {
+    if (this.maxHistoryBytes <= 0 || this.undoStack.length <= 1) return;
+    let total = 0;
+    for (const s of this.undoStack) total += s.length * 2;
+    for (const s of this.redoStack) total += s.length * 2;
+    while (total > this.maxHistoryBytes && this.undoStack.length > 1) {
+      total -= this.undoStack.shift().length * 2;
+    }
+  }
+  /** Approximate bytes held by the undo/redo snapshots (UTF-16 size). */
+  getHistoryByteSize() {
+    let total = 0;
+    for (const s of this.undoStack) total += s.length * 2;
+    for (const s of this.redoStack) total += s.length * 2;
+    return total;
+  }
+  /** Number of undo / redo snapshots currently held. */
+  getHistoryDepth() {
+    return { undo: this.undoStack.length, redo: this.redoStack.length };
   }
   undo() {
     if (this.undoStack.length === 0) return;
@@ -2689,6 +2875,17 @@ function stepInOrder(order, from, delta) {
 }
 
 // src/spreadsheet/menu.ts
+function runSpreadsheetMenuItem(item, ask) {
+  if (!item.input) {
+    item.run();
+    return true;
+  }
+  const prompt = ask ?? ((label, value) => typeof window !== "undefined" && window.prompt ? window.prompt(label, value) : null);
+  const text = prompt(item.input.label, item.input.defaultValue ?? "");
+  if (text === null || text === void 0) return false;
+  item.run(text);
+  return true;
+}
 function clampMenuPosition(point, size, viewport, margin = 4) {
   const place = (start, length, limit) => {
     if (start + length <= limit - margin) return Math.max(margin, start);
@@ -2711,7 +2908,8 @@ function getSpreadsheetMenuItems(controller, cell) {
   if (!column || !row) return [];
   const selection = controller.selectedRange && rangeContains(controller.selectedRange, cell.row, cell.col) ? normalizeRange(controller.selectedRange) : { startRow: cell.row, startCol: cell.col, endRow: cell.row, endCol: cell.col };
   const colName = indexToColName(cell.col);
-  const value = controller.getCell(row.id, column.id).value;
+  const cellData = controller.getCell(row.id, column.id);
+  const value = cellData.value;
   const table = doc.table ?? {};
   const filter = controller.getFilterState();
   const grouping = table.grouping;
@@ -2733,7 +2931,7 @@ function getSpreadsheetMenuItems(controller, cell) {
     },
     {
       id: "filter-equals",
-      label: `Show only rows where ${colName} = ${quote(value)}`,
+      label: `Show only rows where ${colName} = ${quote(formatCellDisplay(cellData))}`,
       separatorBefore: true,
       run: () => controller.addFilterRule({ colId: column.id, operator: "equals", value: String(value ?? "") })
     },
@@ -2822,6 +3020,31 @@ function getSpreadsheetMenuItems(controller, cell) {
       }
     }
   ];
+  const currentFormat = cellData.numberFormat;
+  const presetMatch = NUMBER_FORMAT_PRESETS.find(
+    (p) => p.id === "general" ? isGeneralNumberFormat(currentFormat) : p.code === currentFormat
+  );
+  NUMBER_FORMAT_PRESETS.forEach((preset, i) => {
+    items.push({
+      id: `number-format-${preset.id}`,
+      label: `Format cells: ${preset.label}`,
+      separatorBefore: i === 0,
+      checked: presetMatch === preset,
+      run: () => {
+        controller.setCellNumberFormat(selection, preset.code);
+      }
+    });
+  });
+  items.push({
+    id: "number-format-custom",
+    label: "Format cells: Custom\u2026",
+    checked: !presetMatch,
+    input: { label: "Number format code, e.g. #,##0.00;[Red](#,##0.00)", defaultValue: currentFormat ?? "General" },
+    run: (code) => {
+      if (code === void 0) return;
+      controller.setCellNumberFormat(selection, code.trim() === "" ? null : code);
+    }
+  });
   if (grouping) {
     items.push(
       {
@@ -2880,6 +3103,8 @@ var SPREADSHEET_TABLE_ACTIONS = [
   "toggleGroupCollapsed",
   "getGroups",
   "transposeRange",
+  "setCellNumberFormat",
+  "setColumnNumberFormat",
   "exportToCsv",
   "importFromCsv",
   "copyToClipboardData",
@@ -2948,6 +3173,13 @@ export {
   getFormulaCaretContext,
   getFormulaHints,
   applyFormulaSuggestion,
+  NUMBER_FORMAT_PRESETS,
+  numberFormatForCellFormat,
+  cellFormatForNumberFormat,
+  isGeneralNumberFormat,
+  formatCellForDisplay,
+  formatCellDisplay,
+  formatValueWithCode,
   DataSourceBinder,
   normalizeRange,
   rangeContains,
@@ -2963,11 +3195,6 @@ export {
   fillSeries,
   computeFillTarget,
   getFillDirection,
-  parseCsv,
-  escapeCsvField,
-  serializeCsv,
-  parseTsv,
-  serializeTsv,
   SPREADSHEET_CLIPBOARD_MIME,
   serializeHtmlTable,
   parseHtmlTable,
@@ -2982,6 +3209,7 @@ export {
   computeRowGroups,
   buildSpreadsheetView,
   SpreadsheetController,
+  runSpreadsheetMenuItem,
   clampMenuPosition,
   getSpreadsheetMenuItems,
   SPREADSHEET_TABLE_ACTIONS,
@@ -2992,4 +3220,4 @@ export {
   registerSpreadsheetImportAdapters,
   importFileIntoSpreadsheet
 };
-//# sourceMappingURL=chunk-RU52I7QO.js.map
+//# sourceMappingURL=chunk-U5KWZU4X.js.map