@freighttech/ui 0.13.18

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

@@ -0,0 +1,293 @@
+const DEFAULT_COLUMN_OVERSCAN = 3;
+const EMPTY_COLUMN_RANGE = { startIndex: 0, endIndex: -1 };
+function clampIndex(value, columnCount) {
+  if (columnCount <= 0) return 0;
+  if (value < 0) return 0;
+  if (value > columnCount - 1) return columnCount - 1;
+  return value;
+}
+function computeColumnGeometry(columnCount, getColumnWidth, options = {}) {
+  const leadingWidth = options.leadingWidth ?? 0;
+  const trailingWidth = options.trailingWidth ?? 0;
+  const count = Math.max(0, columnCount);
+  const starts = new Array(count + 1);
+  let x = leadingWidth;
+  starts[0] = x;
+  for (let i = 0; i < count; i++) {
+    const width = getColumnWidth(i);
+    x += Number.isFinite(width) && width > 0 ? width : 0;
+    starts[i + 1] = x;
+  }
+  return {
+    columnCount: count,
+    starts,
+    leadingWidth,
+    trailingWidth,
+    totalWidth: x + trailingWidth
+  };
+}
+function getGeometryColumnWidth(geometry, index) {
+  if (index < 0 || index >= geometry.columnCount) return 0;
+  return geometry.starts[index + 1] - geometry.starts[index];
+}
+function getRangeWidth(geometry, from, to) {
+  if (geometry.columnCount === 0 || to < from) return 0;
+  const lo = clampIndex(from, geometry.columnCount);
+  const hi = clampIndex(to, geometry.columnCount);
+  if (hi < lo) return 0;
+  return geometry.starts[hi + 1] - geometry.starts[lo];
+}
+function findColumnIndexAtOffset(geometry, x) {
+  const { columnCount, starts } = geometry;
+  if (columnCount === 0) return -1;
+  if (x <= starts[0]) return 0;
+  if (x >= starts[columnCount]) return columnCount - 1;
+  let lo = 0;
+  let hi = columnCount - 1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    if (starts[mid] <= x) lo = mid;
+    else hi = mid - 1;
+  }
+  return lo;
+}
+function computeVisibleRange(geometry, scrollLeft, viewportWidth) {
+  const { columnCount, starts } = geometry;
+  if (columnCount === 0) return EMPTY_COLUMN_RANGE;
+  if (!(viewportWidth > 0)) return { startIndex: 0, endIndex: columnCount - 1 };
+  const left = Math.max(scrollLeft, starts[0]);
+  const right = scrollLeft + viewportWidth;
+  const startIndex = findColumnIndexAtOffset(geometry, left);
+  let endIndex = startIndex;
+  while (endIndex + 1 < columnCount && starts[endIndex + 1] < right) endIndex++;
+  return { startIndex, endIndex };
+}
+function expandColumnRange(range, overscan, columnCount) {
+  if (columnCount <= 0 || range.endIndex < range.startIndex) return EMPTY_COLUMN_RANGE;
+  const pad = Math.max(0, Math.floor(overscan));
+  return {
+    startIndex: Math.max(0, range.startIndex - pad),
+    endIndex: Math.min(columnCount - 1, range.endIndex + pad)
+  };
+}
+function getPinnedColumnIndices(columns, frozenColumns) {
+  const left = [];
+  const right = [];
+  for (let i = 0; i < columns.length; i++) {
+    const col = columns[i];
+    if (col.sticky === "right") {
+      right.push(i);
+    } else if (col.sticky === "left" || frozenColumns?.has(col.data)) {
+      left.push(i);
+    }
+  }
+  return { left, right };
+}
+function mergePinnedColumns(range, options) {
+  const { columnCount } = options;
+  if (columnCount <= 0) return [];
+  const mounted = /* @__PURE__ */ new Set();
+  if (range.endIndex >= range.startIndex) {
+    const from = Math.max(0, range.startIndex);
+    const to = Math.min(columnCount - 1, range.endIndex);
+    for (let i = from; i <= to; i++) mounted.add(i);
+  }
+  const add = (list) => {
+    if (!list) return;
+    for (const index of list) {
+      if (Number.isInteger(index) && index >= 0 && index < columnCount) mounted.add(index);
+    }
+  };
+  add(options.pinnedLeftIndices);
+  add(options.pinnedRightIndices);
+  add(options.forcedIndices);
+  return Array.from(mounted).sort((a, b) => a - b);
+}
+function buildColumnRenderPlan(mountedIndices, geometry, getColumnKey) {
+  const segments = [];
+  const virtualColumns = [];
+  let cursor = 0;
+  for (const index of mountedIndices) {
+    if (index > cursor) {
+      segments.push({
+        type: "spacer",
+        width: getRangeWidth(geometry, cursor, index - 1),
+        fromIndex: cursor,
+        toIndex: index - 1
+      });
+    }
+    const column = {
+      index,
+      start: geometry.starts[index],
+      end: geometry.starts[index + 1],
+      size: geometry.starts[index + 1] - geometry.starts[index],
+      key: getColumnKey ? getColumnKey(index) : index
+    };
+    virtualColumns.push(column);
+    segments.push({ type: "column", column });
+    cursor = index + 1;
+  }
+  if (cursor < geometry.columnCount) {
+    segments.push({
+      type: "spacer",
+      width: getRangeWidth(geometry, cursor, geometry.columnCount - 1),
+      fromIndex: cursor,
+      toIndex: geometry.columnCount - 1
+    });
+  }
+  return { segments, virtualColumns };
+}
+function summedWidth(geometry, indices) {
+  if (!indices || indices.length === 0) return 0;
+  let total = 0;
+  for (const index of indices) total += getGeometryColumnWidth(geometry, index);
+  return total;
+}
+function finalizeWindow(geometry, mountedIndices, virtualized, pinnedLeftIndices, pinnedRightIndices, getColumnKey) {
+  const { segments, virtualColumns } = buildColumnRenderPlan(
+    mountedIndices,
+    geometry,
+    getColumnKey
+  );
+  const mountedSet = new Set(mountedIndices);
+  const first = mountedIndices[0];
+  const last = mountedIndices[mountedIndices.length - 1];
+  return {
+    virtualized,
+    startIndex: mountedIndices.length ? first : 0,
+    endIndex: mountedIndices.length ? last : -1,
+    columnCount: geometry.columnCount,
+    mountedIndices,
+    virtualColumns,
+    segments,
+    paddingLeft: mountedIndices.length ? getRangeWidth(geometry, 0, first - 1) : 0,
+    paddingRight: mountedIndices.length ? getRangeWidth(geometry, last + 1, geometry.columnCount - 1) : getRangeWidth(geometry, 0, geometry.columnCount - 1),
+    totalWidth: geometry.totalWidth,
+    leadingWidth: geometry.leadingWidth,
+    trailingWidth: geometry.trailingWidth,
+    pinnedLeftWidth: geometry.leadingWidth + summedWidth(geometry, pinnedLeftIndices),
+    pinnedRightWidth: geometry.trailingWidth + summedWidth(geometry, pinnedRightIndices),
+    isColumnMounted: (index) => mountedSet.has(index)
+  };
+}
+function createFullColumnWindow(geometry, options = {}) {
+  const mounted = new Array(geometry.columnCount);
+  for (let i = 0; i < geometry.columnCount; i++) mounted[i] = i;
+  return finalizeWindow(
+    geometry,
+    mounted,
+    false,
+    options.pinnedLeftIndices,
+    options.pinnedRightIndices,
+    options.getColumnKey
+  );
+}
+function buildColumnWindow(input) {
+  const {
+    geometry,
+    pinnedLeftIndices,
+    pinnedRightIndices,
+    forcedIndices,
+    getColumnKey
+  } = input;
+  if (geometry.columnCount === 0) {
+    return finalizeWindow(geometry, [], true, pinnedLeftIndices, pinnedRightIndices, getColumnKey);
+  }
+  const baseRange = input.range ?? computeVisibleRange(geometry, input.scrollLeft ?? 0, input.viewportWidth ?? 0);
+  const overscanned = expandColumnRange(
+    baseRange,
+    input.overscan ?? DEFAULT_COLUMN_OVERSCAN,
+    geometry.columnCount
+  );
+  const mountedIndices = mergePinnedColumns(overscanned, {
+    columnCount: geometry.columnCount,
+    pinnedLeftIndices,
+    pinnedRightIndices,
+    forcedIndices
+  });
+  return finalizeWindow(
+    geometry,
+    mountedIndices,
+    true,
+    pinnedLeftIndices,
+    pinnedRightIndices,
+    getColumnKey
+  );
+}
+function columnIndexToVisualIndex(window, columnIndex) {
+  const list = window.mountedIndices;
+  let lo = 0;
+  let hi = list.length - 1;
+  while (lo <= hi) {
+    const mid = lo + hi >> 1;
+    if (list[mid] === columnIndex) return mid;
+    if (list[mid] < columnIndex) lo = mid + 1;
+    else hi = mid - 1;
+  }
+  return -1;
+}
+function visualIndexToColumnIndex(window, visualIndex) {
+  if (visualIndex < 0 || visualIndex >= window.mountedIndices.length) return -1;
+  return window.mountedIndices[visualIndex];
+}
+function isColumnMounted(window, columnIndex) {
+  return window.isColumnMounted(columnIndex);
+}
+function getAriaColCount(columnCount, options = {}) {
+  return columnCount + (options.hasRowHeader ? 1 : 0) + (options.hasActionsColumn ? 1 : 0);
+}
+function getAriaColIndex(columnIndex, options = {}) {
+  return columnIndex + 1 + (options.hasRowHeader ? 1 : 0);
+}
+function computeScrollLeftToReveal(geometry, columnIndex, options) {
+  const { columnCount } = geometry;
+  if (columnIndex < 0 || columnIndex >= columnCount) return null;
+  if (options.pinnedIndices?.includes(columnIndex)) return null;
+  const viewportWidth = options.viewportWidth;
+  if (!(viewportWidth > 0)) return null;
+  const gutterLeft = options.pinnedLeftWidth ?? geometry.leadingWidth;
+  const gutterRight = options.pinnedRightWidth ?? geometry.trailingWidth;
+  const align = options.align ?? "auto";
+  const columnStart = geometry.starts[columnIndex];
+  const columnEnd = geometry.starts[columnIndex + 1];
+  const maxScroll = Math.max(0, geometry.totalWidth - viewportWidth);
+  const clamp = (value) => Math.min(Math.max(value, 0), maxScroll);
+  const alignStart = () => clamp(columnStart - gutterLeft);
+  const alignEnd = () => clamp(columnEnd + gutterRight - viewportWidth);
+  if (align === "start") return alignStart();
+  if (align === "end") return alignEnd();
+  if (align === "center") {
+    const usable = viewportWidth - gutterLeft - gutterRight;
+    return clamp(columnStart - gutterLeft - Math.max(0, (usable - (columnEnd - columnStart)) / 2));
+  }
+  const visibleStart = options.scrollLeft + gutterLeft;
+  const visibleEnd = options.scrollLeft + viewportWidth - gutterRight;
+  if (columnStart < visibleStart) return alignStart();
+  if (columnEnd > visibleEnd) {
+    if (columnEnd - columnStart > visibleEnd - visibleStart) return alignStart();
+    return alignEnd();
+  }
+  return null;
+}
+export {
+  DEFAULT_COLUMN_OVERSCAN,
+  EMPTY_COLUMN_RANGE,
+  buildColumnRenderPlan,
+  buildColumnWindow,
+  columnIndexToVisualIndex,
+  computeColumnGeometry,
+  computeScrollLeftToReveal,
+  computeVisibleRange,
+  createFullColumnWindow,
+  expandColumnRange,
+  findColumnIndexAtOffset,
+  getAriaColCount,
+  getAriaColIndex,
+  getGeometryColumnWidth,
+  getPinnedColumnIndices,
+  getRangeWidth,
+  isColumnMounted,
+  mergePinnedColumns,
+  visualIndexToColumnIndex
+};
+//# sourceMappingURL=columnWindow.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/backend/dynamic-table/utils/columnWindow.ts"],
+  "sourcesContent": ["/**\n * COLUMN VIRTUALIZATION \u2014 PURE ARITHMETIC\n * =======================================\n *\n * No React, no DOM, no store. Everything that decides *which columns are\n * mounted and where the gaps go* lives here so it can be unit-tested without a\n * browser. `hooks/useColumnVirtualizer.ts` is a thin wrapper that feeds this\n * module a scroll range from `@tanstack/react-virtual` and hands the result to\n * the render tree.\n *\n * WHY THIS EXISTS\n * ---------------\n * The grid virtualizes rows only. Render cost is\n * `(visible rows + overscan) \u00D7 ALL columns`, so a 60-column table pays for 60\n * columns per mounted row no matter how few are on screen. Information density\n * is a product requirement \u2014 the fix is to make cells CHEAPER, never FEWER \u2014\n * so we stop rendering the columns nobody can see instead of showing less.\n *\n * THE CONTRACT THIS MODULE UPHOLDS (from the range-operation audit)\n * ----------------------------------------------------------------\n * A column may be unmounted while still selected, still exported, still written\n * to, still navigated onto. Consequently:\n *\n *  1. Everything here speaks in COLUMN ARRAY INDICES into the full, view-ordered\n *     `cols` array. A window never renumbers columns. `data-col` stays absolute.\n *  2. Geometry comes from the model (`store.getColumnWidth(i)`, which answers\n *     for every `i`, mounted or not) \u2014 never from `clientWidth` / `scrollWidth`\n *     / `getBoundingClientRect` at scroll time.\n *  3. Pinned (sticky-left / sticky-right / menu-frozen) columns are mounted\n *     unconditionally: `position: sticky` only works on an element that exists.\n *  4. The selection anchor, the selection focus and the editing cell are\n *     force-mountable via `forcedIndices` \u2014 `setEditingCell` on an unmounted\n *     column would mount no editor at all.\n *  5. Spacers replace the columns we skipped, so every mounted column keeps its\n *     exact natural x position. A pinned column that is force-mounted is NOT\n *     also counted inside a spacer, so the pinned block can never double-count\n *     against the scroll offset.\n *\n * COORDINATE SPACE\n * ----------------\n * All offsets are in the scroller's content space: x = 0 is the left edge of\n * the `<table>`, `leadingWidth` is the row-header gutter, column 0 therefore\n * starts at `leadingWidth`, and `trailingWidth` is the sticky Actions column.\n * This is the same space as the scroll container's `scrollLeft`.\n */\n\n/** A half-open range of column array indices; `endIndex` is INCLUSIVE. */\nexport interface ColumnRange {\n  startIndex: number;\n  /** Inclusive. `-1` (with `startIndex: 0`) means \"no columns\". */\n  endIndex: number;\n}\n\n/**\n * Prefix-sum geometry over the FULL column array. `starts` has\n * `columnCount + 1` entries: `starts[i]` is column `i`'s left edge and\n * `starts[columnCount]` is the right edge of the last column.\n */\nexport interface ColumnGeometry {\n  columnCount: number;\n  starts: number[];\n  /** Row-header gutter (or 0). `starts[0] === leadingWidth`. */\n  leadingWidth: number;\n  /** Sticky Actions column (or 0). Included in `totalWidth`. */\n  trailingWidth: number;\n  /** leadingWidth + \u03A3 column widths + trailingWidth. */\n  totalWidth: number;\n}\n\n/** One mounted column, shaped like a `VirtualItem` so it reads familiarly. */\nexport interface VirtualColumn {\n  /** Index into the FULL column array. Never a window-relative index. */\n  index: number;\n  /** Absolute left edge in scroller content space. */\n  start: number;\n  /** Absolute right edge. */\n  end: number;\n  /** Column width. */\n  size: number;\n  /** Stable key (`col.data` when the caller supplies `getColumnKey`). */\n  key: string | number;\n}\n\n/**\n * The render plan. A row renders these left-to-right and gets pixel-identical\n * geometry to an unvirtualized row.\n */\nexport type ColumnRenderSegment =\n  | {\n      type: 'spacer';\n      /** Summed width of the skipped columns. */\n      width: number;\n      /** First skipped column index (inclusive). */\n      fromIndex: number;\n      /** Last skipped column index (inclusive). */\n      toIndex: number;\n    }\n  | { type: 'column'; column: VirtualColumn };\n\nexport interface ColumnWindow {\n  /** False when virtualization is off or bypassed \u2014 every column is mounted. */\n  virtualized: boolean;\n  /** First mounted column index (0 when nothing is mounted). */\n  startIndex: number;\n  /** Last mounted column index, INCLUSIVE (-1 when nothing is mounted). */\n  endIndex: number;\n  /** Length of the FULL column array \u2014 the denominator for aria-colcount. */\n  columnCount: number;\n  /** Every mounted index, ascending, unique: window \u222A pinned \u222A forced. */\n  mountedIndices: number[];\n  /** Mounted columns with absolute geometry, ascending by index. */\n  virtualColumns: VirtualColumn[];\n  /** Spacers + columns, in render order. Widths always sum to `totalWidth`. */\n  segments: ColumnRenderSegment[];\n  /** Width of the unmounted columns BEFORE the first mounted one. */\n  paddingLeft: number;\n  /** Width of the unmounted columns AFTER the last mounted one. */\n  paddingRight: number;\n  /** Full-table width \u2014 unchanged by virtualization. */\n  totalWidth: number;\n  leadingWidth: number;\n  trailingWidth: number;\n  /** leadingWidth + \u03A3 widths of sticky/frozen LEFT columns (the left occluder). */\n  pinnedLeftWidth: number;\n  /** trailingWidth + \u03A3 widths of sticky RIGHT columns (the right occluder). */\n  pinnedRightWidth: number;\n  /** O(1). Range operations ask this before touching the DOM. */\n  isColumnMounted: (index: number) => boolean;\n}\n\n/**\n * DEFAULT HORIZONTAL OVERSCAN \u2014 deliberately 3, not the row virtualizer's 10.\n *\n * Overscan is a pixel budget dressed up as an item count, and the two axes have\n * very different pixel-per-item ratios:\n *\n *   \u2022 Rows are 32px (density 'xs') to 44px ('md'). The row virtualizer's\n *     overscan of 10 therefore pre-renders ~320\u2013440px above and below.\n *   \u2022 Columns default to 100px and are commonly 120\u2013200px. Three columns is\n *     ~300\u2013600px on each side \u2014 the SAME pixel buffer for a third of the items.\n *\n * The cost asymmetry runs the other way, which is why we do not simply copy 10:\n * one extra overscanned column costs (mounted rows \u2248 40) extra cells, whereas\n * one extra overscanned row costs (mounted columns \u2248 20) extra cells. A\n * horizontal overscan of 10 on a 60-column grid would mount roughly as many\n * cells as not virtualizing at all on a normal monitor.\n *\n * The trade is against blank flashes on fast horizontal scroll. Horizontal\n * scrolling here is shift+wheel, a trackpad two-finger pan, or a drag on the\n * scrollbar \u2014 all materially slower in items/second than a vertical fling, and\n * `overscan: 0` on the underlying virtualizer means the React commit happens the\n * moment the base range changes, one full column ahead of the viewport edge.\n * Three columns buys ~2\u20134 frames of headroom at typical pan speeds.\n *\n * DO NOT raise this to \"fix\" a blank flash. A blank flash is a commit-latency\n * bug (a re-render blocked by unmemoized work \u2014 see Defect 5); inflating the\n * mounted set to hide it spends exactly the density budget this work exists to\n * buy back.\n */\nexport const DEFAULT_COLUMN_OVERSCAN = 3;\n\n/** An empty range, spelled once so callers can compare against it meaningfully. */\nexport const EMPTY_COLUMN_RANGE: ColumnRange = { startIndex: 0, endIndex: -1 };\n\nfunction clampIndex(value: number, columnCount: number): number {\n  if (columnCount <= 0) return 0;\n  if (value < 0) return 0;\n  if (value > columnCount - 1) return columnCount - 1;\n  return value;\n}\n\n/**\n * Builds the prefix-sum table. O(n) over the FULL column array \u2014 deliberately\n * not over the window, because a window cannot know where it starts without it.\n *\n * `getColumnWidth` is expected to be `store.getColumnWidth`, which answers for\n * any index whether or not the column is mounted. Widths are user-resizable, so\n * the caller must rebuild this whenever a width changes (see the hook's\n * `widthRevision`).\n */\nexport function computeColumnGeometry(\n  columnCount: number,\n  getColumnWidth: (index: number) => number,\n  options: { leadingWidth?: number; trailingWidth?: number } = {}\n): ColumnGeometry {\n  const leadingWidth = options.leadingWidth ?? 0;\n  const trailingWidth = options.trailingWidth ?? 0;\n  const count = Math.max(0, columnCount);\n  const starts = new Array<number>(count + 1);\n  let x = leadingWidth;\n  starts[0] = x;\n  for (let i = 0; i < count; i++) {\n    const width = getColumnWidth(i);\n    x += Number.isFinite(width) && width > 0 ? width : 0;\n    starts[i + 1] = x;\n  }\n  return {\n    columnCount: count,\n    starts,\n    leadingWidth,\n    trailingWidth,\n    totalWidth: x + trailingWidth,\n  };\n}\n\n/** Width of a single column, straight off the geometry. */\nexport function getGeometryColumnWidth(geometry: ColumnGeometry, index: number): number {\n  if (index < 0 || index >= geometry.columnCount) return 0;\n  return geometry.starts[index + 1] - geometry.starts[index];\n}\n\n/** Summed width of an inclusive index range. `to < from` yields 0. */\nexport function getRangeWidth(geometry: ColumnGeometry, from: number, to: number): number {\n  if (geometry.columnCount === 0 || to < from) return 0;\n  const lo = clampIndex(from, geometry.columnCount);\n  const hi = clampIndex(to, geometry.columnCount);\n  if (hi < lo) return 0;\n  return geometry.starts[hi + 1] - geometry.starts[lo];\n}\n\n/**\n * Binary search: the index of the column containing `x` (the last column whose\n * left edge is <= x). Clamped into range, so an `x` left of the first column\n * returns 0 and an `x` past the end returns `columnCount - 1`.\n */\nexport function findColumnIndexAtOffset(geometry: ColumnGeometry, x: number): number {\n  const { columnCount, starts } = geometry;\n  if (columnCount === 0) return -1;\n  if (x <= starts[0]) return 0;\n  if (x >= starts[columnCount]) return columnCount - 1;\n  let lo = 0;\n  let hi = columnCount - 1;\n  while (lo < hi) {\n    const mid = (lo + hi + 1) >> 1;\n    if (starts[mid] <= x) lo = mid;\n    else hi = mid - 1;\n  }\n  return lo;\n}\n\n/**\n * The columns whose boxes intersect `[scrollLeft, scrollLeft + viewportWidth)`,\n * with no overscan. This is the reference implementation of the base range: the\n * hook normally takes the same range from `@tanstack/react-virtual` (which owns\n * the scroll/resize plumbing), and falls back to this when it needs a window\n * without a live virtualizer \u2014 headless callers, SSR, and tests.\n *\n * FAIL-OPEN: a non-positive `viewportWidth` means \"we have not measured yet\".\n * Returning the full range there mounts everything \u2014 correct but slow \u2014 which\n * is the only acceptable direction to fail. Returning an empty range would\n * paint an empty grid.\n */\nexport function computeVisibleRange(\n  geometry: ColumnGeometry,\n  scrollLeft: number,\n  viewportWidth: number\n): ColumnRange {\n  const { columnCount, starts } = geometry;\n  if (columnCount === 0) return EMPTY_COLUMN_RANGE;\n  if (!(viewportWidth > 0)) return { startIndex: 0, endIndex: columnCount - 1 };\n\n  const left = Math.max(scrollLeft, starts[0]);\n  const right = scrollLeft + viewportWidth;\n\n  const startIndex = findColumnIndexAtOffset(geometry, left);\n  let endIndex = startIndex;\n  while (endIndex + 1 < columnCount && starts[endIndex + 1] < right) endIndex++;\n  return { startIndex, endIndex };\n}\n\n/** Grows a range by `overscan` columns on each side, clamped to the array. */\nexport function expandColumnRange(\n  range: ColumnRange,\n  overscan: number,\n  columnCount: number\n): ColumnRange {\n  if (columnCount <= 0 || range.endIndex < range.startIndex) return EMPTY_COLUMN_RANGE;\n  const pad = Math.max(0, Math.floor(overscan));\n  return {\n    startIndex: Math.max(0, range.startIndex - pad),\n    endIndex: Math.min(columnCount - 1, range.endIndex + pad),\n  };\n}\n\n/**\n * Derives the pinned column indices from the grid's two independent pinning\n * sources, both keyed by column DATA KEY so they survive a reorder:\n *\n *   \u2022 static  \u2014 `ColumnDef.sticky === 'left' | 'right'`\n *   \u2022 runtime \u2014 the `frozenColumns: Set<string>` toggled from the header menu\n *               and persisted per-perspective\n *\n * A frozen column is pinned LEFT unless it is already statically sticky-right;\n * that mirrors `effectiveLeftOffsets` in DynamicTable, which folds the runtime\n * frozen set on top of the static left offsets.\n */\nexport function getPinnedColumnIndices(\n  columns: readonly { data: string; sticky?: 'left' | 'right' }[],\n  frozenColumns?: ReadonlySet<string> | null\n): { left: number[]; right: number[] } {\n  const left: number[] = [];\n  const right: number[] = [];\n  for (let i = 0; i < columns.length; i++) {\n    const col = columns[i];\n    if (col.sticky === 'right') {\n      right.push(i);\n    } else if (col.sticky === 'left' || frozenColumns?.has(col.data)) {\n      left.push(i);\n    }\n  }\n  return { left, right };\n}\n\n/**\n * The mounted set: `window \u222A pinned-left \u222A pinned-right \u222A forced`, ascending and\n * de-duplicated. `forced` carries the selection anchor, the selection focus and\n * the editing cell \u2014 moving the selection onto a column and then failing to\n * mount it is how you get an invisible cursor and a missing editor.\n *\n * Out-of-range indices are dropped rather than throwing: `forced` comes from\n * selection state that can outlive a column being hidden by a perspective.\n */\nexport function mergePinnedColumns(\n  range: ColumnRange,\n  options: {\n    columnCount: number;\n    pinnedLeftIndices?: readonly number[];\n    pinnedRightIndices?: readonly number[];\n    forcedIndices?: readonly number[];\n  }\n): number[] {\n  const { columnCount } = options;\n  if (columnCount <= 0) return [];\n  const mounted = new Set<number>();\n  if (range.endIndex >= range.startIndex) {\n    const from = Math.max(0, range.startIndex);\n    const to = Math.min(columnCount - 1, range.endIndex);\n    for (let i = from; i <= to; i++) mounted.add(i);\n  }\n  const add = (list?: readonly number[]) => {\n    if (!list) return;\n    for (const index of list) {\n      if (Number.isInteger(index) && index >= 0 && index < columnCount) mounted.add(index);\n    }\n  };\n  add(options.pinnedLeftIndices);\n  add(options.pinnedRightIndices);\n  add(options.forcedIndices);\n  return Array.from(mounted).sort((a, b) => a - b);\n}\n\n/**\n * Turns a mounted index list into the left-to-right render plan.\n *\n * Gaps become spacers \u2014 INCLUDING interior gaps. That is what lets a pinned\n * column that sits far to the left stay mounted without being double-counted:\n * it occupies its own real box at its own natural x, and only the columns\n * actually skipped are folded into a spacer. Widths always sum to\n * `totalWidth - leadingWidth - trailingWidth`.\n */\nexport function buildColumnRenderPlan(\n  mountedIndices: readonly number[],\n  geometry: ColumnGeometry,\n  getColumnKey?: (index: number) => string | number\n): { segments: ColumnRenderSegment[]; virtualColumns: VirtualColumn[] } {\n  const segments: ColumnRenderSegment[] = [];\n  const virtualColumns: VirtualColumn[] = [];\n  let cursor = 0;\n\n  for (const index of mountedIndices) {\n    if (index > cursor) {\n      segments.push({\n        type: 'spacer',\n        width: getRangeWidth(geometry, cursor, index - 1),\n        fromIndex: cursor,\n        toIndex: index - 1,\n      });\n    }\n    const column: VirtualColumn = {\n      index,\n      start: geometry.starts[index],\n      end: geometry.starts[index + 1],\n      size: geometry.starts[index + 1] - geometry.starts[index],\n      key: getColumnKey ? getColumnKey(index) : index,\n    };\n    virtualColumns.push(column);\n    segments.push({ type: 'column', column });\n    cursor = index + 1;\n  }\n\n  if (cursor < geometry.columnCount) {\n    segments.push({\n      type: 'spacer',\n      width: getRangeWidth(geometry, cursor, geometry.columnCount - 1),\n      fromIndex: cursor,\n      toIndex: geometry.columnCount - 1,\n    });\n  }\n\n  return { segments, virtualColumns };\n}\n\nexport interface BuildColumnWindowInput {\n  geometry: ColumnGeometry;\n  /**\n   * Base (un-overscanned) range. Supply it from the underlying virtualizer;\n   * omit it and `scrollLeft` / `viewportWidth` are used instead.\n   */\n  range?: ColumnRange | null;\n  scrollLeft?: number;\n  viewportWidth?: number;\n  overscan?: number;\n  pinnedLeftIndices?: readonly number[];\n  pinnedRightIndices?: readonly number[];\n  forcedIndices?: readonly number[];\n  getColumnKey?: (index: number) => string | number;\n}\n\nfunction summedWidth(geometry: ColumnGeometry, indices?: readonly number[]): number {\n  if (!indices || indices.length === 0) return 0;\n  let total = 0;\n  for (const index of indices) total += getGeometryColumnWidth(geometry, index);\n  return total;\n}\n\nfunction finalizeWindow(\n  geometry: ColumnGeometry,\n  mountedIndices: number[],\n  virtualized: boolean,\n  pinnedLeftIndices: readonly number[] | undefined,\n  pinnedRightIndices: readonly number[] | undefined,\n  getColumnKey?: (index: number) => string | number\n): ColumnWindow {\n  const { segments, virtualColumns } = buildColumnRenderPlan(\n    mountedIndices,\n    geometry,\n    getColumnKey\n  );\n  const mountedSet = new Set(mountedIndices);\n  const first = mountedIndices[0];\n  const last = mountedIndices[mountedIndices.length - 1];\n\n  return {\n    virtualized,\n    startIndex: mountedIndices.length ? first : 0,\n    endIndex: mountedIndices.length ? last : -1,\n    columnCount: geometry.columnCount,\n    mountedIndices,\n    virtualColumns,\n    segments,\n    paddingLeft: mountedIndices.length ? getRangeWidth(geometry, 0, first - 1) : 0,\n    paddingRight: mountedIndices.length\n      ? getRangeWidth(geometry, last + 1, geometry.columnCount - 1)\n      : getRangeWidth(geometry, 0, geometry.columnCount - 1),\n    totalWidth: geometry.totalWidth,\n    leadingWidth: geometry.leadingWidth,\n    trailingWidth: geometry.trailingWidth,\n    pinnedLeftWidth: geometry.leadingWidth + summedWidth(geometry, pinnedLeftIndices),\n    pinnedRightWidth: geometry.trailingWidth + summedWidth(geometry, pinnedRightIndices),\n    isColumnMounted: (index: number) => mountedSet.has(index),\n  };\n}\n\n/**\n * Every column mounted, no spacers. Used when virtualization is switched off,\n * and as the fail-open result when geometry has not been measured yet.\n */\nexport function createFullColumnWindow(\n  geometry: ColumnGeometry,\n  options: {\n    pinnedLeftIndices?: readonly number[];\n    pinnedRightIndices?: readonly number[];\n    getColumnKey?: (index: number) => string | number;\n  } = {}\n): ColumnWindow {\n  const mounted: number[] = new Array(geometry.columnCount);\n  for (let i = 0; i < geometry.columnCount; i++) mounted[i] = i;\n  return finalizeWindow(\n    geometry,\n    mounted,\n    false,\n    options.pinnedLeftIndices,\n    options.pinnedRightIndices,\n    options.getColumnKey\n  );\n}\n\n/** The one entry point: range \u2192 overscan \u2192 pinned merge \u2192 render plan. */\nexport function buildColumnWindow(input: BuildColumnWindowInput): ColumnWindow {\n  const {\n    geometry,\n    pinnedLeftIndices,\n    pinnedRightIndices,\n    forcedIndices,\n    getColumnKey,\n  } = input;\n\n  if (geometry.columnCount === 0) {\n    return finalizeWindow(geometry, [], true, pinnedLeftIndices, pinnedRightIndices, getColumnKey);\n  }\n\n  const baseRange =\n    input.range ??\n    computeVisibleRange(geometry, input.scrollLeft ?? 0, input.viewportWidth ?? 0);\n\n  const overscanned = expandColumnRange(\n    baseRange,\n    input.overscan ?? DEFAULT_COLUMN_OVERSCAN,\n    geometry.columnCount\n  );\n\n  const mountedIndices = mergePinnedColumns(overscanned, {\n    columnCount: geometry.columnCount,\n    pinnedLeftIndices,\n    pinnedRightIndices,\n    forcedIndices,\n  });\n\n  return finalizeWindow(\n    geometry,\n    mountedIndices,\n    true,\n    pinnedLeftIndices,\n    pinnedRightIndices,\n    getColumnKey\n  );\n}\n\n// ============================================================================\n// INDEX MAPPING \u2014 \"visual\" (position among rendered cells) \u2194 column array index\n// ============================================================================\n//\n// The grid addresses cells as (rowIndex, colIndex) into the FULL column array,\n// and `data-col` must keep carrying that absolute index or every pointer\n// hit-test in handlers/index.ts silently retargets. These two helpers exist for\n// the narrow cases that genuinely need the rendered position \u2014 DOM sibling\n// walks, focus order, screen-reader ordering \u2014 and nothing else should use them.\n\n/** Position of `columnIndex` among the mounted columns, or -1 if unmounted. */\nexport function columnIndexToVisualIndex(window: ColumnWindow, columnIndex: number): number {\n  // mountedIndices is ascending, so binary search rather than indexOf.\n  const list = window.mountedIndices;\n  let lo = 0;\n  let hi = list.length - 1;\n  while (lo <= hi) {\n    const mid = (lo + hi) >> 1;\n    if (list[mid] === columnIndex) return mid;\n    if (list[mid] < columnIndex) lo = mid + 1;\n    else hi = mid - 1;\n  }\n  return -1;\n}\n\n/** Column array index rendered at mounted position `visualIndex`, or -1. */\nexport function visualIndexToColumnIndex(window: ColumnWindow, visualIndex: number): number {\n  if (visualIndex < 0 || visualIndex >= window.mountedIndices.length) return -1;\n  return window.mountedIndices[visualIndex];\n}\n\n/** Convenience predicate for range operations that only hold a window. */\nexport function isColumnMounted(window: ColumnWindow, columnIndex: number): boolean {\n  return window.isColumnMounted(columnIndex);\n}\n\n// ============================================================================\n// ACCESSIBILITY\n// ============================================================================\n//\n// Unmounted columns break grid semantics if `aria-colcount` / `aria-colindex`\n// are inferred from the DOM: a screen reader would announce \"column 4 of 12\"\n// while the user is on column 37 of 60. Both are therefore computed from the\n// FULL column list, exactly like `data-col`. A grid whose rendered cells are a\n// subset MUST set `aria-colcount` on the grid and `aria-colindex` on every cell\n// and header \u2014 omitting `aria-colindex` is only legal when the DOM is complete.\n\n/** 1-based total, counting the row-header and Actions columns when present. */\nexport function getAriaColCount(\n  columnCount: number,\n  options: { hasRowHeader?: boolean; hasActionsColumn?: boolean } = {}\n): number {\n  return (\n    columnCount + (options.hasRowHeader ? 1 : 0) + (options.hasActionsColumn ? 1 : 0)\n  );\n}\n\n/** 1-based aria index of a data column; the row header occupies index 1. */\nexport function getAriaColIndex(\n  columnIndex: number,\n  options: { hasRowHeader?: boolean } = {}\n): number {\n  return columnIndex + 1 + (options.hasRowHeader ? 1 : 0);\n}\n\n// ============================================================================\n// SCROLL-INTO-VIEW\n// ============================================================================\n\nexport type ColumnScrollAlign = 'auto' | 'start' | 'end' | 'center';\n\n/**\n * The `scrollLeft` that brings `columnIndex` into view, or `null` when no scroll\n * is needed (already visible under `'auto'`, or the column is pinned and can\n * never be scrolled away from).\n *\n * The pinned block occludes the viewport's left and right edges, so a column is\n * only \"visible\" between `pinnedLeftWidth` and `viewportWidth - pinnedRightWidth`\n * \u2014 scrolling a cell to `scrollLeft` exactly would park it underneath a frozen\n * column and it would look like nothing happened.\n *\n * This exists because there is currently NO horizontal scroll-into-view anywhere\n * in the grid. Keyboard navigation and `setEditingCell` move the selection by\n * index, which under column virtualization can land on a column that is not\n * mounted \u2014 the caller must scroll in the same commit, before any focus attempt.\n */\nexport function computeScrollLeftToReveal(\n  geometry: ColumnGeometry,\n  columnIndex: number,\n  options: {\n    scrollLeft: number;\n    viewportWidth: number;\n    /** Left occluder \u2014 `ColumnWindow.pinnedLeftWidth`. */\n    pinnedLeftWidth?: number;\n    /** Right occluder \u2014 `ColumnWindow.pinnedRightWidth`. */\n    pinnedRightWidth?: number;\n    align?: ColumnScrollAlign;\n    /** Indices that are pinned and therefore always visible. */\n    pinnedIndices?: readonly number[];\n  }\n): number | null {\n  const { columnCount } = geometry;\n  if (columnIndex < 0 || columnIndex >= columnCount) return null;\n  if (options.pinnedIndices?.includes(columnIndex)) return null;\n\n  const viewportWidth = options.viewportWidth;\n  if (!(viewportWidth > 0)) return null;\n\n  const gutterLeft = options.pinnedLeftWidth ?? geometry.leadingWidth;\n  const gutterRight = options.pinnedRightWidth ?? geometry.trailingWidth;\n  const align = options.align ?? 'auto';\n\n  const columnStart = geometry.starts[columnIndex];\n  const columnEnd = geometry.starts[columnIndex + 1];\n\n  const maxScroll = Math.max(0, geometry.totalWidth - viewportWidth);\n  const clamp = (value: number) => Math.min(Math.max(value, 0), maxScroll);\n\n  const alignStart = () => clamp(columnStart - gutterLeft);\n  const alignEnd = () => clamp(columnEnd + gutterRight - viewportWidth);\n\n  if (align === 'start') return alignStart();\n  if (align === 'end') return alignEnd();\n  if (align === 'center') {\n    const usable = viewportWidth - gutterLeft - gutterRight;\n    return clamp(columnStart - gutterLeft - Math.max(0, (usable - (columnEnd - columnStart)) / 2));\n  }\n\n  // 'auto': only move if the column is actually occluded. A column wider than\n  // the usable viewport aligns to its start, so at least its leading edge and\n  // its content anchor are visible.\n  const visibleStart = options.scrollLeft + gutterLeft;\n  const visibleEnd = options.scrollLeft + viewportWidth - gutterRight;\n  if (columnStart < visibleStart) return alignStart();\n  if (columnEnd > visibleEnd) {\n    if (columnEnd - columnStart > visibleEnd - visibleStart) return alignStart();\n    return alignEnd();\n  }\n  return null;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

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

@@ -0,0 +1,188 @@
+const CONDITIONAL_FORMAT_STYLES = [
+  "green",
+  "yellow",
+  "red",
+  "green-subtle",
+  "yellow-subtle",
+  "red-subtle"
+];
+const CONDITIONAL_FORMAT_OPERATORS = [
+  "eq",
+  "neq",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "contains",
+  "isEmpty",
+  "isNotEmpty",
+  "beforeField",
+  "afterField"
+];
+const RELATIVE_OPERATORS = ["beforeField", "afterField"];
+const UNARY_OPERATORS = ["isEmpty", "isNotEmpty"];
+function operatorNeedsValue(op) {
+  return !UNARY_OPERATORS.includes(op) && !RELATIVE_OPERATORS.includes(op);
+}
+function operatorNeedsCompareField(op) {
+  return RELATIVE_OPERATORS.includes(op);
+}
+const MAX_CONDITIONAL_FORMAT_RULES = 20;
+function generateConditionalFormatRuleId() {
+  return `cf-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+}
+function parseConditionalFormats(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const entry of raw) {
+    if (!entry || typeof entry !== "object") continue;
+    const { id, field, operator, value, compareField, style } = entry;
+    if (typeof field !== "string" || !field) continue;
+    if (typeof operator !== "string" || !CONDITIONAL_FORMAT_OPERATORS.includes(operator))
+      continue;
+    if (typeof style !== "string" || !CONDITIONAL_FORMAT_STYLES.includes(style))
+      continue;
+    const op = operator;
+    if (operatorNeedsCompareField(op) && (typeof compareField !== "string" || !compareField)) continue;
+    out.push({
+      id: typeof id === "string" && id ? id : generateConditionalFormatRuleId(),
+      field,
+      operator: op,
+      value: typeof value === "string" || typeof value === "number" ? value : value === null ? null : void 0,
+      compareField: typeof compareField === "string" && compareField ? compareField : void 0,
+      style
+    });
+    if (out.length >= MAX_CONDITIONAL_FORMAT_RULES) break;
+  }
+  return out;
+}
+const EMPTY_CONDITIONAL_FORMATS = {
+  byField: /* @__PURE__ */ new Map(),
+  isEmpty: true
+};
+function isBlank(v) {
+  return v === null || v === void 0 || typeof v === "string" && v.trim() === "";
+}
+function asNumber(v) {
+  if (typeof v === "number") return Number.isFinite(v) ? v : null;
+  if (typeof v === "boolean") return v ? 1 : 0;
+  if (typeof v !== "string") return null;
+  const s = v.trim();
+  if (!s) return null;
+  const n = Number(s);
+  return Number.isFinite(n) ? n : null;
+}
+function asComparable(v) {
+  if (v instanceof Date) {
+    const t = v.getTime();
+    return Number.isNaN(t) ? null : t;
+  }
+  const n = asNumber(v);
+  if (n !== null) return n;
+  if (typeof v === "string") {
+    const t = Date.parse(v.trim());
+    if (!Number.isNaN(t)) return t;
+  }
+  return null;
+}
+function compileRule(rule) {
+  const className = `cell-${rule.style}`;
+  const literal = rule.value;
+  switch (rule.operator) {
+    case "isEmpty":
+      return { test: (v) => isBlank(v), className };
+    case "isNotEmpty":
+      return { test: (v) => !isBlank(v), className };
+    case "contains": {
+      const needle = String(literal ?? "").toLowerCase();
+      if (!needle) return null;
+      return { test: (v) => !isBlank(v) && String(v).toLowerCase().includes(needle), className };
+    }
+    case "eq":
+    case "neq": {
+      const wantNumber = asNumber(literal);
+      const wantText = String(literal ?? "").toLowerCase();
+      const eq = (v) => {
+        if (wantNumber !== null) {
+          const n = asNumber(v);
+          if (n !== null) return n === wantNumber;
+        }
+        if (isBlank(v)) return isBlank(literal);
+        return String(v).toLowerCase() === wantText;
+      };
+      return rule.operator === "eq" ? { test: eq, className } : { test: (v, row) => !eq(v, row), className };
+    }
+    case "gt":
+    case "gte":
+    case "lt":
+    case "lte": {
+      const bound = asComparable(literal);
+      if (bound === null) return null;
+      const op = rule.operator;
+      return {
+        test: (v) => {
+          const n = asComparable(v);
+          if (n === null) return false;
+          if (op === "gt") return n > bound;
+          if (op === "gte") return n >= bound;
+          if (op === "lt") return n < bound;
+          return n <= bound;
+        },
+        className
+      };
+    }
+    case "beforeField":
+    case "afterField": {
+      const other = rule.compareField;
+      if (!other) return null;
+      const wantBefore = rule.operator === "beforeField";
+      return {
+        test: (v, rowData) => {
+          const a = asComparable(v);
+          const b = asComparable(rowData?.[other]);
+          if (a === null || b === null) return false;
+          return wantBefore ? a < b : a > b;
+        },
+        className
+      };
+    }
+    default:
+      return null;
+  }
+}
+function compileConditionalFormats(rules) {
+  if (!rules || rules.length === 0) return EMPTY_CONDITIONAL_FORMATS;
+  const byField = /* @__PURE__ */ new Map();
+  for (const rule of rules.slice(0, MAX_CONDITIONAL_FORMAT_RULES)) {
+    const compiled = compileRule(rule);
+    if (!compiled) continue;
+    const list = byField.get(rule.field);
+    if (list) list.push(compiled);
+    else byField.set(rule.field, [compiled]);
+  }
+  return { byField, isEmpty: byField.size === 0 };
+}
+function conditionalFormatClassName(compiled, field, value, rowData) {
+  if (compiled.isEmpty) return void 0;
+  const rules = compiled.byField.get(field);
+  if (!rules) return void 0;
+  for (const rule of rules) {
+    if (rule.test(value, rowData)) return rule.className;
+  }
+  return void 0;
+}
+export {
+  CONDITIONAL_FORMAT_OPERATORS,
+  CONDITIONAL_FORMAT_STYLES,
+  EMPTY_CONDITIONAL_FORMATS,
+  MAX_CONDITIONAL_FORMAT_RULES,
+  RELATIVE_OPERATORS,
+  UNARY_OPERATORS,
+  compileConditionalFormats,
+  conditionalFormatClassName,
+  generateConditionalFormatRuleId,
+  operatorNeedsCompareField,
+  operatorNeedsValue,
+  parseConditionalFormats
+};
+//# sourceMappingURL=conditionalFormat.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/backend/dynamic-table/utils/conditionalFormat.ts"],
+  "sourcesContent": ["// utils/conditionalFormat.ts\n//\n// User-authored conditional formatting (\"Highlighting\"). Rules are view-scoped:\n// they ride inside the perspective's `settings.filters._conditionalFormats`\n// passthrough, so switching views switches the highlighting.\n//\n// The rule type is declared HERE rather than in `types/perspective.ts` so this\n// feature owns its own vocabulary; `PerspectiveConfig` picks it up through\n// `ConditionalFormatCarrier` below.\n\n/** Palette variants. Each maps 1:1 onto an existing `cell-*` class in DynamicTable.css. */\nexport type ConditionalFormatStyle =\n  | 'green'\n  | 'yellow'\n  | 'red'\n  | 'green-subtle'\n  | 'yellow-subtle'\n  | 'red-subtle';\n\nexport const CONDITIONAL_FORMAT_STYLES: readonly ConditionalFormatStyle[] = [\n  'green',\n  'yellow',\n  'red',\n  'green-subtle',\n  'yellow-subtle',\n  'red-subtle',\n] as const;\n\nexport type ConditionalFormatOperator =\n  | 'eq'\n  | 'neq'\n  | 'gt'\n  | 'gte'\n  | 'lt'\n  | 'lte'\n  | 'contains'\n  | 'isEmpty'\n  | 'isNotEmpty'\n  /** `field` is chronologically before `compareField` \u2014 the ETA-vs-ATA delay case. */\n  | 'beforeField'\n  /** `field` is chronologically after `compareField`. */\n  | 'afterField';\n\nexport const CONDITIONAL_FORMAT_OPERATORS: readonly ConditionalFormatOperator[] = [\n  'eq',\n  'neq',\n  'gt',\n  'gte',\n  'lt',\n  'lte',\n  'contains',\n  'isEmpty',\n  'isNotEmpty',\n  'beforeField',\n  'afterField',\n] as const;\n\n/** Operators that compare against another column instead of a literal. */\nexport const RELATIVE_OPERATORS: readonly ConditionalFormatOperator[] = ['beforeField', 'afterField'];\n\n/** Operators that need no comparand at all. */\nexport const UNARY_OPERATORS: readonly ConditionalFormatOperator[] = ['isEmpty', 'isNotEmpty'];\n\nexport function operatorNeedsValue(op: ConditionalFormatOperator): boolean {\n  return !UNARY_OPERATORS.includes(op) && !RELATIVE_OPERATORS.includes(op);\n}\n\nexport function operatorNeedsCompareField(op: ConditionalFormatOperator): boolean {\n  return RELATIVE_OPERATORS.includes(op);\n}\n\nexport interface ConditionalFormatRule {\n  /** `cf-<something unique>`. */\n  id: string;\n  /** `ColumnDef.data` key the rule paints. */\n  field: string;\n  operator: ConditionalFormatOperator;\n  /** Literal comparand. Ignored by unary and relative operators. */\n  value?: string | number | null;\n  /** Other column's `data` key, for `beforeField` / `afterField`. */\n  compareField?: string;\n  style: ConditionalFormatStyle;\n}\n\n/**\n * Mixin that carries view-scoped highlighting rules on a `PerspectiveConfig`.\n * Declared here so `types/perspective.ts` does not have to change; once the\n * field is folded into `PerspectiveConfig` itself the intersection becomes a\n * harmless no-op.\n */\nexport interface ConditionalFormatCarrier {\n  conditionalFormats?: ConditionalFormatRule[];\n}\n\n/**\n * Hard cap. Rules are evaluated on the cell render path, so an unbounded rule\n * set is a scroll-performance hazard. 20 is the spec's number.\n */\nexport const MAX_CONDITIONAL_FORMAT_RULES = 20;\n\nexport function generateConditionalFormatRuleId(): string {\n  return `cf-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;\n}\n\n// \u2500\u2500\u2500 Parsing (persistence boundary) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n/**\n * Defensively parse `_conditionalFormats` out of the perspective settings\n * passthrough. Anything malformed is dropped rather than allowed to crash the\n * grid, and the list is capped.\n */\nexport function parseConditionalFormats(raw: unknown): ConditionalFormatRule[] {\n  if (!Array.isArray(raw)) return [];\n  const out: ConditionalFormatRule[] = [];\n  for (const entry of raw) {\n    if (!entry || typeof entry !== 'object') continue;\n    const { id, field, operator, value, compareField, style } = entry as Record<string, unknown>;\n    if (typeof field !== 'string' || !field) continue;\n    if (\n      typeof operator !== 'string' ||\n      !(CONDITIONAL_FORMAT_OPERATORS as readonly string[]).includes(operator)\n    )\n      continue;\n    if (typeof style !== 'string' || !(CONDITIONAL_FORMAT_STYLES as readonly string[]).includes(style))\n      continue;\n    const op = operator as ConditionalFormatOperator;\n    if (operatorNeedsCompareField(op) && (typeof compareField !== 'string' || !compareField)) continue;\n    out.push({\n      id: typeof id === 'string' && id ? id : generateConditionalFormatRuleId(),\n      field,\n      operator: op,\n      value:\n        typeof value === 'string' || typeof value === 'number' ? value : value === null ? null : undefined,\n      compareField: typeof compareField === 'string' && compareField ? compareField : undefined,\n      style: style as ConditionalFormatStyle,\n    });\n    if (out.length >= MAX_CONDITIONAL_FORMAT_RULES) break;\n  }\n  return out;\n}\n\n// \u2500\u2500\u2500 Evaluation \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\ntype Predicate = (value: unknown, rowData: any) => boolean;\n\ninterface CompiledRule {\n  test: Predicate;\n  className: string;\n}\n\n/** Pre-compiled rule set: field -> ordered predicates. */\nexport interface CompiledConditionalFormats {\n  byField: Map<string, CompiledRule[]>;\n  /** `true` when there is nothing to evaluate \u2014 lets callers skip entirely. */\n  isEmpty: boolean;\n}\n\nexport const EMPTY_CONDITIONAL_FORMATS: CompiledConditionalFormats = {\n  byField: new Map(),\n  isEmpty: true,\n};\n\nfunction isBlank(v: unknown): boolean {\n  return v === null || v === undefined || (typeof v === 'string' && v.trim() === '');\n}\n\nfunction asNumber(v: unknown): number | null {\n  if (typeof v === 'number') return Number.isFinite(v) ? v : null;\n  if (typeof v === 'boolean') return v ? 1 : 0;\n  if (typeof v !== 'string') return null;\n  const s = v.trim();\n  if (!s) return null;\n  const n = Number(s);\n  return Number.isFinite(n) ? n : null;\n}\n\n/** Comparable ordering key: a date if both sides parse as dates, else a number. */\nfunction asComparable(v: unknown): number | null {\n  if (v instanceof Date) {\n    const t = v.getTime();\n    return Number.isNaN(t) ? null : t;\n  }\n  const n = asNumber(v);\n  if (n !== null) return n;\n  if (typeof v === 'string') {\n    const t = Date.parse(v.trim());\n    if (!Number.isNaN(t)) return t;\n  }\n  return null;\n}\n\nfunction compileRule(rule: ConditionalFormatRule): CompiledRule | null {\n  const className = `cell-${rule.style}`;\n  const literal = rule.value;\n\n  switch (rule.operator) {\n    case 'isEmpty':\n      return { test: (v) => isBlank(v), className };\n    case 'isNotEmpty':\n      return { test: (v) => !isBlank(v), className };\n    case 'contains': {\n      const needle = String(literal ?? '').toLowerCase();\n      if (!needle) return null;\n      return { test: (v) => !isBlank(v) && String(v).toLowerCase().includes(needle), className };\n    }\n    case 'eq':\n    case 'neq': {\n      const wantNumber = asNumber(literal);\n      const wantText = String(literal ?? '').toLowerCase();\n      const eq: Predicate = (v) => {\n        if (wantNumber !== null) {\n          const n = asNumber(v);\n          if (n !== null) return n === wantNumber;\n        }\n        if (isBlank(v)) return isBlank(literal);\n        return String(v).toLowerCase() === wantText;\n      };\n      return rule.operator === 'eq'\n        ? { test: eq, className }\n        : { test: (v, row) => !eq(v, row), className };\n    }\n    case 'gt':\n    case 'gte':\n    case 'lt':\n    case 'lte': {\n      const bound = asComparable(literal);\n      if (bound === null) return null;\n      const op = rule.operator;\n      return {\n        test: (v) => {\n          const n = asComparable(v);\n          if (n === null) return false;\n          if (op === 'gt') return n > bound;\n          if (op === 'gte') return n >= bound;\n          if (op === 'lt') return n < bound;\n          return n <= bound;\n        },\n        className,\n      };\n    }\n    case 'beforeField':\n    case 'afterField': {\n      const other = rule.compareField;\n      if (!other) return null;\n      const wantBefore = rule.operator === 'beforeField';\n      return {\n        test: (v, rowData) => {\n          const a = asComparable(v);\n          const b = asComparable(rowData?.[other]);\n          if (a === null || b === null) return false;\n          return wantBefore ? a < b : a > b;\n        },\n        className,\n      };\n    }\n    default:\n      return null;\n  }\n}\n\n/**\n * Compile a rule set ONCE per change, not once per cell. Rules that cannot\n * produce a meaningful predicate (a `gt` with no comparand, a `beforeField`\n * with no target) are dropped rather than matching everything.\n */\nexport function compileConditionalFormats(\n  rules: ConditionalFormatRule[] | undefined | null,\n): CompiledConditionalFormats {\n  if (!rules || rules.length === 0) return EMPTY_CONDITIONAL_FORMATS;\n  const byField = new Map<string, CompiledRule[]>();\n  for (const rule of rules.slice(0, MAX_CONDITIONAL_FORMAT_RULES)) {\n    const compiled = compileRule(rule);\n    if (!compiled) continue;\n    const list = byField.get(rule.field);\n    if (list) list.push(compiled);\n    else byField.set(rule.field, [compiled]);\n  }\n  return { byField, isEmpty: byField.size === 0 };\n}\n\n/**\n * Resolve the highlight class for one cell. First matching rule wins (Excel's\n * precedence: rules are ordered and the first one that fires paints the cell).\n * Returns `undefined` when nothing matches, so the caller can fall through to\n * the code-level `cellClassName` hook.\n */\nexport function conditionalFormatClassName(\n  compiled: CompiledConditionalFormats,\n  field: string,\n  value: unknown,\n  rowData: any,\n): string | undefined {\n  if (compiled.isEmpty) return undefined;\n  const rules = compiled.byField.get(field);\n  if (!rules) return undefined;\n  for (const rule of rules) {\n    if (rule.test(value, rowData)) return rule.className;\n  }\n  return undefined;\n}\n"],
+  "mappings": "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",
+  "names": []
+}