@freighttech/ui 0.13.18

package/dist/backend/dynamic-table/utils/exportTable.js

@@ -0,0 +1,82 @@
+function cellToString(value) {
+  if (value === null || value === void 0) return "";
+  return String(value);
+}
+function extractExportRows(store, cols, selectedRowIds, selectionColumnName) {
+  const headers = cols.map((c) => c.title ?? c.data);
+  const rows = [];
+  const rowCount = store.getRowCount();
+  const exportSelectionOnly = selectedRowIds.size > 0;
+  for (let r = 0; r < rowCount; r++) {
+    const rowData = store.getRowData(r);
+    if (!rowData) continue;
+    if (exportSelectionOnly) {
+      const id = String(rowData[selectionColumnName] ?? "");
+      if (!id || !selectedRowIds.has(id)) continue;
+    }
+    rows.push(
+      cols.map((col, c) => {
+        const raw = store.getCellValue(r, c);
+        if (col.exportValue) return cellToString(col.exportValue(raw, rowData));
+        return cellToString(raw);
+      })
+    );
+  }
+  return { headers, rows };
+}
+function extractExportRowsFromData(data, cols) {
+  const headers = cols.map((c) => c.title ?? c.data);
+  const rows = data.map(
+    (row) => cols.map((col) => {
+      const raw = row?.[col.data];
+      if (col.exportValue) return cellToString(col.exportValue(raw, row));
+      if (raw !== null && typeof raw === "object") return "";
+      return cellToString(raw);
+    })
+  );
+  return { headers, rows };
+}
+function escapeCsvField(field) {
+  if (/[",\r\n]/.test(field)) {
+    return `"${field.replace(/"/g, '""')}"`;
+  }
+  return field;
+}
+function toCsv({ headers, rows }) {
+  const lines = [headers, ...rows].map((row) => row.map(escapeCsvField).join(","));
+  return "\uFEFF" + lines.join("\r\n");
+}
+function toXlsxBlob(table, XLSX) {
+  const aoa = [table.headers, ...table.rows];
+  const sheet = XLSX.utils.aoa_to_sheet(aoa);
+  const book = XLSX.utils.book_new();
+  XLSX.utils.book_append_sheet(book, sheet, "Export");
+  const out = XLSX.write(book, { type: "array", bookType: "xlsx" });
+  return new Blob([out], {
+    type: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+  });
+}
+function slugifyFileName(name) {
+  const slug = name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return slug || "export";
+}
+function downloadBlob(blob, filename) {
+  if (typeof document === "undefined") return;
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = filename;
+  document.body.appendChild(a);
+  a.click();
+  a.remove();
+  setTimeout(() => URL.revokeObjectURL(url), 0);
+}
+export {
+  downloadBlob,
+  extractExportRows,
+  extractExportRowsFromData,
+  slugifyFileName,
+  toCsv,
+  toXlsxBlob
+};
+//# sourceMappingURL=exportTable.js.map

package/dist/backend/dynamic-table/utils/exportTable.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/backend/dynamic-table/utils/exportTable.ts"],
+  "sourcesContent": ["import type { ColumnDef } from '../types/index';\nimport type { CellStore } from '../store/index';\n\nexport type ExportFormat = 'csv' | 'xlsx';\n\nexport interface ExtractedTable {\n  /** Column header labels, in view order. */\n  headers: string[];\n  /** Body rows; each is an array of cell strings aligned to `headers`. */\n  rows: string[][];\n}\n\nfunction cellToString(value: unknown): string {\n  if (value === null || value === undefined) return '';\n  return String(value);\n}\n\n/**\n * Pull the visible columns for the chosen rows out of the cell store \u2014 the same\n * extraction the Copy button uses (`store.getCellValue` over `cols` in view\n * order, which projects `rowData[col.data]`, the one value source the grid also\n * renders from). When `selectedRowIds` is non-empty, only those rows are\n * exported; otherwise every loaded (current-page) row is included.\n *\n * Columns may declare `exportValue(value, row)` to override the stringified raw\n * cell value (e.g. relation columns that store JSON in the cell).\n */\nexport function extractExportRows(\n  store: CellStore,\n  cols: ColumnDef[],\n  selectedRowIds: Set<string>,\n  selectionColumnName: string,\n): ExtractedTable {\n  const headers = cols.map((c) => c.title ?? c.data);\n  const rows: string[][] = [];\n  const rowCount = store.getRowCount();\n  const exportSelectionOnly = selectedRowIds.size > 0;\n\n  for (let r = 0; r < rowCount; r++) {\n    const rowData = store.getRowData(r);\n    if (!rowData) continue;\n    if (exportSelectionOnly) {\n      const id = String(rowData[selectionColumnName] ?? '');\n      if (!id || !selectedRowIds.has(id)) continue;\n    }\n    rows.push(\n      cols.map((col, c) => {\n        const raw = store.getCellValue(r, c);\n        if (col.exportValue) return cellToString(col.exportValue(raw, rowData));\n        return cellToString(raw);\n      }),\n    );\n  }\n\n  return { headers, rows };\n}\n\n/**\n * Build an export table directly from plain row objects (not the cell store).\n * Used for the whole-table export, where rows are re-fetched from the server\n * across all pages and every column is included regardless of perspective\n * visibility. Reads `row[col.data]`, applying `col.exportValue` when present.\n */\nexport function extractExportRowsFromData(\n  data: any[],\n  cols: ColumnDef[],\n): ExtractedTable {\n  const headers = cols.map((c) => c.title ?? c.data);\n  const rows = data.map((row) =>\n    cols.map((col) => {\n      const raw = row?.[col.data];\n      if (col.exportValue) return cellToString(col.exportValue(raw, row));\n      // Objects/arrays have no useful default string form \u2014 leave blank rather\n      // than emit \"[object Object]\". Columns that store them must use exportValue.\n      if (raw !== null && typeof raw === 'object') return '';\n      return cellToString(raw);\n    }),\n  );\n  return { headers, rows };\n}\n\nfunction escapeCsvField(field: string): string {\n  // RFC 4180: quote fields containing comma, quote, CR or LF; double interior quotes.\n  if (/[\",\\r\\n]/.test(field)) {\n    return `\"${field.replace(/\"/g, '\"\"')}\"`;\n  }\n  return field;\n}\n\n/**\n * Serialize an extracted table to a CSV string. Prepends a UTF-8 BOM so Excel\n * opens it with the correct encoding (Polish characters survive).\n */\nexport function toCsv({ headers, rows }: ExtractedTable): string {\n  const lines = [headers, ...rows].map((row) => row.map(escapeCsvField).join(','));\n  return '\uFEFF' + lines.join('\\r\\n');\n}\n\n/**\n * Serialize an extracted table to an .xlsx Blob via SheetJS. The `xlsx`\n * dependency is imported lazily by the caller and passed in, so CSV-only paths\n * never load it.\n */\nexport function toXlsxBlob(\n  table: ExtractedTable,\n  XLSX: typeof import('xlsx'),\n): Blob {\n  const aoa = [table.headers, ...table.rows];\n  const sheet = XLSX.utils.aoa_to_sheet(aoa);\n  const book = XLSX.utils.book_new();\n  XLSX.utils.book_append_sheet(book, sheet, 'Export');\n  const out = XLSX.write(book, { type: 'array', bookType: 'xlsx' }) as ArrayBuffer;\n  return new Blob([out], {\n    type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',\n  });\n}\n\n/** Slugify a table/file name into a safe file-name stem. */\nexport function slugifyFileName(name: string): string {\n  const slug = name\n    .trim()\n    .toLowerCase()\n    .replace(/[^a-z0-9]+/g, '-')\n    .replace(/^-+|-+$/g, '');\n  return slug || 'export';\n}\n\n/** Trigger a browser download of `blob` as `filename` (no-op when no document). */\nexport function downloadBlob(blob: Blob, filename: string): void {\n  if (typeof document === 'undefined') return;\n  const url = URL.createObjectURL(blob);\n  const a = document.createElement('a');\n  a.href = url;\n  a.download = filename;\n  document.body.appendChild(a);\n  a.click();\n  a.remove();\n  // Revoke on the next tick so the click has consumed the URL.\n  setTimeout(() => URL.revokeObjectURL(url), 0);\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/backend/dynamic-table/utils/fillGeometry.js

@@ -0,0 +1,92 @@
+import { invertFillMode } from "./fillPatterns.js";
+function rectSize(bounds) {
+  return (bounds.endRow - bounds.startRow + 1) * (bounds.endCol - bounds.startCol + 1);
+}
+function isCellInRect(row, col, bounds) {
+  return row >= bounds.startRow && row <= bounds.endRow && col >= bounds.startCol && col <= bounds.endCol;
+}
+function overshoot(value, lo, hi) {
+  if (value < lo) return lo - value;
+  if (value > hi) return value - hi;
+  return 0;
+}
+function computeFillPreview(source, pointer, opts) {
+  const mode = opts.modifier ? invertFillMode(opts.defaultMode) : opts.defaultMode;
+  const dRow = overshoot(pointer.row, source.startRow, source.endRow);
+  const dCol = overshoot(pointer.col, source.startCol, source.endCol);
+  if (dRow > 0 || dCol > 0) {
+    const axis2 = dRow >= dCol ? "vertical" : "horizontal";
+    const backwards = axis2 === "vertical" ? pointer.row < source.startRow : pointer.col < source.startCol;
+    const bounds = axis2 === "vertical" ? {
+      startRow: Math.min(source.startRow, pointer.row),
+      endRow: Math.max(source.endRow, pointer.row),
+      startCol: source.startCol,
+      endCol: source.endCol
+    } : {
+      startRow: source.startRow,
+      endRow: source.endRow,
+      startCol: Math.min(source.startCol, pointer.col),
+      endCol: Math.max(source.endCol, pointer.col)
+    };
+    return { source, bounds, axis: axis2, backwards, clearing: false, cleared: null, mode };
+  }
+  const shrinkRows = source.endRow - pointer.row;
+  const shrinkCols = source.endCol - pointer.col;
+  const axis = shrinkRows >= shrinkCols ? "vertical" : "horizontal";
+  const cleared = axis === "vertical" ? { ...source, startRow: pointer.row + 1 } : { ...source, startCol: pointer.col + 1 };
+  const clearing = axis === "vertical" ? cleared.startRow <= cleared.endRow : cleared.startCol <= cleared.endCol;
+  return {
+    source,
+    bounds: source,
+    axis,
+    backwards: false,
+    clearing,
+    cleared: clearing ? cleared : null,
+    mode
+  };
+}
+function buildFillLines(preview) {
+  const { source, bounds, axis, backwards } = preview;
+  const lines = [];
+  if (axis === "vertical") {
+    for (let col = source.startCol; col <= source.endCol; col++) {
+      const seedCells = [];
+      for (let row = source.startRow; row <= source.endRow; row++) seedCells.push({ row, col });
+      const targets = [];
+      if (backwards) {
+        for (let row = source.startRow - 1; row >= bounds.startRow; row--) targets.push({ row, col });
+      } else {
+        for (let row = source.endRow + 1; row <= bounds.endRow; row++) targets.push({ row, col });
+      }
+      lines.push({ seedCells, targets, seedCol: col });
+    }
+    return lines;
+  }
+  for (let row = source.startRow; row <= source.endRow; row++) {
+    const seedCells = [];
+    for (let col = source.startCol; col <= source.endCol; col++) seedCells.push({ row, col });
+    const targets = [];
+    if (backwards) {
+      for (let col = source.startCol - 1; col >= bounds.startCol; col--) targets.push({ row, col });
+    } else {
+      for (let col = source.endCol + 1; col <= bounds.endCol; col++) targets.push({ row, col });
+    }
+    lines.push({ seedCells, targets, seedCol: source.startCol });
+  }
+  return lines;
+}
+function cellsInRect(bounds) {
+  const cells = [];
+  for (let row = bounds.startRow; row <= bounds.endRow; row++) {
+    for (let col = bounds.startCol; col <= bounds.endCol; col++) cells.push({ row, col });
+  }
+  return cells;
+}
+export {
+  buildFillLines,
+  cellsInRect,
+  computeFillPreview,
+  isCellInRect,
+  rectSize
+};
+//# sourceMappingURL=fillGeometry.js.map

package/dist/backend/dynamic-table/utils/fillGeometry.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/backend/dynamic-table/utils/fillGeometry.ts"],
+  "sourcesContent": ["// utils/fillGeometry.ts\n//\n// Where a fill drag is pointing. PURE: no DOM, no store, no React.\n//\n// This is the single most important testability move in the rectangle-fill\n// work: axis lock and back-drag are the two rules users notice, and neither can\n// be proven inside a `mousemove` callback. Both live here instead, so a jest\n// test can assert \"a diagonal drag picks the dominant axis\" without a browser.\n//\n// Excel's fill is SINGLE-AXIS. The axis is chosen by the larger overshoot from\n// the source block's edge; the other axis is clamped to the source's extent.\n// Dragging back INSIDE the source clears the part you dragged back over.\n\nimport type { FillAxis, FillPreview, SelectionBounds } from '../types/index';\nimport type { FillMode } from './fillPatterns';\nimport { invertFillMode } from './fillPatterns';\n\nexport interface FillPointer {\n  row: number;\n  col: number;\n}\n\nexport interface ComputeFillPreviewOptions {\n  /** `Ctrl`/`Alt` held. Inverts the pattern's default copy <-> series. */\n  modifier: boolean;\n  /** The mode the detected pattern would use with no modifier held. */\n  defaultMode: FillMode;\n}\n\n/** Inclusive cell count of a rectangle. */\nexport function rectSize(bounds: SelectionBounds): number {\n  return (\n    (bounds.endRow - bounds.startRow + 1) * (bounds.endCol - bounds.startCol + 1)\n  );\n}\n\nexport function isCellInRect(row: number, col: number, bounds: SelectionBounds): boolean {\n  return (\n    row >= bounds.startRow &&\n    row <= bounds.endRow &&\n    col >= bounds.startCol &&\n    col <= bounds.endCol\n  );\n}\n\n/** How far outside `[lo, hi]` a coordinate sits. 0 when inside. */\nfunction overshoot(value: number, lo: number, hi: number): number {\n  if (value < lo) return lo - value;\n  if (value > hi) return value - hi;\n  return 0;\n}\n\n/**\n * The whole fill gesture, as data.\n *\n * Extending (pointer outside the source):\n *   axis      = the larger overshoot wins; a tie goes VERTICAL, because a fill\n *               drag is overwhelmingly a \"drag down\" and a 1px sideways wobble\n *               must not flip it;\n *   backwards = the pointer is above / left of the source;\n *   bounds    = source stretched along `axis` to the pointer, the other axis\n *               clamped to the source's own extent.\n *\n * Clearing (pointer inside the source): Excel empties everything past the\n * pointer along the shrink axis. A 1-row source has `shrinkRows === 0` and falls\n * to the horizontal branch on its own \u2014 there is no special case for it.\n */\nexport function computeFillPreview(\n  source: SelectionBounds,\n  pointer: FillPointer,\n  opts: ComputeFillPreviewOptions,\n): FillPreview {\n  const mode = opts.modifier ? invertFillMode(opts.defaultMode) : opts.defaultMode;\n\n  const dRow = overshoot(pointer.row, source.startRow, source.endRow);\n  const dCol = overshoot(pointer.col, source.startCol, source.endCol);\n\n  if (dRow > 0 || dCol > 0) {\n    const axis: FillAxis = dRow >= dCol ? 'vertical' : 'horizontal';\n    const backwards =\n      axis === 'vertical' ? pointer.row < source.startRow : pointer.col < source.startCol;\n    const bounds: SelectionBounds =\n      axis === 'vertical'\n        ? {\n            startRow: Math.min(source.startRow, pointer.row),\n            endRow: Math.max(source.endRow, pointer.row),\n            startCol: source.startCol,\n            endCol: source.endCol,\n          }\n        : {\n            startRow: source.startRow,\n            endRow: source.endRow,\n            startCol: Math.min(source.startCol, pointer.col),\n            endCol: Math.max(source.endCol, pointer.col),\n          };\n    return { source, bounds, axis, backwards, clearing: false, cleared: null, mode };\n  }\n\n  // Pointer is inside the source \u2192 back-drag. Everything BEYOND the pointer\n  // along the dominant shrink axis is about to be emptied.\n  const shrinkRows = source.endRow - pointer.row;\n  const shrinkCols = source.endCol - pointer.col;\n  const axis: FillAxis = shrinkRows >= shrinkCols ? 'vertical' : 'horizontal';\n  const cleared: SelectionBounds =\n    axis === 'vertical'\n      ? { ...source, startRow: pointer.row + 1 }\n      : { ...source, startCol: pointer.col + 1 };\n  const clearing =\n    axis === 'vertical' ? cleared.startRow <= cleared.endRow : cleared.startCol <= cleared.endCol;\n\n  return {\n    source,\n    bounds: source,\n    axis,\n    backwards: false,\n    clearing,\n    cleared: clearing ? cleared : null,\n    mode,\n  };\n}\n\n/**\n * The cells a fill will WRITE, grouped into the independent series lines Excel\n * fills them with.\n *\n * Vertical fill: one line per source COLUMN, seeded by that column's rows in\n * row order. Horizontal fill: one line per source ROW, seeded by that row's\n * columns in column order. That is the rule that makes a multi-column drag\n * continue each column's own series instead of smearing one series sideways.\n *\n * Every line's `targets` are ordered ADJACENT-TO-SOURCE FIRST, which is exactly\n * the order `generateFill` returns values in \u2014 so the caller zips the two\n * without ever reversing an array.\n */\nexport interface FillLine {\n  /** Cells of the SOURCE block for this line, in fill order. */\n  seedCells: Array<{ row: number; col: number }>;\n  /** Cells to write, nearest the source first. */\n  targets: Array<{ row: number; col: number }>;\n  /** The column whose `type` / `source` / `fillSeries` governs this line. */\n  seedCol: number;\n}\n\nexport function buildFillLines(preview: FillPreview): FillLine[] {\n  const { source, bounds, axis, backwards } = preview;\n  const lines: FillLine[] = [];\n\n  if (axis === 'vertical') {\n    for (let col = source.startCol; col <= source.endCol; col++) {\n      const seedCells: Array<{ row: number; col: number }> = [];\n      for (let row = source.startRow; row <= source.endRow; row++) seedCells.push({ row, col });\n      const targets: Array<{ row: number; col: number }> = [];\n      if (backwards) {\n        for (let row = source.startRow - 1; row >= bounds.startRow; row--) targets.push({ row, col });\n      } else {\n        for (let row = source.endRow + 1; row <= bounds.endRow; row++) targets.push({ row, col });\n      }\n      lines.push({ seedCells, targets, seedCol: col });\n    }\n    return lines;\n  }\n\n  for (let row = source.startRow; row <= source.endRow; row++) {\n    const seedCells: Array<{ row: number; col: number }> = [];\n    for (let col = source.startCol; col <= source.endCol; col++) seedCells.push({ row, col });\n    const targets: Array<{ row: number; col: number }> = [];\n    if (backwards) {\n      for (let col = source.startCol - 1; col >= bounds.startCol; col--) targets.push({ row, col });\n    } else {\n      for (let col = source.endCol + 1; col <= bounds.endCol; col++) targets.push({ row, col });\n    }\n    // Horizontal fill crosses columns, so no single column governs the line.\n    // The SEED's own column supplies the pattern rules; the TARGET column\n    // decides whether the value is acceptable (see coerceCellValue).\n    lines.push({ seedCells, targets, seedCol: source.startCol });\n  }\n  return lines;\n}\n\n/** Every cell of a rectangle, row-major. Shared by the preview repaint and the commit. */\nexport function cellsInRect(bounds: SelectionBounds): Array<{ row: number; col: number }> {\n  const cells: Array<{ row: number; col: number }> = [];\n  for (let row = bounds.startRow; row <= bounds.endRow; row++) {\n    for (let col = bounds.startCol; col <= bounds.endCol; col++) cells.push({ row, col });\n  }\n  return cells;\n}\n"],
+  "mappings": "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",
+  "names": ["axis"]
+}

package/dist/backend/dynamic-table/utils/fillPatterns.js

@@ -0,0 +1,241 @@
+function isBlank(value) {
+  return value === null || value === void 0 || typeof value === "string" && value.trim() === "";
+}
+function cyclic(values, i) {
+  const k = values.length;
+  return values[(i % k + k) % k];
+}
+function copyPattern(seed) {
+  const values = seed.values.length > 0 ? seed.values : [void 0];
+  return { kind: "copy", defaultMode: "copy", at: (i) => cyclic(values, i) };
+}
+function constantDelta(nums, epsilon = 1e-9) {
+  if (nums.length < 2) return null;
+  const step = nums[1] - nums[0];
+  for (let i = 2; i < nums.length; i++) {
+    if (Math.abs(nums[i] - nums[i - 1] - step) > epsilon) return null;
+  }
+  return step;
+}
+function parseNumeric(value) {
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (typeof value !== "string") return null;
+  const raw = value.trim();
+  if (raw === "") return null;
+  if (/^[+-]?0\d/.test(raw)) return null;
+  const normalised = raw.replace(/[\s\u00a0\u202f]/g, "").replace(",", ".");
+  if (!/^[+-]?(\d+(\.\d*)?|\.\d+)$/.test(normalised)) return null;
+  const n = Number(normalised);
+  return Number.isFinite(n) ? n : null;
+}
+function decimalsOf(value) {
+  const text = typeof value === "number" ? String(value) : String(value ?? "");
+  const match = /[.,](\d+)$/.exec(text.trim());
+  return match ? match[1].length : 0;
+}
+function roundTo(value, decimals) {
+  if (decimals <= 0) return Math.round(value);
+  const factor = 10 ** decimals;
+  return Math.round(value * factor) / factor;
+}
+const MS_PER_DAY = 864e5;
+function parseYmd(value) {
+  if (value instanceof Date) {
+    if (Number.isNaN(value.getTime())) return null;
+    return { y: value.getFullYear(), m: value.getMonth() + 1, d: value.getDate() };
+  }
+  if (typeof value !== "string") return null;
+  const raw = value.trim();
+  if (raw === "") return null;
+  const iso = /^(\d{4})-(\d{2})-(\d{2})/.exec(raw);
+  if (iso) return { y: Number(iso[1]), m: Number(iso[2]), d: Number(iso[3]) };
+  const parsed = new Date(raw);
+  if (Number.isNaN(parsed.getTime())) return null;
+  return { y: parsed.getFullYear(), m: parsed.getMonth() + 1, d: parsed.getDate() };
+}
+function formatYmd({ y, m, d }) {
+  return `${String(y).padStart(4, "0")}-${String(m).padStart(2, "0")}-${String(d).padStart(2, "0")}`;
+}
+function ymdToDays({ y, m, d }) {
+  return Math.round(Date.UTC(y, m - 1, d) / MS_PER_DAY);
+}
+function daysToYmd(days) {
+  const date = new Date(days * MS_PER_DAY);
+  return { y: date.getUTCFullYear(), m: date.getUTCMonth() + 1, d: date.getUTCDate() };
+}
+function dayOfWeek(days) {
+  return (days % 7 + 7 + 4) % 7;
+}
+function isWeekday(days) {
+  const dow = dayOfWeek(days);
+  return dow >= 1 && dow <= 5;
+}
+function weekdayIndex(days) {
+  const dow = dayOfWeek(days);
+  const week = Math.floor((days + 3) / 7);
+  return week * 5 + (dow - 1);
+}
+function weekdayIndexToDays(index) {
+  const week = Math.floor(index / 5);
+  const rest = (index % 5 + 5) % 5;
+  return week * 7 - 3 + rest;
+}
+function monthIndex({ y, m }) {
+  return y * 12 + (m - 1);
+}
+function daysInMonth(y, m) {
+  return new Date(Date.UTC(y, m, 0)).getUTCDate();
+}
+function fromMonthIndex(index, day) {
+  const y = Math.floor(index / 12);
+  const m = (index % 12 + 12) % 12 + 1;
+  return { y, m, d: Math.min(day, daysInMonth(y, m)) };
+}
+const weekdayStep = (seed) => {
+  if (seed.column.type !== "date") return null;
+  if (seed.values.length < 2) return null;
+  const days = [];
+  for (const value of seed.values) {
+    const ymd = parseYmd(value);
+    if (!ymd) return null;
+    const d = ymdToDays(ymd);
+    if (!isWeekday(d)) return null;
+    days.push(d);
+  }
+  const indices = days.map(weekdayIndex);
+  const step = constantDelta(indices);
+  if (step === null || Math.abs(step) !== 1) return null;
+  const base = indices[0];
+  return {
+    kind: "weekday",
+    defaultMode: "series",
+    at: (i) => formatYmd(daysToYmd(weekdayIndexToDays(base + step * i)))
+  };
+};
+const dateStep = (seed) => {
+  if (seed.column.type !== "date") return null;
+  const parsed = [];
+  for (const value of seed.values) {
+    const ymd = parseYmd(value);
+    if (!ymd) return null;
+    parsed.push(ymd);
+  }
+  if (parsed.length === 0) return null;
+  if (parsed.length === 1) {
+    const base = ymdToDays(parsed[0]);
+    return { kind: "date", defaultMode: "series", at: (i) => formatYmd(daysToYmd(base + i)) };
+  }
+  const sameDayOfMonth = parsed.every((p) => p.d === parsed[0].d);
+  if (sameDayOfMonth) {
+    const months = parsed.map(monthIndex);
+    const monthStep = constantDelta(months);
+    if (monthStep !== null && monthStep !== 0) {
+      const base = months[0];
+      const day = parsed[0].d;
+      return {
+        kind: "date",
+        defaultMode: "series",
+        at: (i) => formatYmd(fromMonthIndex(base + monthStep * i, day))
+      };
+    }
+  }
+  const days = parsed.map(ymdToDays);
+  const dayStep = constantDelta(days);
+  if (dayStep !== null && dayStep !== 0) {
+    const base = days[0];
+    return { kind: "date", defaultMode: "series", at: (i) => formatYmd(daysToYmd(base + dayStep * i)) };
+  }
+  return null;
+};
+const numericStep = (seed) => {
+  const nums = [];
+  for (const value of seed.values) {
+    const n = parseNumeric(value);
+    if (n === null) return null;
+    nums.push(n);
+  }
+  if (nums.length === 0) return null;
+  const decimals = seed.values.reduce((max, v) => Math.max(max, decimalsOf(v)), 0);
+  if (nums.length === 1) {
+    const base2 = nums[0];
+    return { kind: "numeric", defaultMode: "copy", at: (i) => roundTo(base2 + i, decimals) };
+  }
+  const step = constantDelta(nums, 10 ** -(decimals + 6));
+  if (step === null) return null;
+  const base = nums[0];
+  return { kind: "numeric", defaultMode: "series", at: (i) => roundTo(base + step * i, decimals) };
+};
+const SUFFIX_RE = /^(.*?)(\d+)(\D*)$/;
+const suffixStep = (seed) => {
+  let prefix = null;
+  let tail = null;
+  let width = 0;
+  const nums = [];
+  for (const value of seed.values) {
+    if (typeof value !== "string") return null;
+    const match = SUFFIX_RE.exec(value);
+    if (!match) return null;
+    const [, p, digits, t] = match;
+    if (prefix === null) {
+      prefix = p;
+      tail = t;
+      width = digits.length;
+    } else if (p !== prefix || t !== tail) {
+      return null;
+    }
+    nums.push(Number(digits));
+  }
+  if (prefix === null || nums.length === 0) return null;
+  const step = nums.length === 1 ? 1 : constantDelta(nums);
+  if (step === null) return null;
+  const base = nums[0];
+  const head = prefix;
+  const foot = tail ?? "";
+  return {
+    kind: "suffix",
+    defaultMode: "series",
+    at: (i) => {
+      const n = base + step * i;
+      const sign = n < 0 ? "-" : "";
+      return `${head}${sign}${String(Math.abs(n)).padStart(width, "0")}${foot}`;
+    }
+  };
+};
+const fillDetectors = [weekdayStep, dateStep, numericStep, suffixStep];
+function detectFillPattern(seed) {
+  const column = seed.column;
+  if (column.fillSeries === "copy") return copyPattern(seed);
+  if (column.type === "dropdown" || column.type === "multiselect" || column.type === "boolean") {
+    return copyPattern(seed);
+  }
+  if (seed.values.length === 0 || seed.values.every(isBlank)) return copyPattern(seed);
+  for (const detect of fillDetectors) {
+    const pattern = detect(seed);
+    if (pattern) return pattern;
+  }
+  return copyPattern(seed);
+}
+function invertFillMode(mode) {
+  return mode === "series" ? "copy" : "series";
+}
+function generateFill(seed, count, direction, mode) {
+  if (count <= 0) return [];
+  const pattern = mode === "copy" ? copyPattern(seed) : detectFillPattern(seed);
+  const k = Math.max(seed.values.length, 1);
+  const out = [];
+  for (let n = 0; n < count; n++) {
+    out.push(pattern.at(direction === 1 ? k + n : -1 - n));
+  }
+  return out;
+}
+export {
+  dateStep,
+  detectFillPattern,
+  fillDetectors,
+  generateFill,
+  invertFillMode,
+  numericStep,
+  suffixStep,
+  weekdayStep
+};
+//# sourceMappingURL=fillPatterns.js.map

package/dist/backend/dynamic-table/utils/fillPatterns.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/backend/dynamic-table/utils/fillPatterns.ts"],
+  "sourcesContent": ["// utils/fillPatterns.ts\n//\n// Fill-series pattern detection and extrapolation. PURE: no store, no React,\n// no DOM. Where Excel has an established behaviour, that behaviour is the\n// specification \u2014 nothing here is invented UX.\n//\n// The chain is ordered and `copy` is terminal, so today's shipped behaviour\n// (drag a value down, get that value repeated) is the floor: a seed that\n// matches no series still fills, it just fills by copying.\n//\n//   1. weekdayStep  Mon-Fri dates whose delta is a whole number of WEEKDAYS\n//   2. dateStep     day / month / year steps on a `type: 'date'` column\n//   3. numericStep  finite numbers with an exact constant delta\n//   4. suffixStep   `REF-001` -> `REF-002`, zero-padding preserved\n//   5. copy         cyclic tiling of the seed \u2014 always matches\n//\n// `at(i)` takes a SIGNED index: `at(0)..at(k-1)` reproduce the seed, `at(k)`\n// and up extend forwards, `at(-1)` and down extend backwards. That single\n// signed accessor is why up/left fill needs no separate code path.\n\nimport type { ColumnDef } from '../types/index';\n\n// ============================================\n// TYPES\n// ============================================\n// These belong in `types/index.ts` alongside `FillPreview` once Wave 3 rewrites\n// it; they live here so this module ships without touching the shared type file.\n\n/** Continue the series, or tile the seed. `Ctrl`/`Alt` inverts the default. */\nexport type FillMode = 'series' | 'copy';\n\n/** One line of the fill source: a source column (vertical) or row (horizontal). */\nexport interface FillSeed {\n  /** Seed values in fill order: top-to-bottom vertically, left-to-right horizontally. */\n  values: unknown[];\n  /** The column the seed came from \u2014 supplies `type`, `source` and `fillSeries`. */\n  column: ColumnDef;\n}\n\nexport interface FillPattern {\n  kind: 'numeric' | 'date' | 'weekday' | 'suffix' | 'copy';\n  /** Mode used when no modifier is held. Excel differs per pattern. */\n  defaultMode: FillMode;\n  /** Value at signed seed index `i`. */\n  at(i: number): unknown;\n}\n\nexport type FillDetector = (seed: FillSeed) => FillPattern | null;\n\n// ============================================\n// SHARED HELPERS\n// ============================================\n\nfunction isBlank(value: unknown): boolean {\n  return value === null || value === undefined || (typeof value === 'string' && value.trim() === '');\n}\n\n/** Cyclic tiling, correct for negative indices: `at(-1)` is the LAST seed value. */\nfunction cyclic<T>(values: readonly T[], i: number): T {\n  const k = values.length;\n  return values[((i % k) + k) % k];\n}\n\nfunction copyPattern(seed: FillSeed): FillPattern {\n  const values = seed.values.length > 0 ? seed.values : [undefined];\n  return { kind: 'copy', defaultMode: 'copy', at: (i) => cyclic(values, i) };\n}\n\n/** Every delta between consecutive entries is the same value. */\nfunction constantDelta(nums: number[], epsilon = 1e-9): number | null {\n  if (nums.length < 2) return null;\n  const step = nums[1] - nums[0];\n  for (let i = 2; i < nums.length; i++) {\n    if (Math.abs(nums[i] - nums[i - 1] - step) > epsilon) return null;\n  }\n  return step;\n}\n\n// --- numbers -------------------------------------------------------------\n\n/**\n * Parse a stored cell value as a number. Accepts the `pl` decimal comma and\n * space/NBSP thousands separators, because that is what a Polish Excel puts in\n * a cell. Rejects zero-padded digit strings (`007`) \u2014 those are identifiers and\n * belong to `suffixStep`, which preserves the padding.\n */\nfunction parseNumeric(value: unknown): number | null {\n  if (typeof value === 'number') return Number.isFinite(value) ? value : null;\n  if (typeof value !== 'string') return null;\n  const raw = value.trim();\n  if (raw === '') return null;\n  if (/^[+-]?0\\d/.test(raw)) return null;\n  const normalised = raw.replace(/[\\s\\u00a0\\u202f]/g, '').replace(',', '.');\n  if (!/^[+-]?(\\d+(\\.\\d*)?|\\.\\d+)$/.test(normalised)) return null;\n  const n = Number(normalised);\n  return Number.isFinite(n) ? n : null;\n}\n\nfunction decimalsOf(value: unknown): number {\n  const text = typeof value === 'number' ? String(value) : String(value ?? '');\n  const match = /[.,](\\d+)$/.exec(text.trim());\n  return match ? match[1].length : 0;\n}\n\nfunction roundTo(value: number, decimals: number): number {\n  if (decimals <= 0) return Math.round(value);\n  const factor = 10 ** decimals;\n  return Math.round(value * factor) / factor;\n}\n\n// --- dates ---------------------------------------------------------------\n\nconst MS_PER_DAY = 86_400_000;\n\ninterface Ymd {\n  y: number;\n  m: number;\n  d: number;\n}\n\n/**\n * Parse a date cell. `YYYY-MM-DD` (what the grid stores) and `Date` instances\n * only, plus a last-resort `Date` parse \u2014 deliberately narrow, because the\n * caller must never date-parse a column that is not `type: 'date'`.\n */\nfunction parseYmd(value: unknown): Ymd | null {\n  if (value instanceof Date) {\n    if (Number.isNaN(value.getTime())) return null;\n    return { y: value.getFullYear(), m: value.getMonth() + 1, d: value.getDate() };\n  }\n  if (typeof value !== 'string') return null;\n  const raw = value.trim();\n  if (raw === '') return null;\n  const iso = /^(\\d{4})-(\\d{2})-(\\d{2})/.exec(raw);\n  if (iso) return { y: Number(iso[1]), m: Number(iso[2]), d: Number(iso[3]) };\n  const parsed = new Date(raw);\n  if (Number.isNaN(parsed.getTime())) return null;\n  return { y: parsed.getFullYear(), m: parsed.getMonth() + 1, d: parsed.getDate() };\n}\n\nfunction formatYmd({ y, m, d }: Ymd): string {\n  return `${String(y).padStart(4, '0')}-${String(m).padStart(2, '0')}-${String(d).padStart(2, '0')}`;\n}\n\n/** Days since 1970-01-01, computed in UTC so no timezone can shift a date. */\nfunction ymdToDays({ y, m, d }: Ymd): number {\n  return Math.round(Date.UTC(y, m - 1, d) / MS_PER_DAY);\n}\n\nfunction daysToYmd(days: number): Ymd {\n  const date = new Date(days * MS_PER_DAY);\n  return { y: date.getUTCFullYear(), m: date.getUTCMonth() + 1, d: date.getUTCDate() };\n}\n\n/** 0 = Sunday \u2026 6 = Saturday. 1970-01-01 (day 0) was a Thursday. */\nfunction dayOfWeek(days: number): number {\n  return ((days % 7) + 7 + 4) % 7;\n}\n\nfunction isWeekday(days: number): boolean {\n  const dow = dayOfWeek(days);\n  return dow >= 1 && dow <= 5;\n}\n\n/**\n * Monotonic index over Mon-Fri days only: consecutive weekdays differ by 1, so\n * Friday -> Monday is +1 and the \"skip the weekend\" rule needs no special case.\n */\nfunction weekdayIndex(days: number): number {\n  const dow = dayOfWeek(days);\n  const week = Math.floor((days + 3) / 7);\n  return week * 5 + (dow - 1);\n}\n\nfunction weekdayIndexToDays(index: number): number {\n  const week = Math.floor(index / 5);\n  const rest = ((index % 5) + 5) % 5;\n  return week * 7 - 3 + rest;\n}\n\nfunction monthIndex({ y, m }: Ymd): number {\n  return y * 12 + (m - 1);\n}\n\nfunction daysInMonth(y: number, m: number): number {\n  return new Date(Date.UTC(y, m, 0)).getUTCDate();\n}\n\nfunction fromMonthIndex(index: number, day: number): Ymd {\n  const y = Math.floor(index / 12);\n  const m = (((index % 12) + 12) % 12) + 1;\n  // Excel clamps: 31 Jan + 1 month = 28/29 Feb.\n  return { y, m, d: Math.min(day, daysInMonth(y, m)) };\n}\n\n// ============================================\n// DETECTORS\n// ============================================\n\n/**\n * 1. Weekday step. Runs BEFORE `dateStep`: `Fri, Mon, Tue` has day deltas\n * 3,1 and would die there, while as weekdays it is an unambiguous +1. A\n * Fri->Mon seed admits no other reading, so inferring it is not inventing UX.\n *\n * CONSECUTIVE WEEKDAYS ONLY (`|step| === 1`). \"Both seeds happen to fall on a\n * weekday\" is NOT the signal \u2014 that reading hijacked every wide date step whose\n * endpoints missed the weekend: `01.02.2027` + `11.02.2027` are ten CALENDAR\n * days apart but eight WEEKDAYS apart, and the series came out 23.02, 05.03,\n * 17.03 where Excel gives 21.02, 03.03, 13.03 (ledger row 1.16). A step of one\n * weekday is the only delta a user cannot have meant as anything else; every\n * other delta belongs to `dateStep`, which reads it as plain days.\n */\nexport const weekdayStep: FillDetector = (seed) => {\n  if (seed.column.type !== 'date') return null;\n  if (seed.values.length < 2) return null;\n  const days: number[] = [];\n  for (const value of seed.values) {\n    const ymd = parseYmd(value);\n    if (!ymd) return null;\n    const d = ymdToDays(ymd);\n    if (!isWeekday(d)) return null;\n    days.push(d);\n  }\n  const indices = days.map(weekdayIndex);\n  const step = constantDelta(indices);\n  if (step === null || Math.abs(step) !== 1) return null;\n  const base = indices[0];\n  return {\n    kind: 'weekday',\n    defaultMode: 'series',\n    at: (i) => formatYmd(daysToYmd(weekdayIndexToDays(base + step * i))),\n  };\n};\n\n/**\n * 2. Date step \u2014 Excel's own ladder: constant day delta, else a whole-month\n * step on the same day-of-month (which covers whole years as a x12 month\n * step), else no match. A single date seeds +1 day.\n */\nexport const dateStep: FillDetector = (seed) => {\n  if (seed.column.type !== 'date') return null;\n  const parsed: Ymd[] = [];\n  for (const value of seed.values) {\n    const ymd = parseYmd(value);\n    if (!ymd) return null;\n    parsed.push(ymd);\n  }\n  if (parsed.length === 0) return null;\n\n  if (parsed.length === 1) {\n    const base = ymdToDays(parsed[0]);\n    return { kind: 'date', defaultMode: 'series', at: (i) => formatYmd(daysToYmd(base + i)) };\n  }\n\n  // Month step is tested FIRST. Two dates always have a constant day delta, so\n  // testing days first would read 31 Dec -> 31 Jan as \"every 31 days\" and land\n  // on 3 March. Sharing a day-of-month is the unambiguous signal that the user\n  // meant months \u2014 Excel reads it the same way.\n  const sameDayOfMonth = parsed.every((p) => p.d === parsed[0].d);\n  if (sameDayOfMonth) {\n    const months = parsed.map(monthIndex);\n    const monthStep = constantDelta(months);\n    if (monthStep !== null && monthStep !== 0) {\n      const base = months[0];\n      const day = parsed[0].d;\n      return {\n        kind: 'date',\n        defaultMode: 'series',\n        at: (i) => formatYmd(fromMonthIndex(base + monthStep * i, day)),\n      };\n    }\n  }\n\n  const days = parsed.map(ymdToDays);\n  const dayStep = constantDelta(days);\n  if (dayStep !== null && dayStep !== 0) {\n    const base = days[0];\n    return { kind: 'date', defaultMode: 'series', at: (i) => formatYmd(daysToYmd(base + dayStep * i)) };\n  }\n\n  return null;\n};\n\n/**\n * 3. Numeric step. A single number DEFAULTS TO COPY \u2014 Excel's asymmetry with\n * dates, kept \u2014 and `Ctrl` turns it into +1. Two or more require an EXACT\n * constant delta: `1, 2, 4` falls through to copy rather than regressing to\n * 5.5, because a freight user reads a regression result as a bug.\n */\nexport const numericStep: FillDetector = (seed) => {\n  const nums: number[] = [];\n  for (const value of seed.values) {\n    const n = parseNumeric(value);\n    if (n === null) return null;\n    nums.push(n);\n  }\n  if (nums.length === 0) return null;\n\n  const decimals = seed.values.reduce<number>((max, v) => Math.max(max, decimalsOf(v)), 0);\n\n  if (nums.length === 1) {\n    const base = nums[0];\n    return { kind: 'numeric', defaultMode: 'copy', at: (i) => roundTo(base + i, decimals) };\n  }\n\n  const step = constantDelta(nums, 10 ** -(decimals + 6));\n  if (step === null) return null;\n  const base = nums[0];\n  return { kind: 'numeric', defaultMode: 'series', at: (i) => roundTo(base + step * i, decimals) };\n};\n\nconst SUFFIX_RE = /^(.*?)(\\d+)(\\D*)$/;\n\n/**\n * 4. Text with a trailing number: `REF-001` -> `REF-002`. Prefix and trailing\n * part must be identical across the seed. Zero-padding comes from the first\n * seed value and widens on overflow (`REF-999` -> `REF-1000`).\n */\nexport const suffixStep: FillDetector = (seed) => {\n  let prefix: string | null = null;\n  let tail: string | null = null;\n  let width = 0;\n  const nums: number[] = [];\n\n  for (const value of seed.values) {\n    if (typeof value !== 'string') return null;\n    const match = SUFFIX_RE.exec(value);\n    if (!match) return null;\n    const [, p, digits, t] = match;\n    if (prefix === null) {\n      prefix = p;\n      tail = t;\n      width = digits.length;\n    } else if (p !== prefix || t !== tail) {\n      return null;\n    }\n    nums.push(Number(digits));\n  }\n  if (prefix === null || nums.length === 0) return null;\n\n  const step = nums.length === 1 ? 1 : constantDelta(nums);\n  if (step === null) return null;\n  const base = nums[0];\n  const head = prefix;\n  const foot = tail ?? '';\n  return {\n    kind: 'suffix',\n    defaultMode: 'series',\n    at: (i) => {\n      const n = base + step * i;\n      const sign = n < 0 ? '-' : '';\n      return `${head}${sign}${String(Math.abs(n)).padStart(width, '0')}${foot}`;\n    },\n  };\n};\n\n/** The ordered chain. First match wins; `copy` is applied after it. */\nexport const fillDetectors: readonly FillDetector[] = [weekdayStep, dateStep, numericStep, suffixStep];\n\n// ============================================\n// ENTRY POINTS\n// ============================================\n\n/**\n * Never returns null \u2014 `copy` is terminal, so an unrecognised seed still fills.\n *\n * Hard gates, before the chain runs:\n *  - `column.fillSeries === 'copy'` \u2014 a per-column opt-out for identity fields;\n *  - `dropdown` / `multiselect` / `boolean` \u2014 a `source` array is a presentation\n *    order, not a semantic sequence; cycling Draft -> Sent -> Paid -> Draft is\n *    not something a dispatcher asked for;\n *  - an all-blank seed has nothing to continue.\n */\nexport function detectFillPattern(seed: FillSeed): FillPattern {\n  const column = seed.column;\n  if (column.fillSeries === 'copy') return copyPattern(seed);\n  if (column.type === 'dropdown' || column.type === 'multiselect' || column.type === 'boolean') {\n    return copyPattern(seed);\n  }\n  if (seed.values.length === 0 || seed.values.every(isBlank)) return copyPattern(seed);\n\n  for (const detect of fillDetectors) {\n    const pattern = detect(seed);\n    if (pattern) return pattern;\n  }\n  return copyPattern(seed);\n}\n\n/** `Ctrl`/`Alt` inverts copy <-> series. Applied by the CALLER, not a detector. */\nexport function invertFillMode(mode: FillMode): FillMode {\n  return mode === 'series' ? 'copy' : 'series';\n}\n\n/**\n * Values for `count` cells beyond one seed line.\n *\n * `direction: 1` extends past the END of the seed (down / right);\n * `direction: -1` extends past its START (up / left).\n *\n * **Ordering**: the returned values are always ADJACENT-TO-SOURCE FIRST. For a\n * backwards fill, `result[0]` belongs in the cell immediately above/left of the\n * source and `result[n-1]` in the furthest one. The caller walks its target\n * cells outwards from the source in both directions, so it never has to reverse\n * this array.\n */\nexport function generateFill(\n  seed: FillSeed,\n  count: number,\n  direction: 1 | -1,\n  mode: FillMode,\n): unknown[] {\n  if (count <= 0) return [];\n  const pattern = mode === 'copy' ? copyPattern(seed) : detectFillPattern(seed);\n  const k = Math.max(seed.values.length, 1);\n  const out: unknown[] = [];\n  for (let n = 0; n < count; n++) {\n    // Forwards continues at k, k+1, \u2026; backwards at -1, -2, \u2026 \u2014 both walking\n    // away from the source one step at a time.\n    out.push(pattern.at(direction === 1 ? k + n : -1 - n));\n  }\n  return out;\n}\n"],
+  "mappings": "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",
+  "names": ["base"]
+}

package/dist/backend/dynamic-table/utils/formatAggregate.js

@@ -0,0 +1,82 @@
+import * as React from "react";
+const AGGREGATE_EMPTY_PLACEHOLDER = "\u2014";
+const AGGREGATE_UNLABELLED_DIMENSION = "(none)";
+function coerceAggregateValue(value) {
+  if (value === null || value === void 0) return null;
+  if (typeof value === "number") return Number.isFinite(value) ? value : 0;
+  if (typeof value === "bigint") return Number(value);
+  if (typeof value === "boolean") return value ? 1 : 0;
+  if (typeof value === "string") {
+    const s = value.trim();
+    if (!s) return null;
+    const n = Number(s);
+    return Number.isFinite(n) ? n : 0;
+  }
+  if (value instanceof Date) {
+    const t = value.getTime();
+    return Number.isFinite(t) ? t : null;
+  }
+  return 0;
+}
+function fractionDigitsFor(fn) {
+  if (fn === "count" || fn === "countDistinct") return { min: 0, max: 0 };
+  return { min: 2, max: 2 };
+}
+function formatAggregateNumber(num, locale, fn) {
+  const digits = fractionDigitsFor(fn);
+  return new Intl.NumberFormat(locale || "pl-PL", {
+    minimumFractionDigits: digits.min,
+    maximumFractionDigits: digits.max
+  }).format(num);
+}
+function formatAggregateBreakdown(entries, column, locale, fn = "sum") {
+  const rendered = entries.map((entry) => {
+    const num = coerceAggregateValue(entry.value);
+    return {
+      key: entry.key,
+      label: entry.key || AGGREGATE_UNLABELLED_DIMENSION,
+      text: num === null ? AGGREGATE_EMPTY_PLACEHOLDER : formatAggregateNumber(num, locale, fn),
+      magnitude: num === null ? -Infinity : Math.abs(num)
+    };
+  }).sort((a, b) => b.magnitude - a.magnitude);
+  return React.createElement(
+    "span",
+    {
+      className: "hot-aggregate-breakdown",
+      // The stacked lines can outgrow a 140px money column; the flat string is
+      // always available on hover and to assistive tech.
+      title: rendered.map((r) => `${r.text} ${r.label}`).join(" \xB7 "),
+      "data-aggregate-breakdown": String(rendered.length)
+    },
+    rendered.map(
+      (r) => React.createElement(
+        "span",
+        { key: r.key, className: "hot-aggregate-breakdown-line" },
+        React.createElement("span", { className: "hot-aggregate-breakdown-value" }, r.text),
+        " ",
+        React.createElement("span", { className: "hot-aggregate-breakdown-key" }, r.label)
+      )
+    )
+  );
+}
+function formatAggregate(value, column, locale, fn = "sum", breakdown) {
+  if (breakdown && breakdown.length > 0) {
+    return formatAggregateBreakdown(breakdown, column, locale, fn);
+  }
+  const num = coerceAggregateValue(value);
+  if (column.summaryRenderer) return column.summaryRenderer(num ?? 0, column);
+  if (num === null) return AGGREGATE_EMPTY_PLACEHOLDER;
+  if (column.type === "date" && (fn === "min" || fn === "max")) {
+    const d = new Date(num);
+    if (!Number.isNaN(d.getTime())) return d.toLocaleDateString(locale || "pl-PL");
+  }
+  return formatAggregateNumber(num, locale, fn);
+}
+export {
+  AGGREGATE_EMPTY_PLACEHOLDER,
+  AGGREGATE_UNLABELLED_DIMENSION,
+  coerceAggregateValue,
+  formatAggregate,
+  formatAggregateBreakdown
+};
+//# sourceMappingURL=formatAggregate.js.map

package/dist/backend/dynamic-table/utils/formatAggregate.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/backend/dynamic-table/utils/formatAggregate.ts"],
+  "sourcesContent": ["import * as React from 'react';\nimport type { ColumnDef } from '../types/index';\nimport type { AggregationFn, AggregateBreakdownEntry } from '../types/grouping';\n\n/** Rendered when a function had nothing to work with (MIN over no numbers, \u2026). */\nexport const AGGREGATE_EMPTY_PLACEHOLDER = '\u2014';\n\n/** Label for a breakdown slice whose dimension cell was empty. */\nexport const AGGREGATE_UNLABELLED_DIMENSION = '(none)';\n\n/**\n * Coerce a raw aggregate value to a finite number, or `null` when there is\n * genuinely no value.\n *\n * **This is the boundary that used to be wrong.** `formatAggregate` was typed\n * `value: number` and did `Number.isFinite(value) ? value : 0` \u2014 but server\n * aggregates arrive over JSON as *strings*: Postgres returns `COUNT` as `int8`\n * (`\"7\"`) and `SUM` over `numeric` as `\"18400.0000\"`. Both are non-finite as\n * far as `Number.isFinite` is concerned, so every server-side total rendered\n * as `0,00`. Coerce here, once, and everything downstream sees a number.\n */\nexport function coerceAggregateValue(value: unknown): number | null {\n  if (value === null || value === undefined) return null;\n  if (typeof value === 'number') return Number.isFinite(value) ? value : 0;\n  if (typeof value === 'bigint') return Number(value);\n  if (typeof value === 'boolean') return value ? 1 : 0;\n  if (typeof value === 'string') {\n    const s = value.trim();\n    if (!s) return null;\n    const n = Number(s);\n    return Number.isFinite(n) ? n : 0;\n  }\n  if (value instanceof Date) {\n    const t = value.getTime();\n    return Number.isFinite(t) ? t : null;\n  }\n  return 0;\n}\n\n/** Counts are whole things; money and averages carry two decimals. */\nfunction fractionDigitsFor(fn: AggregationFn): { min: number; max: number } {\n  if (fn === 'count' || fn === 'countDistinct') return { min: 0, max: 0 };\n  return { min: 2, max: 2 };\n}\n\n/** The bare number, with no dimension label. Shared by both paths. */\nfunction formatAggregateNumber(num: number, locale: string | undefined, fn: AggregationFn): string {\n  const digits = fractionDigitsFor(fn);\n  return new Intl.NumberFormat(locale || 'pl-PL', {\n    minimumFractionDigits: digits.min,\n    maximumFractionDigits: digits.max,\n  }).format(num);\n}\n\n/**\n * Render a dimensioned aggregate as ONE LABELLED LINE PER SLICE.\n *\n * Slices are sorted by descending magnitude so the figure that dominates the\n * total reads first, with empty-dimension rows last.\n *\n * Every line carries its dimension key. That is the whole point: a summary line\n * without one is the defect (HEDGE-147). A single-slice breakdown therefore\n * still prints its label \u2014 `6 150,00 PLN`, not `6 150,00` \u2014 because \"there\n * happens to be one currency in this group right now\" is not something the\n * reader can tell from an unlabelled number.\n */\nexport function formatAggregateBreakdown(\n  entries: AggregateBreakdownEntry[],\n  column: ColumnDef,\n  locale?: string,\n  fn: AggregationFn = 'sum',\n): React.ReactNode {\n  const rendered = entries\n    .map((entry) => {\n      const num = coerceAggregateValue(entry.value);\n      return {\n        key: entry.key,\n        label: entry.key || AGGREGATE_UNLABELLED_DIMENSION,\n        text: num === null ? AGGREGATE_EMPTY_PLACEHOLDER : formatAggregateNumber(num, locale, fn),\n        magnitude: num === null ? -Infinity : Math.abs(num),\n      };\n    })\n    .sort((a, b) => b.magnitude - a.magnitude);\n\n  return React.createElement(\n    'span',\n    {\n      className: 'hot-aggregate-breakdown',\n      // The stacked lines can outgrow a 140px money column; the flat string is\n      // always available on hover and to assistive tech.\n      title: rendered.map((r) => `${r.text} ${r.label}`).join(' \u00B7 '),\n      'data-aggregate-breakdown': String(rendered.length),\n    },\n    rendered.map((r) =>\n      React.createElement(\n        'span',\n        { key: r.key, className: 'hot-aggregate-breakdown-line' },\n        React.createElement('span', { className: 'hot-aggregate-breakdown-value' }, r.text),\n        ' ',\n        React.createElement('span', { className: 'hot-aggregate-breakdown-key' }, r.label),\n      ),\n    ),\n  );\n}\n\n/**\n * Format an aggregated value for a group-summary or footer-totals row.\n *\n * Uses a dedicated locale number formatter so the summary reads as its own\n * special row rather than mimicking the per-row cell renderer (which often\n * carries currency badges / row-specific chrome). A column may override this\n * with `summaryRenderer` when it needs bespoke formatting.\n *\n * `fn` governs presentation: a `count` renders as an integer, and `min`/`max`\n * on a date column render as a date (the value is epoch milliseconds).\n */\nexport function formatAggregate(\n  value: unknown,\n  column: ColumnDef,\n  locale?: string,\n  fn: AggregationFn = 'sum',\n  breakdown?: AggregateBreakdownEntry[] | null,\n): React.ReactNode {\n  // A dimensioned rule wins over everything below, INCLUDING the scalar and the\n  // column's own `summaryRenderer`. For such a rule the scalar is precisely the\n  // number that must not be shown: `SUM(grossAmount)` across PLN + EUR + USD is\n  // arithmetic on incommensurable quantities, and it renders as a plausible\n  // month-end figure (HEDGE-147). One labelled line per slice instead.\n  if (breakdown && breakdown.length > 0) {\n    return formatAggregateBreakdown(breakdown, column, locale, fn);\n  }\n\n  const num = coerceAggregateValue(value);\n  if (column.summaryRenderer) return column.summaryRenderer(num ?? 0, column);\n  if (num === null) return AGGREGATE_EMPTY_PLACEHOLDER;\n\n  // MIN/MAX over a date column are epoch milliseconds \u2014 show them as dates,\n  // not as a 13-digit number.\n  if (column.type === 'date' && (fn === 'min' || fn === 'max')) {\n    const d = new Date(num);\n    if (!Number.isNaN(d.getTime())) return d.toLocaleDateString(locale || 'pl-PL');\n  }\n\n  return formatAggregateNumber(num, locale, fn);\n}\n"],
+  "mappings": "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",
+  "names": []
+}