Skip to content

ServerKit is a lightweight, modern server control panel for managing web applications, databases, and services on your VPS or dedicated server. Built with Python/Flask backend and React frontend.

feat(ds): DataGrid -- the list surface for pages where the table is the page

Juan Denisc66d5037ef1b
diff --git a/frontend/src/components/ds/grid/ColumnMenu.jsx b/frontend/src/components/ds/grid/ColumnMenu.jsx
new file mode 100644
index 00000000..9b2ad063
--- /dev/null
+++ b/frontend/src/components/ds/grid/ColumnMenu.jsx
@@ -0,0 +1,283 @@
+import { useState } from 'react';
+import {
+ ArrowUp, ArrowDown, Rows3, Check, Filter, Search,
+ ChevronLeft, ChevronRight, EyeOff,
+} from 'lucide-react';
+import { Popover, PopoverContent, PopoverTrigger } from '@/components/ui/popover';
+import { cn } from '@/lib/utils';
+import {
+ OPS, columnLabel, coerceValue, isFilterable, isGroupable, isSortable,
+ optionsFor, ruleId, valueCounts,
+} from './fields';
+
+// The per-column header menu — one popover that owns everything you can do to
+// a column, so a toolbar stops being a parking lot of Sort/Columns/Group
+// buttons three clicks away from the column they act on:
+//
+// Sort A→Z / Z→A (low→high / high→low for numbers and dates)
+// Group by this field (enum + bool columns)
+// Filter by <label> (type-aware: checkbox list, or operator + value)
+// Move left / Move right
+// Hide this field
+//
+// The props are a FLAT, state-model-agnostic contract on purpose: <DataTable>
+// drives it from a `sorts[]` array + `hiddenKeys`, <DataGrid> drives it from a
+// single `cfg` object, and neither has to know about the other. Radix Popover
+// does the portalling and collision flipping, so a menu on the last column
+// needs none of the "align right when near the edge" guesswork.
+export function ColumnMenu({
+ column,
+ rows, // the UNFILTERED set — option counts must not collapse
+ // to zero as you tick boxes in this very menu
+ sortDir = null, // 'asc' | 'desc' | null — this column's current sort
+ grouped = false,
+ rule = null, // this column's active filter rule, if any
+ canMoveLeft = false,
+ canMoveRight = false,
+ canHide = true,
+ onSort,
+ onToggleGroup,
+ onPutRule,
+ onMove,
+ onHide,
+ open,
+ onOpenChange,
+}) {
+ const label = columnLabel(column);
+ const type = column.type;
+ const isEnumish = type === 'enum' || type === 'bool';
+ const filterable = isFilterable(column) && !!onPutRule;
+
+ const [draft, setDraft] = useState(
+ rule && !isEnumish ? String(rule.value ?? '') : '',
+ );
+
+ const ordered = type === 'num' || type === 'date';
+ const counts = isEnumish ? valueCounts(rows, column) : null;
+ const options = isEnumish ? optionsFor(rows, column) : [];
+ const picked = rule?.op === 'any' || rule?.op === 'none' ? rule.value : [];
+
+ const writeRule = (next) => onPutRule(column.key, next);
+
+ const toggleOption = (option) => {
+ if (type === 'bool') {
+ const on = rule && String(rule.value) === option;
+ writeRule(on ? null : {
+ id: rule?.id || ruleId(), field: column.key, op: 'is', value: option === 'true',
+ });
+ return;
+ }
+ const next = picked.includes(option)
+ ? picked.filter((v) => v !== option)
+ : [...picked, option];
+ writeRule(next.length ? {
+ id: rule?.id || ruleId(),
+ field: column.key,
+ op: rule?.op || 'any',
+ value: next,
+ } : null);
+ };
+
+ const writeValue = (raw, op) => {
+ setDraft(raw);
+ writeRule(raw === '' ? null : {
+ id: rule?.id || ruleId(),
+ field: column.key,
+ op: op || rule?.op || OPS[type][0][0],
+ value: coerceValue(type, raw),
+ });
+ };
+
+ const canSort = isSortable(column) && !!onSort;
+ const canGroup = isGroupable(column) && !!onToggleGroup;
+ const canMove = !!onMove && (canMoveLeft || canMoveRight);
+ const canHideHere = canHide && !!onHide && !column.locked && column.hideable !== false;
+
+ // Nothing to offer (a decorative column) — render no trigger at all rather
+ // than an empty popover.
+ if (!canSort && !canGroup && !filterable && !canMove && !canHideHere) return null;
+
+ return (
+ <Popover open={open} onOpenChange={onOpenChange}>
+ <PopoverTrigger asChild>
+ <button
+ type="button"
+ className="sk-colmenu-btn"
+ aria-label={`${label} column options`}
+ onClick={(e) => { e.stopPropagation(); }}
+ >
+ <span className="sk-colmenu-btn__dots" aria-hidden="true" />
+ </button>
+ </PopoverTrigger>
+ <PopoverContent
+ align="start"
+ sideOffset={6}
+ collisionPadding={12}
+ className="ui-popover-panel sk-gridmenu"
+ onClick={(e) => e.stopPropagation()}
+ >
+ {canSort && (
+ <>
+ <button
+ type="button"
+ className={cn('sk-gridmenu__opt', sortDir === 'asc' && 'is-on')}
+ onClick={() => { onSort(column.key, 'asc'); onOpenChange(false); }}
+ >
+ <ArrowUp size={13} />
+ {ordered ? 'Sort low to high' : 'Sort A to Z'}
+ </button>
+ <button
+ type="button"
+ className={cn('sk-gridmenu__opt', sortDir === 'desc' && 'is-on')}
+ onClick={() => { onSort(column.key, 'desc'); onOpenChange(false); }}
+ >
+ <ArrowDown size={13} />
+ {ordered ? 'Sort high to low' : 'Sort Z to A'}
+ </button>
+ </>
+ )}
+
+ {canGroup && (
+ <button
+ type="button"
+ className={cn('sk-gridmenu__opt', grouped && 'is-on')}
+ onClick={() => { onToggleGroup(column.key); onOpenChange(false); }}
+ >
+ <Rows3 size={13} />
+ {grouped ? 'Remove grouping' : 'Group by this field'}
+ </button>
+ )}
+
+ {filterable && (
+ <>
+ {(canSort || canGroup) && <div className="sk-gridmenu__sep" />}
+ <div className="sk-gridmenu__head">{`Filter by ${label}`}</div>
+
+ {isEnumish ? (
+ <div className="sk-gridmenu__scroll">
+ {type === 'enum' && (
+ <div className="sk-gridmenu__mini">
+ <select
+ value={rule?.op || 'any'}
+ onChange={(e) => rule && writeRule({ ...rule, op: e.target.value })}
+ aria-label={`${label} filter operator`}
+ >
+ {OPS.enum.map(([op, text]) => (
+ <option key={op} value={op}>{text}</option>
+ ))}
+ </select>
+ </div>
+ )}
+ {options.map((option) => {
+ const on = type === 'bool'
+ ? !!rule && String(rule.value) === option
+ : picked.includes(option);
+ const text = type === 'bool' ? (option === 'true' ? 'On' : 'Off') : option;
+ return (
+ <button
+ key={option}
+ type="button"
+ className={cn('sk-gridmenu__opt', on && 'is-on')}
+ onClick={() => toggleOption(option)}
+ aria-pressed={on}
+ >
+ <span className="sk-gridmenu__box"><Check size={11} /></span>
+ <span className="sk-gridmenu__val">{text}</span>
+ <span className="sk-gridmenu__rest">{counts.get(option) || 0}</span>
+ </button>
+ );
+ })}
+ </div>
+ ) : (
+ <>
+ <div className="sk-gridmenu__mini">
+ <select
+ value={rule?.op || OPS[type][0][0]}
+ onChange={(e) => writeValue(draft, e.target.value)}
+ aria-label={`${label} filter operator`}
+ >
+ {OPS[type].map(([op, text]) => (
+ <option key={op} value={op}>{text}</option>
+ ))}
+ </select>
+ </div>
+ <div className="sk-gridmenu__mini sk-gridmenu__mini--input">
+ {type === 'num' ? <Filter size={13} /> : <Search size={13} />}
+ <input
+ autoFocus
+ type={type === 'num' ? 'number' : type === 'date' ? 'date' : 'text'}
+ value={draft}
+ placeholder={type === 'num' ? 'value' : 'Enter value'}
+ aria-label={`${label} filter value`}
+ onChange={(e) => writeValue(e.target.value)}
+ />
+ </div>
+ {!!column.quick?.length && (
+ <div className="sk-gridmenu__quick">
+ {column.quick.map((q) => (
+ <button
+ key={q.label}
+ type="button"
+ onClick={() => writeValue(String(q.value), q.op)}
+ >
+ {q.label}
+ </button>
+ ))}
+ </div>
+ )}
+ </>
+ )}
+ </>
+ )}
+
+ {(canMove || canHideHere) && <div className="sk-gridmenu__sep" />}
+ {canMove && (
+ <>
+ <button
+ type="button"
+ className="sk-gridmenu__opt"
+ disabled={!canMoveLeft}
+ onClick={() => { onMove(column.key, -1); onOpenChange(false); }}
+ >
+ <ChevronLeft size={13} />Move left
+ </button>
+ <button
+ type="button"
+ className="sk-gridmenu__opt"
+ disabled={!canMoveRight}
+ onClick={() => { onMove(column.key, 1); onOpenChange(false); }}
+ >
+ <ChevronRight size={13} />Move right
+ </button>
+ </>
+ )}
+ {canHideHere && (
+ <button
+ type="button"
+ className="sk-gridmenu__opt"
+ onClick={() => { onHide(column.key); onOpenChange(false); }}
+ >
+ <EyeOff size={13} />Hide this field
+ </button>
+ )}
+
+ {filterable && (
+ <div className="sk-gridmenu__foot">
+ <button
+ type="button"
+ onClick={() => { writeRule(null); setDraft(''); }}
+ disabled={!rule}
+ >
+ Clear filter
+ </button>
+ <button type="button" className="is-primary" onClick={() => onOpenChange(false)}>
+ Done
+ </button>
+ </div>
+ )}
+ </PopoverContent>
+ </Popover>
+ );
+}
+
+export default ColumnMenu;
diff --git a/frontend/src/components/ds/grid/DataGrid.jsx b/frontend/src/components/ds/grid/DataGrid.jsx
new file mode 100644
index 00000000..354fa20e
--- /dev/null
+++ b/frontend/src/components/ds/grid/DataGrid.jsx
@@ -0,0 +1,250 @@
+import { useMemo, useRef, useState } from 'react';
+import { ArrowUp, ArrowDown, Check, ChevronDown, ChevronRight, Filter, Minus } from 'lucide-react';
+import { cn } from '@/lib/utils';
+import ColumnMenu from './ColumnMenu';
+import { byKey, columnLabel, fieldValue, isSortable } from './fields';
+
+// The grid itself: a CSS-grid table (NOT a <table>) whose header and rows share
+// one `--sk-grid-tpl` track list, so a column's width is declared once next to
+// the column and every row obeys it. That is what makes per-column reordering
+// and show/hide a pure data change — there is no <colgroup> to keep in sync.
+//
+// Everything user-facing hangs off the header cell: the label is the sort
+// toggle, and the "⋮" opens <ColumnMenu> (sort · group · filter · move · hide).
+export function DataGrid({
+ columns,
+ groups, // from useGridRows — [[groupLabel|null, rows], …]
+ allRows, // unfiltered, for the column menu's option counts
+ cfg,
+ grid, // the useGridConfig api
+ keyField = 'id',
+ selectable = false,
+ selectedKeys = [],
+ onToggleRow,
+ onToggleAll,
+ onRowClick,
+ onRowContextMenu,
+ rowActions,
+ rowLeading, // (row) => JSX rendered as the name-cell avatar/chip
+ empty,
+ footer,
+ className,
+}) {
+ const [openMenu, setOpenMenu] = useState(null);
+ const [collapsed, setCollapsed] = useState(() => new Set());
+ const lastIndex = useRef(null);
+
+ const map = useMemo(() => byKey(columns), [columns]);
+ const visible = useMemo(
+ () => cfg.cols.map((key) => map.get(key)).filter(Boolean),
+ [cfg.cols, map],
+ );
+ const lockedCount = useMemo(
+ () => visible.findIndex((c) => !c.locked) === -1 ? visible.length : visible.findIndex((c) => !c.locked),
+ [visible],
+ );
+
+ // "38px <col tracks> 44px" — checkbox gutter, the columns, row-end actions.
+ const tpl = useMemo(() => [
+ selectable ? '38px' : null,
+ ...visible.map((c) => c.width || 'minmax(120px,1fr)'),
+ rowActions ? '44px' : null,
+ ].filter(Boolean).join(' '), [visible, selectable, rowActions]);
+
+ const keyOf = (row) => (typeof keyField === 'function' ? keyField(row) : row[keyField]);
+ const flat = useMemo(
+ () => groups.flatMap(([label, rows]) => (collapsed.has(label) ? [] : rows)),
+ [groups, collapsed],
+ );
+ const picked = useMemo(() => new Set(selectedKeys), [selectedKeys]);
+ const allOn = flat.length > 0 && flat.every((r) => picked.has(keyOf(r)));
+ const someOn = !allOn && flat.some((r) => picked.has(keyOf(r)));
+
+ const toggleGroupOpen = (label) => setCollapsed((prev) => {
+ const next = new Set(prev);
+ if (next.has(label)) next.delete(label); else next.add(label);
+ return next;
+ });
+
+ // Shift-click extends the selection from the last row you touched — the
+ // behaviour every file manager has trained people to expect.
+ const handleRowCheck = (row, index, event) => {
+ const key = keyOf(row);
+ if (event.shiftKey && lastIndex.current != null) {
+ const [a, b] = [lastIndex.current, index].sort((x, y) => x - y);
+ onToggleAll?.(true, flat.slice(a, b + 1).map(keyOf));
+ } else {
+ onToggleRow?.(key, !picked.has(key));
+ }
+ lastIndex.current = index;
+ };
+
+ const headerSort = (column) => {
+ if (!isSortable(column)) return;
+ const active = cfg.sort.key === column.key;
+ grid.setSort(column.key, active && cfg.sort.dir === 'asc' ? 'desc' : 'asc');
+ };
+
+ return (
+ <div
+ className={cn('sk-grid', cfg.density === 'compact' && 'sk-grid--compact', className)}
+ style={{ '--sk-grid-tpl': tpl }}
+ >
+ <div className="sk-grid__head" role="row">
+ {selectable && (
+ <div
+ className="sk-grid__th sk-grid__check"
+ role="columnheader"
+ onClick={() => onToggleAll?.(!allOn, flat.map(keyOf))}
+ >
+ <span className={cn('sk-grid__box', allOn && 'is-on', someOn && 'is-part')}>
+ {allOn ? <Check size={11} /> : someOn ? <Minus size={11} /> : null}
+ </span>
+ </div>
+ )}
+
+ {visible.map((column, index) => {
+ const filtered = cfg.filters.rules.some((r) => r.field === column.key);
+ const sorted = cfg.sort.key === column.key;
+ return (
+ <div
+ key={column.key}
+ role="columnheader"
+ aria-sort={sorted ? (cfg.sort.dir === 'asc' ? 'ascending' : 'descending') : 'none'}
+ className={cn(
+ 'sk-grid__th',
+ filtered && 'is-filtered',
+ sorted && 'is-sorted',
+ column.align === 'right' && 'is-num',
+ isSortable(column) && 'is-sortable',
+ )}
+ onClick={() => headerSort(column)}
+ >
+ <span className="sk-grid__thlabel">{columnLabel(column)}</span>
+ {filtered && <Filter size={11} />}
+ {sorted && (
+ <span className="sk-grid__tharrow">
+ {cfg.sort.dir === 'desc' ? <ArrowDown size={11} /> : <ArrowUp size={11} />}
+ </span>
+ )}
+ <ColumnMenu
+ column={column}
+ rows={allRows}
+ sortDir={sorted ? cfg.sort.dir : null}
+ grouped={cfg.group === column.key}
+ rule={cfg.filters.rules.find((r) => r.field === column.key) || null}
+ canMoveLeft={index > lockedCount}
+ canMoveRight={index < visible.length - 1}
+ onSort={grid.setSort}
+ onToggleGroup={grid.toggleGroup}
+ onPutRule={grid.putColumnRule}
+ onMove={(key, delta) => grid.moveColumn(key, delta, lockedCount)}
+ onHide={grid.hideColumn}
+ open={openMenu === column.key}
+ onOpenChange={(open) => setOpenMenu(open ? column.key : null)}
+ />
+ </div>
+ );
+ })}
+
+ {rowActions && <div className="sk-grid__th" role="columnheader" />}
+ </div>
+
+ {flat.length === 0 && groups.every(([, rows]) => rows.length === 0)
+ ? <div className="sk-grid__empty">{empty}</div>
+ : groups.map(([label, rows]) => (
+ <div key={label ?? '__all__'} className="sk-grid__group-wrap">
+ {label != null && (
+ <button
+ type="button"
+ className="sk-grid__group"
+ onClick={() => toggleGroupOpen(label)}
+ aria-expanded={!collapsed.has(label)}
+ >
+ {collapsed.has(label) ? <ChevronRight size={12} /> : <ChevronDown size={12} />}
+ {label}
+ <i />
+ <span className="sk-grid__groupcount">{rows.length}</span>
+ </button>
+ )}
+ {(label != null && collapsed.has(label) ? [] : rows).map((row) => {
+ const key = keyOf(row);
+ const index = flat.indexOf(row);
+ const on = picked.has(key);
+ return (
+ <div
+ key={key}
+ role="row"
+ className={cn('sk-grid__row', on && 'is-picked', onRowClick && 'is-clickable')}
+ onClick={onRowClick ? () => onRowClick(row) : undefined}
+ onContextMenu={onRowContextMenu
+ ? (e) => { e.preventDefault(); onRowContextMenu(row, e); }
+ : undefined}
+ >
+ {selectable && (
+ <div
+ className="sk-grid__td sk-grid__check"
+ onClick={(e) => { e.stopPropagation(); handleRowCheck(row, index, e); }}
+ >
+ <span className={cn('sk-grid__box', on && 'is-on')}>
+ {on ? <Check size={11} /> : null}
+ </span>
+ </div>
+ )}
+ {visible.map((column, ci) => (
+ <div
+ key={column.key}
+ role="cell"
+ className={cn(
+ 'sk-grid__td',
+ column.align === 'right' && 'is-num',
+ column.cellClassName,
+ )}
+ >
+ {ci === 0 && (rowLeading || cfg.sub.length)
+ ? (
+ <div className="sk-grid__name">
+ {rowLeading && <span className="sk-grid__avatar">{rowLeading(row)}</span>}
+ <div className="sk-grid__nameinner">
+ <div className="sk-grid__nm">
+ {column.render ? column.render(row) : fieldValue(column, row)}
+ </div>
+ {!!cfg.sub.length && (
+ <div className="sk-grid__sub">
+ {cfg.sub.map((sk, si) => {
+ const sc = map.get(sk);
+ if (!sc) return null;
+ const v = fieldValue(sc, row);
+ return (
+ <span key={sk} className="sk-grid__subitem">
+ {si > 0 && <i />}
+ <b>{columnLabel(sc)}</b>
+ {sc.type === 'bool' ? (v ? 'on' : 'off') : String(v ?? '—')}
+ </span>
+ );
+ })}
+ </div>
+ )}
+ </div>
+ </div>
+ )
+ : (column.render ? column.render(row) : fieldValue(column, row))}
+ </div>
+ ))}
+ {rowActions && (
+ <div className="sk-grid__td sk-grid__rowend" onClick={(e) => e.stopPropagation()}>
+ {rowActions(row)}
+ </div>
+ )}
+ </div>
+ );
+ })}
+ </div>
+ ))}
+
+ {footer}
+ </div>
+ );
+}
+
+export default DataGrid;
diff --git a/frontend/src/components/ds/grid/GridBulkBar.jsx b/frontend/src/components/ds/grid/GridBulkBar.jsx
new file mode 100644
index 00000000..27c65197
--- /dev/null
+++ b/frontend/src/components/ds/grid/GridBulkBar.jsx
@@ -0,0 +1,25 @@
+import { X } from 'lucide-react';
+
+// The selection bar. Appears only when rows are picked, and holds the actions
+// that only make sense in bulk — so the per-row menu doesn't have to carry
+// "…and 40 others" variants of everything.
+//
+// <GridBulkBar count={picked.length} noun="domain" onClear={…}>
+// <button onClick={…}><RefreshCw size={13}/> Check DNS</button>
+// <button className="is-danger" onClick={…}><Trash2 size={13}/> Remove</button>
+// </GridBulkBar>
+export function GridBulkBar({ count, noun = 'row', onClear, children }) {
+ if (!count) return null;
+ return (
+ <div className="sk-gridbulk">
+ <span className="sk-gridbulk__count">{count}</span>
+ <span className="sk-gridbulk__label">{noun}{count === 1 ? '' : 's'} selected</span>
+ <div className="sk-gridbulk__acts">{children}</div>
+ <button type="button" className="sk-gridbulk__clear" onClick={onClear}>
+ <X size={13} /> Clear
+ </button>
+ </div>
+ );
+}
+
+export default GridBulkBar;
diff --git a/frontend/src/components/ds/grid/GridChips.jsx b/frontend/src/components/ds/grid/GridChips.jsx
new file mode 100644
index 00000000..8aae44de
--- /dev/null
+++ b/frontend/src/components/ds/grid/GridChips.jsx
@@ -0,0 +1,48 @@
+import { X } from 'lucide-react';
+import { byKey, columnLabel, opLabel, ruleText } from './fields';
+
+// Active filter rules, spelled out above the grid. A filter you cannot see is
+// a filter you will blame the data for — every rule gets a chip, and every chip
+// can be removed on its own.
+export function GridChips({ cfg, columns, onRemove, onClear, onMatchChange }) {
+ const rules = cfg.filters.rules;
+ if (!rules.length) return null;
+ const map = byKey(columns);
+
+ return (
+ <div className="sk-gridchips">
+ {rules.length > 1 && (
+ <button
+ type="button"
+ className="sk-gridchip sk-gridchip--match"
+ onClick={() => onMatchChange(cfg.filters.match === 'all' ? 'any' : 'all')}
+ title="Toggle whether rows must match every condition or any one"
+ >
+ match {cfg.filters.match}
+ </button>
+ )}
+ {rules.map((rule) => {
+ const column = map.get(rule.field);
+ if (!column) return null;
+ return (
+ <span key={rule.id} className="sk-gridchip">
+ <span className="sk-gridchip__k">{columnLabel(column)}</span>
+ <span className="sk-gridchip__op">{opLabel(column.type, rule.op)}</span>
+ <span className="sk-gridchip__v">{ruleText(rule, columns)}</span>
+ <button
+ type="button"
+ className="sk-gridchip__x"
+ onClick={() => onRemove(rule.id)}
+ aria-label={`Remove ${columnLabel(column)} filter`}
+ >
+ <X size={12} />
+ </button>
+ </span>
+ );
+ })}
+ <button type="button" className="sk-gridchips__clear" onClick={onClear}>Clear all</button>
+ </div>
+ );
+}
+
+export default GridChips;
diff --git a/frontend/src/components/ds/grid/GridFilterButton.jsx b/frontend/src/components/ds/grid/GridFilterButton.jsx
new file mode 100644
index 00000000..f0ffb8d4
--- /dev/null
+++ b/frontend/src/components/ds/grid/GridFilterButton.jsx
@@ -0,0 +1,22 @@
+import { SlidersHorizontal } from 'lucide-react';
+import { cn } from '@/lib/utils';
+
+// The top bar's filter affordance. Icon-only with a count badge so it occupies
+// the same width whether or not filters are active — the search field next to
+// it must not shift when you add a condition.
+export function GridFilterButton({ count = 0, onClick, title = 'Filters & fields (⌘F)' }) {
+ return (
+ <button
+ type="button"
+ className={cn('sk-gridicon', count > 0 && 'is-on')}
+ onClick={onClick}
+ title={title}
+ aria-label={title}
+ >
+ <SlidersHorizontal size={16} />
+ {count > 0 && <span className="sk-gridicon__count">{count}</span>}
+ </button>
+ );
+}
+
+export default GridFilterButton;
diff --git a/frontend/src/components/ds/grid/GridFilterDrawer.jsx b/frontend/src/components/ds/grid/GridFilterDrawer.jsx
new file mode 100644
index 00000000..414fa6fd
--- /dev/null
+++ b/frontend/src/components/ds/grid/GridFilterDrawer.jsx
@@ -0,0 +1,299 @@
+import { useState } from 'react';
+import { Filter, Layers, X, Plus, History, ChevronDown, GripVertical } from 'lucide-react';
+import { Drawer } from '../Drawer';
+import { Button } from '@/components/ui/button';
+import { Switch } from '@/components/ui/switch';
+import { cn } from '@/lib/utils';
+import {
+ OPS, byKey, columnLabel, coerceValue, emptyValueFor, fieldValue,
+ isFilterable, isSortable, optionsFor,
+} from './fields';
+
+// Two panes behind one drawer, because they are the two halves of "what am I
+// looking at": FILTERS decides which rows, FIELDS decides which columns (and in
+// what order, at what density, with which detail line). The header menu is the
+// fast path for one column; this is the whole picture at once.
+export function GridFilterDrawer({ open, onOpenChange, columns, rows, cfg, grid, noun = 'rows' }) {
+ const [tab, setTab] = useState('filters');
+ const [dragging, setDragging] = useState(null);
+
+ const map = byKey(columns);
+ const rules = cfg.filters.rules;
+ const filterable = columns.filter(isFilterable);
+
+ const patchRule = (id, patch) => grid.setRules(
+ rules.map((r) => (r.id === id ? { ...r, ...patch } : r)),
+ );
+
+ // Visible columns first (in their real order), then the hidden ones — so
+ // dragging inside the list and toggling a switch are the same mental model.
+ const ordered = [...cfg.cols, ...columns.map((c) => c.key).filter((k) => !cfg.cols.includes(k))];
+ const allKeys = columns.map((c) => c.key);
+
+ const moveTo = (from, to) => {
+ const list = [...ordered];
+ const [moved] = list.splice(from, 1);
+ list.splice(to, 0, moved);
+ grid.setColumnOrder(list.filter((k) => cfg.cols.includes(k)));
+ };
+
+ const valueEditor = (rule) => {
+ const column = map.get(rule.field);
+ if (!column) return null;
+ if (column.type === 'bool') {
+ return (
+ <div className="sk-gridrule__sel">
+ <select
+ value={String(rule.value)}
+ onChange={(e) => patchRule(rule.id, { value: e.target.value === 'true' })}
+ aria-label="Value"
+ >
+ <option value="true">On</option>
+ <option value="false">Off</option>
+ </select>
+ <ChevronDown size={13} />
+ </div>
+ );
+ }
+ if (column.type === 'enum') {
+ const selected = Array.isArray(rule.value) ? rule.value : [];
+ return (
+ <div className="sk-gridrule__enum">
+ {optionsFor(rows, column).map((option) => {
+ const on = selected.includes(option);
+ return (
+ <button
+ key={option}
+ type="button"
+ className={cn('sk-gridrule__tag', on && 'is-on')}
+ onClick={() => patchRule(rule.id, {
+ value: on ? selected.filter((v) => v !== option) : [...selected, option],
+ })}
+ >
+ {option}
+ </button>
+ );
+ })}
+ </div>
+ );
+ }
+ return (
+ <input
+ type={column.type === 'num' ? 'number' : column.type === 'date' ? 'date' : 'text'}
+ value={rule.value ?? ''}
+ placeholder="value"
+ aria-label="Value"
+ onChange={(e) => patchRule(rule.id, { value: coerceValue(column.type, e.target.value) })}
+ />
+ );
+ };
+
+ return (
+ <Drawer
+ open={open}
+ onOpenChange={onOpenChange}
+ title="Filters & fields"
+ subtitle={`${rules.length} condition${rules.length === 1 ? '' : 's'} · ${cfg.cols.length} fields shown`}
+ icon={<Filter size={18} />}
+ iconColor="var(--accent-bright)"
+ width={470}
+ flush
+ className="sk-griddrawer"
+ >
+ <div className="sk-griddrawer__tabs">
+ {[['filters', Filter, 'Filters', rules.length], ['fields', Layers, 'Fields', cfg.cols.length]]
+ .map(([key, Icon, text, n]) => (
+ <button
+ key={key}
+ type="button"
+ className={cn(tab === key && 'is-on')}
+ onClick={() => setTab(key)}
+ >
+ <Icon size={14} />{text}<span className="n">{n}</span>
+ </button>
+ ))}
+ </div>
+
+ <div className="sk-griddrawer__body">
+ {tab === 'filters' && (
+ <div className="sk-gridsec">
+ <div className="sk-gridsec__head">
+ <div className="sk-gridsec__t">Conditions</div>
+ <button type="button" className="sk-gridsec__add" onClick={() => grid.addRule(columns)}>
+ <Plus size={13} />Add condition
+ </button>
+ </div>
+
+ <div className="sk-gridmatch">
+ Match
+ <div className="sk-gridseg">
+ {['all', 'any'].map((value) => (
+ <button
+ key={value}
+ type="button"
+ className={cn(cfg.filters.match === value && 'is-on')}
+ onClick={() => grid.setMatch(value)}
+ >
+ {value}
+ </button>
+ ))}
+ </div>
+ of the following
+ </div>
+
+ {rules.length === 0 && (
+ <div className="sk-gridsec__none">
+ No conditions — this view shows every {noun.replace(/s$/, '')}.
+ </div>
+ )}
+
+ {rules.map((rule, i) => {
+ const column = map.get(rule.field);
+ if (!column) return null;
+ return (
+ <div key={rule.id}>
+ {i > 0 && (
+ <div className="sk-gridrule__join">
+ {cfg.filters.match === 'all' ? 'and' : 'or'}
+ </div>
+ )}
+ <div className="sk-gridrule">
+ <div className="sk-gridrule__sel">
+ <select
+ value={rule.field}
+ aria-label="Field"
+ onChange={(e) => {
+ const next = map.get(e.target.value);
+ patchRule(rule.id, {
+ field: next.key,
+ op: OPS[next.type][0][0],
+ value: emptyValueFor(next.type),
+ });
+ }}
+ >
+ {filterable.map((c) => (
+ <option key={c.key} value={c.key}>{columnLabel(c)}</option>
+ ))}
+ </select>
+ <ChevronDown size={13} />
+ </div>
+ <div className="sk-gridrule__sel">
+ <select
+ value={rule.op}
+ aria-label="Operator"
+ onChange={(e) => patchRule(rule.id, { op: e.target.value })}
+ >
+ {OPS[column.type].map(([op, text]) => (
+ <option key={op} value={op}>{text}</option>
+ ))}
+ </select>
+ <ChevronDown size={13} />
+ </div>
+ <button
+ type="button"
+ className="sk-gridrule__del"
+ onClick={() => grid.removeRule(rule.id)}
+ aria-label="Remove condition"
+ >
+ <X size={14} />
+ </button>
+ <div className="sk-gridrule__value">{valueEditor(rule)}</div>
+ </div>
+ </div>
+ );
+ })}
+ </div>
+ )}
+
+ {tab === 'fields' && (
+ <>
+ <div className="sk-gridsec">
+ <div className="sk-gridsec__head">
+ <div className="sk-gridsec__t">Fields · {cfg.cols.length} shown</div>
+ </div>
+ {ordered.map((key, i) => {
+ const column = map.get(key);
+ if (!column) return null;
+ const on = cfg.cols.includes(key);
+ const locked = !!column.locked || column.hideable === false;
+ return (
+ <div
+ key={key}
+ draggable={!locked && on}
+ className={cn('sk-gridcol', !on && 'is-off', dragging === i && 'is-drag')}
+ onDragStart={() => setDragging(i)}
+ onDragEnd={() => setDragging(null)}
+ onDragOver={(e) => {
+ e.preventDefault();
+ if (dragging != null && dragging !== i) { moveTo(dragging, i); setDragging(i); }
+ }}
+ >
+ <span className="sk-gridcol__grip"><GripVertical size={13} /></span>
+ <span className="sk-gridcol__nm">{columnLabel(column)}</span>
+ {locked
+ ? <span className="sk-gridcol__lock">pinned</span>
+ : (
+ <Switch
+ checked={on}
+ onCheckedChange={() => grid.toggleColumn(key, allKeys)}
+ aria-label={`Show ${columnLabel(column)}`}
+ />
+ )}
+ </div>
+ );
+ })}
+ </div>
+
+ <div className="sk-gridsec">
+ <div className="sk-gridsec__head"><div className="sk-gridsec__t">Row detail</div></div>
+ <p className="sk-gridsec__hint">Extra fields printed under the first column.</p>
+ <div className="sk-gridsec__tags">
+ {columns.filter((c) => !c.locked && isSortable(c)).map((c) => {
+ const on = cfg.sub.includes(c.key);
+ return (
+ <button
+ key={c.key}
+ type="button"
+ className={cn('sk-gridrule__tag', on && 'is-on')}
+ onClick={() => grid.setSub(
+ on ? cfg.sub.filter((k) => k !== c.key) : [...cfg.sub, c.key],
+ )}
+ >
+ {columnLabel(c)}
+ </button>
+ );
+ })}
+ </div>
+
+ <div className="sk-gridsec__head" style={{ marginTop: 18 }}>
+ <div className="sk-gridsec__t">Density</div>
+ </div>
+ <div className="sk-gridseg sk-gridseg--wide">
+ {[['cozy', 'Cozy'], ['compact', 'Compact']].map(([value, text]) => (
+ <button
+ key={value}
+ type="button"
+ className={cn(cfg.density === value && 'is-on')}
+ onClick={() => grid.setDensity(value)}
+ >
+ {text}
+ </button>
+ ))}
+ </div>
+ </div>
+ </>
+ )}
+ </div>
+
+ <div className="sk-griddrawer__foot">
+ <Button variant="ghost" size="sm" onClick={grid.resetToView}>
+ <History size={14} /> Reset
+ </Button>
+ <span className="sk-griddrawer__sp" />
+ <Button size="sm" onClick={() => onOpenChange(false)}>Done</Button>
+ </div>
+ </Drawer>
+ );
+}
+
+export default GridFilterDrawer;
diff --git a/frontend/src/components/ds/grid/GridFooter.jsx b/frontend/src/components/ds/grid/GridFooter.jsx
new file mode 100644
index 00000000..9bbea015
--- /dev/null
+++ b/frontend/src/components/ds/grid/GridFooter.jsx
@@ -0,0 +1,62 @@
+import { ChevronDown, ChevronsLeft, ChevronsRight, ChevronLeft, ChevronRight } from 'lucide-react';
+import { byKey, columnLabel } from './fields';
+
+// Footer: what you are looking at on the left, how to page through it on the
+// right. The sort/group summary is here rather than in a toolbar chip because
+// it answers a question you only ask while reading the rows.
+export function GridFooter({
+ from, to, total, noun = 'rows', cfg, columns,
+ page, pageCount, perPage, onPage, onPerPage,
+}) {
+ const map = byKey(columns);
+ const sortCol = cfg.sort.key ? map.get(cfg.sort.key) : null;
+ const groupCol = cfg.group ? map.get(cfg.group) : null;
+
+ return (
+ <div className="sk-gridfoot">
+ <span>{total ? `${from}–${to} of ${total}` : '0'} {noun}</span>
+ {sortCol && (
+ <>
+ <span>·</span>
+ <span>sorted by {columnLabel(sortCol)} {cfg.sort.dir === 'asc' ? '↑' : '↓'}</span>
+ </>
+ )}
+ {groupCol && (
+ <>
+ <span>·</span>
+ <span>grouped by {columnLabel(groupCol)}</span>
+ </>
+ )}
+ <span className="sk-gridfoot__sp" />
+ <div className="sk-gridpager">
+ <span className="sk-gridpager__label">Rows</span>
+ <div className="sk-gridpager__sel">
+ <select
+ value={perPage}
+ onChange={(e) => onPerPage(e.target.value === 'all' ? 'all' : Number(e.target.value))}
+ aria-label="Rows per page"
+ >
+ {[10, 25, 50, 100].map((n) => <option key={n} value={n}>{n}</option>)}
+ <option value="all">All</option>
+ </select>
+ <ChevronDown size={12} />
+ </div>
+ <button type="button" disabled={page <= 1} onClick={() => onPage(1)} aria-label="First page">
+ <ChevronsLeft size={13} />
+ </button>
+ <button type="button" disabled={page <= 1} onClick={() => onPage(page - 1)} aria-label="Previous page">
+ <ChevronLeft size={14} />
+ </button>
+ <span className="sk-gridpager__pos">{page} / {pageCount}</span>
+ <button type="button" disabled={page >= pageCount} onClick={() => onPage(page + 1)} aria-label="Next page">
+ <ChevronRight size={14} />
+ </button>
+ <button type="button" disabled={page >= pageCount} onClick={() => onPage(pageCount)} aria-label="Last page">
+ <ChevronsRight size={13} />
+ </button>
+ </div>
+ </div>
+ );
+}
+
+export default GridFooter;
diff --git a/frontend/src/components/ds/grid/GridToolsMenu.jsx b/frontend/src/components/ds/grid/GridToolsMenu.jsx
new file mode 100644
index 00000000..3264ed47
--- /dev/null
+++ b/frontend/src/components/ds/grid/GridToolsMenu.jsx
@@ -0,0 +1,127 @@
+import { useState } from 'react';
+import { MoreVertical, Download, RefreshCw, History, Check, Rows2, Rows3 } from 'lucide-react';
+import { Popover, PopoverContent, PopoverTrigger } from '@/components/ui/popover';
+import { cn } from '@/lib/utils';
+import { byKey, exportRows } from './fields';
+
+// The toolbar's "⋮" — everything that is neither a filter nor a per-column
+// action: export, refresh, row density, and discarding unsaved view changes.
+// One button instead of four keeps the top bar the same shape on every page,
+// which is the whole point of putting search there.
+export function GridToolsMenu({
+ cfg, columns, rows, selectedRows, viewName, noun = 'rows',
+ onRefresh, onReset, onDensity, onExported,
+}) {
+ const [open, setOpen] = useState(false);
+ const [pane, setPane] = useState('root'); // root | export
+ const [scope, setScope] = useState('view');
+ const [allCols, setAllCols] = useState(false);
+
+ const map = byKey(columns);
+ const set = scope === 'picked' ? selectedRows : rows;
+ const exportCols = allCols ? columns : cfg.cols.map((k) => map.get(k)).filter(Boolean);
+
+ const close = () => { setOpen(false); setPane('root'); };
+
+ const go = (format) => {
+ const n = exportRows(
+ set,
+ exportCols,
+ format,
+ (viewName || noun).toLowerCase().replace(/\s+/g, '-'),
+ );
+ onExported?.(n, exportCols.length, format);
+ close();
+ };
+
+ return (
+ <Popover
+ open={open}
+ onOpenChange={(o) => { setOpen(o); if (!o) setPane('root'); }}
+ >
+ <PopoverTrigger asChild>
+ <button type="button" className="sk-gridicon" aria-label="More table options">
+ <MoreVertical size={16} />
+ </button>
+ </PopoverTrigger>
+ <PopoverContent align="end" sideOffset={6} className="ui-popover-panel sk-gridmenu">
+ {pane === 'root' ? (
+ <>
+ <button type="button" className="sk-gridmenu__opt" onClick={() => setPane('export')}>
+ <Download size={13} />Export…
+ </button>
+ {onRefresh && (
+ <button
+ type="button"
+ className="sk-gridmenu__opt"
+ onClick={() => { onRefresh(); close(); }}
+ >
+ <RefreshCw size={13} />Refresh data
+ </button>
+ )}
+ <div className="sk-gridmenu__sep" />
+ <div className="sk-gridmenu__head">Row density</div>
+ {[['cozy', 'Cozy', Rows2], ['compact', 'Compact', Rows3]].map(([value, text, Icon]) => (
+ <button
+ key={value}
+ type="button"
+ className={cn('sk-gridmenu__opt', cfg.density === value && 'is-on')}
+ onClick={() => onDensity(value)}
+ >
+ <span className="sk-gridmenu__box"><Check size={11} /></span>
+ <Icon size={13} />{text}
+ </button>
+ ))}
+ <div className="sk-gridmenu__sep" />
+ <button
+ type="button"
+ className="sk-gridmenu__opt"
+ onClick={() => { onReset(); close(); }}
+ >
+ <History size={13} />Reset view changes
+ </button>
+ </>
+ ) : (
+ <>
+ <div className="sk-gridmenu__head">Export</div>
+ <button
+ type="button"
+ className={cn('sk-gridmenu__opt', scope === 'view' && 'is-on')}
+ onClick={() => setScope('view')}
+ >
+ <span className="sk-gridmenu__box"><Check size={11} /></span>
+ Rows in this view
+ <span className="sk-gridmenu__rest">{rows.length}</span>
+ </button>
+ <button
+ type="button"
+ className={cn('sk-gridmenu__opt', scope === 'picked' && 'is-on')}
+ disabled={!selectedRows.length}
+ onClick={() => setScope('picked')}
+ >
+ <span className="sk-gridmenu__box"><Check size={11} /></span>
+ Selected rows
+ <span className="sk-gridmenu__rest">{selectedRows.length}</span>
+ </button>
+ <div className="sk-gridmenu__sep" />
+ <button
+ type="button"
+ className={cn('sk-gridmenu__opt', allCols && 'is-on')}
+ onClick={() => setAllCols((v) => !v)}
+ >
+ <span className="sk-gridmenu__box"><Check size={11} /></span>
+ Include hidden fields
+ <span className="sk-gridmenu__rest">{exportCols.length}</span>
+ </button>
+ <div className="sk-gridmenu__foot">
+ <button type="button" onClick={() => go('json')}>JSON</button>
+ <button type="button" className="is-primary" onClick={() => go('csv')}>Download CSV</button>
+ </div>
+ </>
+ )}
+ </PopoverContent>
+ </Popover>
+ );
+}
+
+export default GridToolsMenu;
diff --git a/frontend/src/components/ds/grid/GridViewPicker.jsx b/frontend/src/components/ds/grid/GridViewPicker.jsx
new file mode 100644
index 00000000..dcbd6ac1
--- /dev/null
+++ b/frontend/src/components/ds/grid/GridViewPicker.jsx
@@ -0,0 +1,172 @@
+import { useState } from 'react';
+import {
+ ChevronDown, Star, Copy, Trash2, Plus, MoreVertical, Check, History, AlertTriangle,
+} from 'lucide-react';
+import { Popover, PopoverContent, PopoverTrigger } from '@/components/ui/popover';
+import { cn } from '@/lib/utils';
+
+// The saved-view selector, rendered as the page's own heading rather than yet
+// another toolbar button — the view IS what you are looking at, so its name is
+// the largest thing on the page and clicking it swaps the whole grid config.
+//
+// Built-in views ship in code; "My views" are the user's own, persisted through
+// /api/v1/views by useTableViews. A modified view shows an asterisk plus an
+// inline Save / Reset strip, so tweaking a built-in never silently destroys it.
+export function GridViewPicker({ views, counts, onCreate, label = 'items', total }) {
+ const [open, setOpen] = useState(false);
+ const [menuFor, setMenuFor] = useState(null);
+ const [creating, setCreating] = useState(false);
+ const [name, setName] = useState('');
+ const [fromCurrent, setFromCurrent] = useState(true);
+
+ const active = views.activeView;
+ const activeName = active?.name || `All ${label}`;
+ const builtins = views.builtinViews || [];
+ const mine = views.userViews || [];
+
+ const pick = (view) => { views.applyView(view); setOpen(false); setMenuFor(null); };
+
+ const submitNew = () => {
+ if (!name.trim()) return;
+ onCreate(name.trim(), fromCurrent);
+ setName('');
+ setCreating(false);
+ setOpen(false);
+ };
+
+ const renderRow = (view) => {
+ const key = view.builtin ? `builtin:${view.name}` : `user:${view.id}`;
+ const isActive = active && (active.builtin ? active.name === view.name : active.id === view.id);
+ return (
+ <div key={key} className={cn('sk-viewpick__row', isActive && 'is-on')}>
+ <button type="button" className="sk-viewpick__rowmain" onClick={() => pick(view)}>
+ <span className="sk-viewpick__dot" data-builtin={view.builtin ? 'true' : 'false'} />
+ <span className="sk-viewpick__nm">{view.name}</span>
+ {view.is_default && <Star size={11} className="sk-viewpick__star" />}
+ {counts && <span className="sk-viewpick__n">{counts(view)}</span>}
+ </button>
+ {!view.builtin && (
+ <Popover
+ open={menuFor === key}
+ onOpenChange={(o) => setMenuFor(o ? key : null)}
+ >
+ <PopoverTrigger asChild>
+ <button type="button" className="sk-viewpick__cog" aria-label={`${view.name} options`}>
+ <MoreVertical size={14} />
+ </button>
+ </PopoverTrigger>
+ <PopoverContent align="end" sideOffset={4} className="ui-popover-panel sk-gridmenu">
+ <button
+ type="button"
+ className="sk-gridmenu__opt"
+ onClick={() => { views.toggleDefault(view); setMenuFor(null); }}
+ >
+ <Star size={13} />{view.is_default ? 'Unset as default' : 'Make default'}
+ </button>
+ <button
+ type="button"
+ className="sk-gridmenu__opt"
+ onClick={() => { pick(view); onCreate(`${view.name} copy`, true); setMenuFor(null); }}
+ >
+ <Copy size={13} />Duplicate view
+ </button>
+ <div className="sk-gridmenu__sep" />
+ <button
+ type="button"
+ className="sk-gridmenu__opt is-danger"
+ onClick={() => { views.removeView(view); setMenuFor(null); }}
+ >
+ <Trash2 size={13} />Delete view
+ </button>
+ </PopoverContent>
+ </Popover>
+ )}
+ </div>
+ );
+ };
+
+ return (
+ <div className="sk-viewbar">
+ <Popover open={open} onOpenChange={setOpen}>
+ <PopoverTrigger asChild>
+ <button type="button" className={cn('sk-viewpick', open && 'is-open')}>
+ <span className="sk-viewpick__title">{activeName}</span>
+ {views.isDirty && <span className="sk-viewpick__ast">*</span>}
+ <ChevronDown size={16} />
+ </button>
+ </PopoverTrigger>
+ <PopoverContent align="start" sideOffset={6} className="ui-popover-panel sk-gridmenu sk-viewpick__menu">
+ {!!builtins.length && <div className="sk-gridmenu__head">Built in</div>}
+ {builtins.map(renderRow)}
+ <div className="sk-gridmenu__head">My views</div>
+ {mine.length ? mine.map(renderRow) : (
+ <div className="sk-gridmenu__note">
+ No personal views yet — tune the grid, then save it here.
+ </div>
+ )}
+ <div className="sk-gridmenu__sep" />
+ {creating ? (
+ <>
+ <div className="sk-gridmenu__mini sk-gridmenu__mini--input">
+ <input
+ autoFocus
+ value={name}
+ placeholder="e.g. Cloudflare prod"
+ onChange={(e) => setName(e.target.value)}
+ onKeyDown={(e) => {
+ if (e.key === 'Enter') submitNew();
+ if (e.key === 'Escape') setCreating(false);
+ }}
+ />
+ </div>
+ <button
+ type="button"
+ className={cn('sk-gridmenu__opt', fromCurrent && 'is-on')}
+ onClick={() => setFromCurrent((v) => !v)}
+ >
+ <span className="sk-gridmenu__box"><Check size={11} /></span>
+ Start from current filters &amp; columns
+ </button>
+ <div className="sk-gridmenu__foot">
+ <button type="button" onClick={() => setCreating(false)}>Cancel</button>
+ <button type="button" className="is-primary" disabled={!name.trim()} onClick={submitNew}>
+ Create
+ </button>
+ </div>
+ </>
+ ) : (
+ <button type="button" className="sk-gridmenu__opt" onClick={() => setCreating(true)}>
+ <Plus size={13} />Save current view…
+ </button>
+ )}
+ </PopoverContent>
+ </Popover>
+
+ {total != null && (
+ <span className="sk-viewbar__count">{total}</span>
+ )}
+
+ {views.isDirty && (
+ <div className="sk-viewbar__dirty">
+ <AlertTriangle size={13} />
+ Unsaved
+ <button type="button" onClick={views.resetView}>
+ <History size={12} />Reset
+ </button>
+ <button
+ type="button"
+ className="is-primary"
+ onClick={() => {
+ if (active && !active.builtin) views.updateActiveView();
+ else setOpen(true);
+ }}
+ >
+ {active && !active.builtin ? 'Save' : 'Save as…'}
+ </button>
+ </div>
+ )}
+ </div>
+ );
+}
+
+export default GridViewPicker;
diff --git a/frontend/src/components/ds/grid/fields.js b/frontend/src/components/ds/grid/fields.js
new file mode 100644
index 00000000..7b45d62a
--- /dev/null
+++ b/frontend/src/components/ds/grid/fields.js
@@ -0,0 +1,317 @@
+// DataGrid field model + filter-rule engine.
+//
+// A grid column is a superset of the legacy DataTable column descriptor, so a
+// column list can be moved from one to the other. The extra keys are what let
+// the per-column header menu build itself:
+//
+// {
+// key: 'ssl',
+// header: 'SSL', // plain-text label (menus need a string)
+// type: 'enum', // text | enum | num | bool | date
+// width: 'minmax(140px,1fr)', // a CSS grid track, not a px number
+// value: (row) => row.ssl.state, // raw value: sorts, filters, groups, exports
+// render: (row) => <Pill…/>, // cell JSX (defaults to the raw value)
+// enumOrder: ['valid','expiring','none'], // menu order for enums, else A-Z
+// unit: 'd', // suffix shown on numeric chips
+// quick: [{ op:'lt', value:30, label:'under 30' }], // one-tap numeric filters
+// locked: true, // never hidden, never leaves slot 0
+// hideable / sortable / filterable / groupable // explicit opt-out
+// align: 'right',
+// }
+//
+// `type` is the only new required-ish key: it picks the operator set and the
+// filter UI. A column without one is still sortable and still renders — it just
+// doesn't offer filtering.
+
+export const FIELD_TYPES = ['text', 'enum', 'num', 'bool', 'date'];
+
+// Operator sets per type: [op, label]. Order matters — first is the default.
+export const OPS = {
+ text: [
+ ['contains', 'contains'],
+ ['ncontains', 'does not contain'],
+ ['is', 'is'],
+ ['starts', 'starts with'],
+ ],
+ enum: [
+ ['any', 'is any of'],
+ ['none', 'is none of'],
+ ],
+ num: [
+ ['lt', 'is under'],
+ ['gt', 'is over'],
+ ['eq', 'equals'],
+ ],
+ date: [
+ ['before', 'is before'],
+ ['after', 'is after'],
+ ],
+ bool: [
+ ['is', 'is'],
+ ],
+};
+
+export const opLabel = (type, op) => (OPS[type] || []).find(([o]) => o === op)?.[1] ?? op;
+
+let seq = 0;
+export const ruleId = () => `r${(seq += 1)}${Math.random().toString(36).slice(2, 6)}`;
+
+// ---------------------------------------------------------------- column API
+
+export const columnLabel = (column) => (
+ typeof column?.header === 'string' && column.header ? column.header : column?.key ?? ''
+);
+
+// The raw value behind a cell. `value` is the grid name; `sortValue` is
+// accepted so legacy DataTable column lists keep working unchanged.
+export function fieldValue(column, row) {
+ if (!column) return undefined;
+ if (typeof column.value === 'function') return column.value(row);
+ if (typeof column.sortValue === 'function') return column.sortValue(row);
+ return row?.[column.key];
+}
+
+export const isFilterable = (c) => c?.filterable !== false && FIELD_TYPES.includes(c?.type);
+
+// An action / chevron column: no label and nothing to sort. 31 of the app's
+// 275 column descriptors are these, and a header menu on one is meaningless.
+export const isDecorative = (c) => (
+ !c || (typeof c.header === 'string' && c.header.trim() === '' && c.sortable !== true)
+);
+
+const ISO_DATE = /^\d{4}-\d{2}-\d{2}([T ]|$)/;
+
+// Guess a column's filter type from the data when it doesn't declare one.
+//
+// This is what makes the header menu work on the ~50 tables in the app that
+// were written before types existed: they get filtering for free, and a page
+// that cares can override by declaring `type` explicitly. Deliberately
+// conservative — an unrecognised shape stays `text`, which offers
+// contains/is/starts-with and is never wrong, just less specific.
+export function inferColumnType(column, rows) {
+ if (column.type) return column.type;
+ if (column.filterable === false || isDecorative(column)) return null;
+
+ const sample = [];
+ for (const row of rows) {
+ const v = fieldValue(column, row);
+ if (v != null && v !== '') sample.push(v);
+ if (sample.length >= 60) break;
+ }
+ if (!sample.length) return 'text';
+
+ if (sample.every((v) => typeof v === 'boolean')) return 'bool';
+ if (sample.every((v) => typeof v === 'number' && Number.isFinite(v))) return 'num';
+ if (sample.every((v) => v instanceof Date || (typeof v === 'string' && ISO_DATE.test(v)))) return 'date';
+
+ if (sample.every((v) => typeof v === 'string')) {
+ const distinct = new Set(sample);
+ // Low-cardinality strings are statuses, kinds, owners — the things you
+ // pick from a list. High-cardinality ones are names and paths, which
+ // you type a fragment of. The test is "values repeat", with a hard cap
+ // so a 40-value column never becomes an unusable checklist. The ratio
+ // has to stay loose enough for SMALL tables: a 5-row table with 3
+ // statuses is still obviously a pick-list, and a stricter ratio
+ // silently downgraded every short table in the app to plain text.
+ if (distinct.size <= 12 && distinct.size <= sample.length * 0.8) return 'enum';
+ }
+ return 'text';
+}
+
+// Column list with inferred types filled in. Memoise at the call site: it
+// walks the data.
+export function withInferredTypes(columns, rows) {
+ return columns.map((c) => {
+ const type = inferColumnType(c, rows);
+ return type && type !== c.type ? { ...c, type } : c;
+ });
+}
+export const isGroupable = (c) => (
+ c?.groupable !== undefined ? !!c.groupable : c?.type === 'enum' || c?.type === 'bool'
+);
+export const isSortable = (c) => c?.sortable !== false;
+export const isHideable = (c) => c?.hideable !== false && !c?.locked;
+
+export const byKey = (columns) => {
+ const map = new Map();
+ for (const c of columns || []) map.set(c.key, c);
+ return map;
+};
+
+// ---------------------------------------------------------------- rule engine
+
+const asText = (v) => String(v ?? '').toLowerCase();
+const asTime = (v) => {
+ if (v == null || v === '') return null;
+ const t = v instanceof Date ? v.getTime() : new Date(v).getTime();
+ return Number.isNaN(t) ? null : t;
+};
+
+export function ruleMatches(row, rule, columns) {
+ const column = columns.get(rule.field);
+ if (!column) return true;
+ const value = fieldValue(column, row);
+
+ switch (rule.op) {
+ case 'contains': return asText(value).includes(asText(rule.value));
+ case 'ncontains': return !asText(value).includes(asText(rule.value));
+ case 'starts': return asText(value).startsWith(asText(rule.value));
+ case 'is':
+ return column.type === 'bool'
+ ? !!value === (rule.value === true || rule.value === 'true')
+ : asText(value) === asText(rule.value);
+ case 'any': return !rule.value?.length || rule.value.includes(String(value));
+ case 'none': return !rule.value?.length || !rule.value.includes(String(value));
+ case 'lt': return Number(value) < Number(rule.value);
+ case 'gt': return Number(value) > Number(rule.value);
+ case 'eq': return Number(value) === Number(rule.value);
+ case 'before': {
+ const a = asTime(value); const b = asTime(rule.value);
+ return a != null && b != null && a < b;
+ }
+ case 'after': {
+ const a = asTime(value); const b = asTime(rule.value);
+ return a != null && b != null && a > b;
+ }
+ default: return true;
+ }
+}
+
+// A rule with no value yet (a half-typed condition) must not filter anything
+// out — otherwise the table blanks the moment you add a condition row.
+export const ruleIsArmed = (rule) => !!rule?.field && !!rule?.op && (
+ Array.isArray(rule.value) ? rule.value.length > 0 : rule.value !== '' && rule.value != null
+);
+
+export function applyFilters(rows, filters, columns) {
+ const armed = (filters?.rules || []).filter(ruleIsArmed);
+ if (!armed.length) return rows;
+ const map = byKey(columns);
+ const test = filters.match === 'any'
+ ? (row) => armed.some((r) => ruleMatches(row, r, map))
+ : (row) => armed.every((r) => ruleMatches(row, r, map));
+ return rows.filter(test);
+}
+
+// Short human text for a filter chip: "valid, expiring +2", "30d", "on".
+export function ruleText(rule, columns) {
+ const column = byKey(columns).get(rule.field);
+ if (!column) return '';
+ if (column.type === 'bool') return rule.value === true || rule.value === 'true' ? 'on' : 'off';
+ if (Array.isArray(rule.value)) {
+ return rule.value.length > 2
+ ? `${rule.value.slice(0, 2).join(', ')} +${rule.value.length - 2}`
+ : rule.value.join(', ');
+ }
+ return String(rule.value) + (column.type === 'num' && column.unit ? column.unit : '');
+}
+
+// The blank value a freshly added rule of this type should start from.
+export function emptyValueFor(type) {
+ if (type === 'enum') return [];
+ if (type === 'bool') return true;
+ if (type === 'num') return '';
+ return '';
+}
+
+export function coerceValue(type, raw) {
+ if (type === 'num') return raw === '' ? '' : Number(raw);
+ if (type === 'bool') return raw === true || raw === 'true';
+ return raw;
+}
+
+// ---------------------------------------------------------------- sort / group
+
+export function applySort(rows, sort, columns) {
+ if (!sort?.key) return rows;
+ const column = byKey(columns).get(sort.key);
+ if (!column) return rows;
+ const dir = sort.dir === 'desc' ? -1 : 1;
+ const numeric = column.type === 'num';
+ const temporal = column.type === 'date';
+
+ return [...rows].sort((a, b) => {
+ const av = fieldValue(column, a);
+ const bv = fieldValue(column, b);
+ // Nulls always sink, regardless of direction — an empty cell is never
+ // "the most urgent row" just because you flipped the arrow.
+ const aNull = av == null || av === '';
+ const bNull = bv == null || bv === '';
+ if (aNull && bNull) return 0;
+ if (aNull) return 1;
+ if (bNull) return -1;
+ if (numeric) return (Number(av) - Number(bv)) * dir;
+ if (temporal) return ((asTime(av) ?? 0) - (asTime(bv) ?? 0)) * dir;
+ return String(av).localeCompare(String(bv)) * dir;
+ });
+}
+
+export function groupRows(rows, groupKey, columns) {
+ if (!groupKey) return [[null, rows]];
+ const column = byKey(columns).get(groupKey);
+ if (!column) return [[null, rows]];
+ const buckets = new Map();
+ for (const row of rows) {
+ const raw = fieldValue(column, row);
+ const label = column.type === 'bool'
+ ? (raw ? 'on' : 'off')
+ : String(raw ?? '—');
+ if (!buckets.has(label)) buckets.set(label, []);
+ buckets.get(label).push(row);
+ }
+ return [...buckets.entries()];
+}
+
+// Distinct values of an enum/bool column with row counts — powers the
+// checkbox list in the column menu.
+export function valueCounts(rows, column) {
+ const counts = new Map();
+ for (const row of rows) {
+ const key = String(fieldValue(column, row));
+ counts.set(key, (counts.get(key) || 0) + 1);
+ }
+ return counts;
+}
+
+export function optionsFor(rows, column) {
+ if (column.type === 'bool') return ['true', 'false'];
+ if (column.enumOrder) return column.enumOrder;
+ return [...valueCounts(rows, column).keys()].sort();
+}
+
+// ---------------------------------------------------------------- export
+
+function exportCell(column, row) {
+ const value = fieldValue(column, row);
+ if (column.type === 'bool') return value ? 'yes' : 'no';
+ return value == null ? '' : String(value);
+}
+
+const csvEscape = (s) => (/[",\n]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s);
+
+export function exportRows(rows, columns, format, filename) {
+ let body; let mime; let ext;
+ if (format === 'json') {
+ body = JSON.stringify(
+ rows.map((row) => Object.fromEntries(columns.map((c) => [c.key, fieldValue(c, row)]))),
+ null,
+ 2,
+ );
+ mime = 'application/json';
+ ext = 'json';
+ } else {
+ body = [
+ columns.map((c) => csvEscape(columnLabel(c))).join(','),
+ ...rows.map((row) => columns.map((c) => csvEscape(exportCell(c, row))).join(',')),
+ ].join('\n');
+ mime = 'text/csv';
+ ext = 'csv';
+ }
+ const url = URL.createObjectURL(new Blob([body], { type: mime }));
+ const a = document.createElement('a');
+ a.href = url;
+ a.download = `${filename || 'export'}.${ext}`;
+ a.click();
+ setTimeout(() => URL.revokeObjectURL(url), 2000);
+ return rows.length;
+}
diff --git a/frontend/src/components/ds/grid/index.js b/frontend/src/components/ds/grid/index.js
new file mode 100644
index 00000000..3991d97d
--- /dev/null
+++ b/frontend/src/components/ds/grid/index.js
@@ -0,0 +1,24 @@
+// DataGrid — the list surface for pages that need real table work: per-column
+// menus (sort · group · filter · move · hide), saved views, a filter drawer,
+// bulk selection, grouping, density and export.
+//
+// It does NOT replace ds/DataTable. DataTable stays the right answer for the
+// ~50 short, read-only tables in the app; DataGrid is for the handful of pages
+// where the table IS the page. Column descriptors are a superset of
+// DataTable's, so moving one up is additive (add `type` and `width`).
+export { DataGrid } from './DataGrid';
+export { ColumnMenu } from './ColumnMenu';
+export { GridViewPicker } from './GridViewPicker';
+export { GridChips } from './GridChips';
+export { GridBulkBar } from './GridBulkBar';
+export { GridFooter } from './GridFooter';
+export { GridToolsMenu } from './GridToolsMenu';
+export { GridFilterDrawer } from './GridFilterDrawer';
+export { GridFilterButton } from './GridFilterButton';
+export { useGridConfig, makeGridConfig, GRID_DEFAULTS } from './useGridConfig';
+export { useGridRows } from './useGridRows';
+export {
+ OPS, FIELD_TYPES, opLabel, ruleId, columnLabel, fieldValue,
+ applyFilters, applySort, groupRows, ruleText, exportRows,
+ isFilterable, isGroupable, isSortable, isHideable, optionsFor, valueCounts,
+} from './fields';
diff --git a/frontend/src/components/ds/grid/useGridConfig.js b/frontend/src/components/ds/grid/useGridConfig.js
new file mode 100644
index 00000000..d67ae13b
--- /dev/null
+++ b/frontend/src/components/ds/grid/useGridConfig.js
@@ -0,0 +1,201 @@
+import { useCallback, useMemo, useState } from 'react';
+import useTableViews from '@/hooks/useTableViews';
+import { emptyValueFor, isFilterable, OPS, ruleId } from './fields';
+
+// The whole of a grid's chrome is ONE serialisable object, so a saved view is
+// just a snapshot of it and "dirty" is a deep-equal away:
+//
+// {
+// cols: ['name','site','ssl'], // visible columns, IN ORDER
+// sort: { key:'name', dir:'asc' },
+// group: null, // column key or null
+// filters: { match:'all', rules:[…] },
+// density: 'cozy' | 'compact',
+// sub: ['registrar'], // fields printed under the name cell
+// }
+//
+// Column ORDER lives in `cols` — that is what makes "move left / move right"
+// in the header menu a one-line splice instead of a separate ordering system.
+
+export const GRID_DEFAULTS = {
+ cols: [],
+ sort: { key: null, dir: 'asc' },
+ group: null,
+ filters: { match: 'all', rules: [] },
+ density: 'cozy',
+ sub: [],
+};
+
+export function makeGridConfig(partial = {}) {
+ return {
+ ...GRID_DEFAULTS,
+ ...partial,
+ sort: { ...GRID_DEFAULTS.sort, ...(partial.sort || {}) },
+ filters: { ...GRID_DEFAULTS.filters, ...(partial.filters || {}) },
+ cols: [...(partial.cols || GRID_DEFAULTS.cols)],
+ sub: [...(partial.sub || GRID_DEFAULTS.sub)],
+ };
+}
+
+const clone = (o) => JSON.parse(JSON.stringify(o));
+
+/**
+ * Grid chrome state + saved views for one list page.
+ *
+ * const grid = useGridConfig({
+ * page: 'domains', // server-side saved-view bucket
+ * columns: domainColumns,
+ * initial: { cols: ['name','ssl'], sort: { key:'name', dir:'asc' } },
+ * builtinViews: [{ name:'SSL expiring', state: {…} }],
+ * });
+ */
+export function useGridConfig({ page, columns, initial, builtinViews = [] }) {
+ const base = useMemo(
+ () => makeGridConfig({
+ cols: columns.filter((c) => c.defaultVisible !== false).map((c) => c.key),
+ ...initial,
+ }),
+ // Recomputing on every columns identity change would stomp user edits;
+ // the initial config is a mount-time concern only.
+ // eslint-disable-next-line react-hooks/exhaustive-deps
+ [],
+ );
+
+ const [cfg, setCfg] = useState(base);
+
+ const capture = useCallback(() => cfg, [cfg]);
+ const apply = useCallback((state) => setCfg(makeGridConfig(state || {})), []);
+
+ const views = useTableViews({ page, builtinViews, capture, apply });
+
+ // ---- narrow setters the menus talk to ------------------------------
+ const patch = useCallback((next) => setCfg((prev) => ({ ...prev, ...next })), []);
+
+ const setSort = useCallback((key, dir) => patch({ sort: { key, dir } }), [patch]);
+
+ const toggleGroup = useCallback((key) => {
+ setCfg((prev) => ({ ...prev, group: prev.group === key ? null : key }));
+ }, []);
+
+ const setRules = useCallback((rules) => {
+ setCfg((prev) => ({ ...prev, filters: { ...prev.filters, rules } }));
+ }, []);
+
+ const setMatch = useCallback((match) => {
+ setCfg((prev) => ({ ...prev, filters: { ...prev.filters, match } }));
+ }, []);
+
+ // One rule per column from the header menu (the drawer can stack more).
+ const putColumnRule = useCallback((key, rule) => {
+ setCfg((prev) => ({
+ ...prev,
+ filters: {
+ ...prev.filters,
+ rules: [...prev.filters.rules.filter((r) => r.field !== key), ...(rule ? [rule] : [])],
+ },
+ }));
+ }, []);
+
+ const addRule = useCallback((columnList) => {
+ const first = columnList.find(isFilterable);
+ if (!first) return;
+ setCfg((prev) => ({
+ ...prev,
+ filters: {
+ ...prev.filters,
+ rules: [...prev.filters.rules, {
+ id: ruleId(),
+ field: first.key,
+ op: OPS[first.type][0][0],
+ value: emptyValueFor(first.type),
+ }],
+ },
+ }));
+ }, []);
+
+ const removeRule = useCallback((id) => {
+ setCfg((prev) => ({
+ ...prev,
+ filters: { ...prev.filters, rules: prev.filters.rules.filter((r) => r.id !== id) },
+ }));
+ }, []);
+
+ const clearRules = useCallback(() => {
+ setCfg((prev) => ({ ...prev, filters: { ...prev.filters, rules: [] } }));
+ }, []);
+
+ // Move a column within the visible order. `locked` columns hold slot 0, so
+ // nothing may be moved in front of them.
+ const moveColumn = useCallback((key, delta, lockedCount) => {
+ setCfg((prev) => {
+ const cols = [...prev.cols];
+ const from = cols.indexOf(key);
+ const to = from + delta;
+ if (from < 0 || to < lockedCount || to >= cols.length) return prev;
+ cols.splice(to, 0, ...cols.splice(from, 1));
+ return { ...prev, cols };
+ });
+ }, []);
+
+ const hideColumn = useCallback((key) => {
+ setCfg((prev) => ({
+ ...prev,
+ cols: prev.cols.filter((c) => c !== key),
+ group: prev.group === key ? null : prev.group,
+ filters: { ...prev.filters, rules: prev.filters.rules.filter((r) => r.field !== key) },
+ }));
+ }, []);
+
+ const toggleColumn = useCallback((key, allKeys) => {
+ setCfg((prev) => {
+ if (prev.cols.includes(key)) {
+ return {
+ ...prev,
+ cols: prev.cols.filter((c) => c !== key),
+ group: prev.group === key ? null : prev.group,
+ filters: { ...prev.filters, rules: prev.filters.rules.filter((r) => r.field !== key) },
+ };
+ }
+ // Re-inserting restores the column's natural position rather than
+ // dumping it on the end, so toggling twice is a no-op.
+ const wanted = allKeys.indexOf(key);
+ const at = prev.cols.findIndex((c) => allKeys.indexOf(c) > wanted);
+ const cols = [...prev.cols];
+ cols.splice(at === -1 ? cols.length : at, 0, key);
+ return { ...prev, cols };
+ });
+ }, []);
+
+ const setColumnOrder = useCallback((cols) => patch({ cols }), [patch]);
+ const setDensity = useCallback((density) => patch({ density }), [patch]);
+ const setSub = useCallback((sub) => patch({ sub }), [patch]);
+
+ const resetToView = useCallback(() => {
+ if (views.activeView) views.applyView(views.activeView);
+ else setCfg(clone(base));
+ }, [views, base]);
+
+ return {
+ cfg,
+ setCfg,
+ views,
+ base,
+ setSort,
+ toggleGroup,
+ setRules,
+ setMatch,
+ putColumnRule,
+ addRule,
+ removeRule,
+ clearRules,
+ moveColumn,
+ hideColumn,
+ toggleColumn,
+ setColumnOrder,
+ setDensity,
+ setSub,
+ resetToView,
+ };
+}
+
+export default useGridConfig;
diff --git a/frontend/src/components/ds/grid/useGridRows.js b/frontend/src/components/ds/grid/useGridRows.js
new file mode 100644
index 00000000..056047a7
Binary files /dev/null and b/frontend/src/components/ds/grid/useGridRows.js differ
diff --git a/frontend/src/data/themeTokens.js b/frontend/src/data/themeTokens.js
index c7983650..19c72cee 100644
--- a/frontend/src/data/themeTokens.js
+++ b/frontend/src/data/themeTokens.js
@@ -20,7 +20,7 @@
// Authors write these ~37 names; the alias table below fans each out to the
// legacy names so all ~60 theme-sensitive stylesheet variables get painted.
export const TOKEN_GROUPS = {
- surfaces: ['--bg-body', '--bg-sidebar', '--surface', '--surface-2', '--surface-3', '--surface-hover'],
+ surfaces: ['--bg-body', '--bg-sidebar', '--surface-0', '--surface', '--surface-2', '--surface-3', '--surface-hover'],
borders: ['--border', '--border-soft', '--border-strong'],
text: ['--text', '--text-dim', '--text-faint', '--text-ghost'],
semantic: ['--green', '--green-bg', '--amber', '--amber-bg', '--red', '--red-bg', '--cyan', '--cyan-bg', '--violet', '--violet-bg'],
diff --git a/frontend/src/styles/_theme-variables.scss b/frontend/src/styles/_theme-variables.scss
index a2bb0a10..3746bdc9 100644
--- a/frontend/src/styles/_theme-variables.scss
+++ b/frontend/src/styles/_theme-variables.scss
@@ -27,6 +27,10 @@
--bg-tertiary: #1c2029; // = --surface-3
// ---- Backgrounds (new prototype names) ----
+ // --surface-0 is the recessed step BELOW --surface: group headers, drawer
+ // tab strips and drawer footers sit on it so they read as part of the
+ // chrome rather than as another card.
+ --surface-0: #0d0f14;
--surface: #101218;
--surface-2: #161922;
--surface-3: #1c2029;
@@ -120,6 +124,7 @@
--bg-elevated: #ffffff;
--bg-secondary: #f1f3f9;
--bg-tertiary: #e6e9f2;
+ --surface-0: #f1f3f9;
--surface: #ffffff;
--surface-2: #f6f7fb;
--surface-3: #eef1f7;
@@ -178,6 +183,7 @@
--bg-elevated: #ffffff;
--bg-secondary: #f1f3f9;
--bg-tertiary: #e6e9f2;
+ --surface-0: #f1f3f9;
--surface: #ffffff;
--surface-2: #f6f7fb;
--surface-3: #eef1f7;
diff --git a/frontend/src/styles/components/_datagrid.scss b/frontend/src/styles/components/_datagrid.scss
new file mode 100644
index 00000000..eba4a0f6
--- /dev/null
+++ b/frontend/src/styles/components/_datagrid.scss
@@ -0,0 +1,1206 @@
+// ============================================================
+// DataGrid — the "table is the page" list surface.
+// components/ds/grid/*. Ported from the Domains design mock.
+//
+// The grid is NOT a <table>: the header and every row are separate CSS grids
+// that align because they all read `--sk-grid-tpl`, injected per render from
+// the visible column list. That is what makes show/hide and move-left/right a
+// pure data change with no <colgroup> to keep in sync.
+// ============================================================
+
+// ---------------------------------------------------------------- column menu
+// The "⋮" trigger. Shared by <DataGrid> (CSS grid) and <DataTable> (a real
+// <table>), so it is defined once, standalone, and positioned by whichever
+// header cell hosts it. Three stacked dots drawn with box-shadow rather than
+// an icon: it stays crisp at 3px and needs no SVG per header cell.
+.sk-colmenu-btn {
+ position: absolute;
+ right: 4px;
+ top: 50%;
+ transform: translateY(-50%);
+ width: 20px;
+ height: 20px;
+ display: grid;
+ place-items: center;
+ border: none;
+ border-radius: 5px;
+ background: transparent;
+ color: var(--text-ghost);
+ cursor: pointer;
+ opacity: 0;
+ transition: 0.12s;
+
+ &:hover { background: var(--surface-3); color: var(--text); }
+ &:focus-visible { opacity: 1; outline: 2px solid var(--accent-dim); outline-offset: -2px; }
+ &[data-state='open'] { opacity: 1; background: var(--surface-3); color: var(--text); }
+
+ &__dots {
+ width: 3px;
+ height: 3px;
+ border-radius: 50%;
+ background: currentcolor;
+ box-shadow: 0 -5px 0 currentcolor, 0 5px 0 currentcolor;
+ }
+}
+
+// ---------------------------------------------------------------- view bar
+.sk-viewbar {
+ display: flex;
+ align-items: center;
+ gap: 14px;
+ margin-bottom: 14px;
+
+ &__count {
+ font-family: var(--mono);
+ font-size: 11.5px;
+ color: var(--text-ghost);
+ padding-top: 3px;
+ white-space: nowrap;
+ }
+
+ // Amber, not red: unsaved tweaks are a state, not an error.
+ &__dirty {
+ display: flex;
+ align-items: center;
+ gap: 8px;
+ padding: 4px 5px 4px 11px;
+ border: 1px solid rgba(245, 185, 69, 0.28);
+ background: rgba(245, 185, 69, 0.07);
+ border-radius: 9px;
+ font-size: 12px;
+ color: var(--amber);
+ white-space: nowrap;
+
+ button {
+ display: inline-flex;
+ align-items: center;
+ gap: 4px;
+ font-size: 12px;
+ font-weight: 500;
+ padding: 4px 9px;
+ border: none;
+ border-radius: 6px;
+ background: transparent;
+ color: var(--text-dim);
+ cursor: pointer;
+
+ &:hover { background: var(--surface-3); color: var(--text); }
+
+ &.is-primary {
+ background: var(--amber);
+ color: #20180a;
+ font-weight: 600;
+
+ &:hover { background: #ffc75c; }
+ }
+ }
+ }
+}
+
+.sk-viewpick {
+ display: flex;
+ align-items: center;
+ gap: 8px;
+ padding: 5px 10px 5px 4px;
+ border: none;
+ border-radius: 9px;
+ background: transparent;
+ color: var(--text);
+ cursor: pointer;
+ transition: background 0.13s;
+
+ &:hover,
+ &.is-open { background: var(--surface-2); }
+
+ &__title {
+ font-size: 20px;
+ font-weight: 600;
+ letter-spacing: -0.02em;
+ }
+
+ &__ast {
+ color: var(--amber);
+ font-size: 18px;
+ margin-left: -4px;
+ }
+
+ svg { color: var(--text-faint); }
+
+ &__menu { width: 19rem; }
+
+ &__row {
+ display: flex;
+ align-items: center;
+ border-radius: 8px;
+
+ &:hover { background: var(--surface-3); }
+ &.is-on { background: var(--accent-bg); }
+ &.is-on .sk-viewpick__nm { color: var(--accent-bright); }
+ }
+
+ &__rowmain {
+ flex: 1;
+ min-width: 0;
+ display: flex;
+ align-items: center;
+ gap: 10px;
+ padding: 8px 9px;
+ border: none;
+ background: transparent;
+ font-size: 13px;
+ color: var(--text-dim);
+ text-align: left;
+ cursor: pointer;
+ }
+
+ &__dot {
+ width: 7px;
+ height: 7px;
+ border-radius: 50%;
+ flex-shrink: 0;
+ background: var(--accent);
+
+ &[data-builtin='true'] { background: var(--text-ghost); }
+ }
+
+ &__nm {
+ flex: 1;
+ min-width: 0;
+ overflow: hidden;
+ text-overflow: ellipsis;
+ white-space: nowrap;
+ }
+
+ &__star { color: var(--amber); flex-shrink: 0; }
+
+ &__n {
+ font-family: var(--mono);
+ font-size: 10.5px;
+ color: var(--text-ghost);
+ }
+
+ &__cog {
+ opacity: 0;
+ display: grid;
+ place-items: center;
+ width: 24px;
+ height: 24px;
+ margin-right: 5px;
+ border: none;
+ border-radius: 5px;
+ background: transparent;
+ color: var(--text-ghost);
+ cursor: pointer;
+ transition: 0.12s;
+
+ &:hover { color: var(--text); background: var(--surface-2); }
+ }
+
+ &__row:hover &__cog,
+ &__row.is-on &__cog { opacity: 1; }
+}
+
+// ---------------------------------------------------------------- toolbar bits
+.sk-gridicon {
+ position: relative;
+ width: 34px;
+ height: 32px;
+ display: grid;
+ place-items: center;
+ border: 1px solid var(--border);
+ background: var(--surface-2);
+ border-radius: 9px;
+ color: var(--text-dim);
+ cursor: pointer;
+ flex-shrink: 0;
+ transition: 0.13s;
+
+ &:hover {
+ border-color: var(--border-strong);
+ color: var(--text);
+ background: var(--surface-3);
+ }
+
+ &.is-on {
+ border-color: var(--accent-dim);
+ background: var(--accent-bg);
+ color: var(--accent-bright);
+ }
+
+ &__count {
+ position: absolute;
+ top: -6px;
+ right: -6px;
+ font-family: var(--mono);
+ font-size: 9.5px;
+ background: var(--accent);
+ color: #fff;
+ border: 2px solid var(--bg-body);
+ border-radius: 20px;
+ min-width: 17px;
+ height: 17px;
+ padding: 0 4px;
+ display: grid;
+ place-items: center;
+ }
+}
+
+// ---------------------------------------------------------------- filter chips
+.sk-gridchips {
+ display: flex;
+ flex-wrap: wrap;
+ align-items: center;
+ gap: 7px;
+ margin-bottom: 13px;
+
+ &__clear {
+ font-size: 12px;
+ color: var(--text-faint);
+ padding: 5px 8px;
+ border: none;
+ border-radius: 7px;
+ background: transparent;
+ cursor: pointer;
+
+ &:hover { background: var(--surface-2); color: var(--text); }
+ }
+}
+
+.sk-gridchip {
+ display: inline-flex;
+ align-items: center;
+ gap: 8px;
+ padding: 5px 6px 5px 10px;
+ border: 1px solid var(--border);
+ background: var(--surface-2);
+ border-radius: 9px;
+ font-size: 12.5px;
+ color: var(--text);
+ max-width: 360px;
+ white-space: nowrap;
+
+ &:hover { border-color: var(--border-strong); }
+
+ &__k {
+ font-family: var(--mono);
+ font-size: 10px;
+ letter-spacing: 0.08em;
+ text-transform: uppercase;
+ color: var(--text-faint);
+ }
+
+ &__op { color: var(--text-faint); font-size: 11.5px; }
+
+ &__v { overflow: hidden; text-overflow: ellipsis; }
+
+ &__x {
+ width: 18px;
+ height: 18px;
+ border: none;
+ border-radius: 5px;
+ background: transparent;
+ display: grid;
+ place-items: center;
+ color: var(--text-ghost);
+ cursor: pointer;
+
+ &:hover { background: var(--surface-3); color: var(--red); }
+ }
+
+ &--match {
+ background: var(--accent-bg-soft);
+ border-color: var(--accent-dim);
+ color: var(--accent-bright);
+ font-family: var(--mono);
+ font-size: 10.5px;
+ letter-spacing: 0.08em;
+ text-transform: uppercase;
+ padding: 6px 10px;
+ cursor: pointer;
+ }
+}
+
+// ---------------------------------------------------------------- bulk bar
+.sk-gridbulk {
+ display: flex;
+ align-items: center;
+ gap: 12px;
+ white-space: nowrap;
+ padding: 8px 10px 8px 14px;
+ margin-bottom: 10px;
+ border: 1px solid var(--accent-dim);
+ background: linear-gradient(90deg, var(--accent-bg), var(--surface-2));
+ border-radius: 11px;
+ animation: sk-grid-pop 0.14s ease;
+
+ &__count {
+ font-family: var(--mono);
+ font-size: 12px;
+ font-weight: 600;
+ color: #fff;
+ background: var(--accent);
+ border-radius: 7px;
+ padding: 2px 8px;
+ }
+
+ &__label { font-size: 12.5px; color: var(--text); }
+
+ &__acts {
+ display: flex;
+ align-items: center;
+ gap: 4px;
+ margin-left: 6px;
+ overflow-x: auto;
+ scrollbar-width: none;
+
+ &::-webkit-scrollbar { display: none; }
+
+ button {
+ flex-shrink: 0;
+ display: flex;
+ align-items: center;
+ gap: 7px;
+ padding: 6px 10px;
+ border: none;
+ border-radius: 8px;
+ background: transparent;
+ font-size: 12.5px;
+ color: var(--text-dim);
+ cursor: pointer;
+ transition: 0.12s;
+
+ &:hover { background: var(--surface-3); color: var(--text); }
+ &.is-danger:hover { background: var(--red-bg); color: var(--red); }
+ }
+ }
+
+ &__clear {
+ margin-left: auto;
+ display: flex;
+ align-items: center;
+ gap: 6px;
+ padding: 6px 10px;
+ border: none;
+ border-radius: 8px;
+ background: transparent;
+ font-size: 12.5px;
+ color: var(--text-faint);
+ cursor: pointer;
+
+ &:hover { background: var(--surface-3); color: var(--text); }
+ }
+}
+
+// ---------------------------------------------------------------- the grid
+.sk-grid {
+ border: 1px solid var(--border-soft);
+ border-radius: var(--radius-lg);
+ background: var(--surface);
+ position: relative;
+
+ &__head,
+ &__row {
+ display: grid;
+ grid-template-columns: var(--sk-grid-tpl);
+ align-items: center;
+ }
+
+ &__head {
+ position: sticky;
+ top: 0;
+ z-index: 6;
+ border-bottom: 1px solid var(--border-soft);
+ // Top-lit, not a flat fill — the header reads as a lid on the surface.
+ background: linear-gradient(180deg, var(--surface-2), var(--surface));
+ border-radius: var(--radius-lg) var(--radius-lg) 0 0;
+ }
+
+ &__th {
+ position: relative;
+ display: flex;
+ align-items: center;
+ gap: 6px;
+ // 26px of right padding is the reserved lane for the "⋮" button, so the
+ // label never reflows when it appears on hover.
+ padding: 10px 26px 10px 14px;
+ font-family: var(--mono);
+ font-size: 10px;
+ letter-spacing: 0.055em;
+ text-transform: uppercase;
+ color: var(--text-ghost);
+ user-select: none;
+ min-width: 0;
+
+ &.is-sortable { cursor: pointer; }
+ &.is-sortable:hover { color: var(--text-dim); }
+ &.is-sorted { color: var(--text); }
+ &.is-filtered { color: var(--accent-bright); }
+ &.is-num { justify-content: flex-end; }
+ }
+
+ &__thlabel {
+ overflow: hidden;
+ text-overflow: ellipsis;
+ white-space: nowrap;
+ }
+
+ &__tharrow {
+ display: grid;
+ place-items: center;
+ color: var(--accent-bright);
+ }
+
+ &__th:hover .sk-colmenu-btn { opacity: 1; }
+ &__th.is-filtered .sk-colmenu-btn { opacity: 1; color: var(--accent-bright); }
+
+ // ---- rows ----
+ &__row {
+ border-top: 1px solid var(--border-soft);
+ transition: background 0.12s;
+
+ &.is-clickable { cursor: pointer; }
+ &:hover { background: var(--surface-2); }
+ &.is-picked { background: var(--accent-bg-soft); }
+ &.is-picked:hover { background: var(--accent-bg); }
+ }
+
+ &__td {
+ padding: 11px 14px;
+ min-width: 0;
+ font-size: 13px;
+ color: var(--text-dim);
+ overflow: hidden;
+
+ &.is-num {
+ text-align: right;
+ font-family: var(--mono);
+ font-size: 12px;
+ }
+ }
+
+ // ---- first-column identity cell ----
+ &__name {
+ display: flex;
+ align-items: center;
+ gap: 11px;
+ min-width: 0;
+ }
+
+ &__avatar {
+ width: 30px;
+ height: 30px;
+ border-radius: 9px;
+ flex-shrink: 0;
+ display: grid;
+ place-items: center;
+ background: var(--surface-3);
+ border: 1px solid var(--border);
+ color: var(--text-faint);
+ transition: 0.12s;
+ }
+
+ &__row:hover &__avatar {
+ border-color: var(--accent-dim);
+ color: var(--accent-bright);
+ background: var(--accent-bg);
+ }
+
+ &__nameinner { min-width: 0; }
+
+ &__nm {
+ font-size: 13.5px;
+ font-weight: 550;
+ color: var(--text);
+ white-space: nowrap;
+ overflow: hidden;
+ text-overflow: ellipsis;
+ }
+
+ &__sub {
+ display: flex;
+ align-items: center;
+ gap: 9px;
+ margin-top: 2px;
+ font-family: var(--mono);
+ font-size: 10.5px;
+ color: var(--text-ghost);
+ white-space: nowrap;
+ overflow: hidden;
+
+ b { font-weight: 500; color: var(--text-faint); margin-right: 4px; }
+ }
+
+ &__subitem {
+ display: inline-flex;
+ align-items: center;
+
+ i {
+ width: 3px;
+ height: 3px;
+ border-radius: 50%;
+ background: var(--border-strong);
+ flex-shrink: 0;
+ margin-right: 9px;
+ }
+ }
+
+ // ---- selection ----
+ &__check {
+ display: flex;
+ align-items: center;
+ justify-content: center;
+ padding-left: 12px !important;
+ padding-right: 0 !important;
+ cursor: pointer;
+ }
+
+ &__box {
+ width: 16px;
+ height: 16px;
+ border-radius: 5px;
+ border: 1.5px solid var(--border-strong);
+ display: grid;
+ place-items: center;
+ color: transparent;
+ background: var(--surface);
+ transition: 0.12s;
+
+ &.is-on { background: var(--accent); border-color: var(--accent); color: #fff; }
+ &.is-part { background: var(--surface-3); border-color: var(--accent-dim); color: var(--accent-bright); }
+ }
+
+ &__row:hover &__box { border-color: var(--text-ghost); }
+
+ // ---- row-end quick actions ----
+ &__rowend {
+ display: flex;
+ align-items: center;
+ justify-content: flex-end;
+ gap: 2px;
+ padding-right: 10px !important;
+
+ button {
+ width: 24px;
+ height: 24px;
+ border: none;
+ border-radius: 6px;
+ background: transparent;
+ display: grid;
+ place-items: center;
+ color: var(--text-ghost);
+ cursor: pointer;
+ opacity: 0;
+ transition: 0.12s;
+
+ &:hover { background: var(--surface-3); color: var(--accent-bright); }
+ }
+ }
+
+ &__row:hover &__rowend button { opacity: 1; }
+
+ // ---- group headers ----
+ &__group {
+ display: flex;
+ align-items: center;
+ gap: 10px;
+ width: 100%;
+ padding: 9px 16px;
+ border: none;
+ border-top: 1px solid var(--border-soft);
+ background: var(--surface-0);
+ font-family: var(--mono);
+ font-size: 10.5px;
+ letter-spacing: 0.09em;
+ text-transform: uppercase;
+ color: var(--text-faint);
+ cursor: pointer;
+ position: sticky;
+ top: 41px; // sits under the sticky header, never over it
+ z-index: 2;
+
+ &:hover { color: var(--text); }
+
+ i { flex: 1; height: 1px; background: var(--border-soft); }
+ }
+
+ &__groupcount { color: var(--text-ghost); }
+
+ &__empty { padding: 56px 20px; text-align: center; }
+
+ // ---- density ----
+ &--compact {
+ .sk-grid__td { padding: 7px 14px; }
+ .sk-grid__sub { display: none; }
+ .sk-grid__avatar { width: 22px; height: 22px; border-radius: 7px; }
+ }
+}
+
+// ---------------------------------------------------------------- footer
+.sk-gridfoot {
+ display: flex;
+ align-items: center;
+ gap: 14px;
+ padding: 12px 16px;
+ border-top: 1px solid var(--border-soft);
+ font-family: var(--mono);
+ font-size: 11px;
+ color: var(--text-ghost);
+ flex-wrap: wrap;
+
+ &__sp { flex: 1; }
+}
+
+.sk-gridpager {
+ display: flex;
+ align-items: center;
+ gap: 6px;
+
+ &__label {
+ font-family: var(--mono);
+ font-size: 10.5px;
+ letter-spacing: 0.06em;
+ text-transform: uppercase;
+ color: var(--text-ghost);
+ }
+
+ &__sel {
+ position: relative;
+ display: flex;
+ align-items: center;
+ margin-right: 6px;
+
+ select {
+ appearance: none;
+ padding: 4px 20px 4px 8px;
+ border-radius: 7px;
+ border: 1px solid var(--border);
+ background: var(--surface-2);
+ color: var(--text-dim);
+ font-family: var(--mono);
+ font-size: 11px;
+ outline: none;
+ cursor: pointer;
+
+ &:hover { border-color: var(--border-strong); color: var(--text); }
+ }
+
+ svg {
+ position: absolute;
+ right: 5px;
+ pointer-events: none;
+ color: var(--text-ghost);
+ }
+ }
+
+ button {
+ width: 26px;
+ height: 24px;
+ display: grid;
+ place-items: center;
+ border-radius: 7px;
+ border: 1px solid var(--border);
+ background: var(--surface-2);
+ color: var(--text-dim);
+ cursor: pointer;
+ transition: 0.12s;
+
+ &:hover:not(:disabled) {
+ border-color: var(--border-strong);
+ color: var(--text);
+ background: var(--surface-3);
+ }
+
+ &:disabled { opacity: 0.32; cursor: default; }
+ }
+
+ &__pos {
+ font-family: var(--mono);
+ font-size: 11px;
+ color: var(--text-dim);
+ padding: 0 4px;
+ min-width: 44px;
+ text-align: center;
+ }
+}
+
+// ---------------------------------------------------------------- menus
+// Rendered inside the shared .ui-popover-panel surface (Radix portal + collision
+// flipping), so these rules own spacing only — never position.
+.sk-gridmenu {
+ width: auto;
+ min-width: 15.5rem;
+ max-width: 20rem;
+ padding: 8px;
+ display: flex;
+ flex-direction: column;
+ gap: 1px;
+
+ &__head {
+ font-family: var(--mono);
+ font-size: 10px;
+ letter-spacing: 0.11em;
+ text-transform: uppercase;
+ color: var(--text-ghost);
+ padding: 5px 8px 7px;
+ }
+
+ &__note {
+ font-size: 11.5px;
+ color: var(--text-ghost);
+ padding: 2px 9px 8px;
+ line-height: 1.45;
+ }
+
+ &__sep {
+ height: 1px;
+ background: var(--border-soft);
+ margin: 6px 4px;
+ }
+
+ &__opt {
+ display: flex;
+ align-items: center;
+ gap: 10px;
+ width: 100%;
+ padding: 7px 9px;
+ border: none;
+ border-radius: 8px;
+ background: transparent;
+ font-size: 12.5px;
+ font-family: inherit;
+ color: var(--text-dim);
+ text-align: left;
+ cursor: pointer;
+ transition: 0.11s;
+
+ &:hover:not(:disabled) { background: var(--surface-3); color: var(--text); }
+ &.is-on { color: var(--text); }
+ &.is-danger { color: var(--red); }
+ &.is-danger:hover:not(:disabled) { background: var(--red-bg); color: var(--red); }
+ &:disabled { opacity: 0.4; cursor: default; }
+
+ svg { flex-shrink: 0; }
+ }
+
+ // The check-in-the-option pattern: a toggle reads as a list row, not a form
+ // control, so multi-select filters stay scannable at a glance.
+ &__box {
+ width: 15px;
+ height: 15px;
+ border-radius: 4px;
+ border: 1.5px solid var(--border-strong);
+ display: grid;
+ place-items: center;
+ flex-shrink: 0;
+ color: transparent;
+ }
+
+ &__opt.is-on &__box {
+ background: var(--accent);
+ border-color: var(--accent);
+ color: #fff;
+ }
+
+ &__cap { text-transform: capitalize; }
+
+ &__rest {
+ margin-left: auto;
+ font-family: var(--mono);
+ font-size: 10.5px;
+ color: var(--text-ghost);
+ }
+
+ &__scroll { max-height: 212px; overflow-y: auto; }
+
+ &__mini {
+ display: flex;
+ align-items: center;
+ gap: 7px;
+ padding: 6px 9px;
+ border: 1px solid var(--border);
+ background: var(--surface-3);
+ border-radius: 8px;
+ margin: 2px 4px 6px;
+
+ svg { color: var(--text-ghost); flex-shrink: 0; }
+
+ input,
+ select {
+ width: 100%;
+ min-width: 0;
+ background: none;
+ border: none;
+ outline: none;
+ color: var(--text);
+ font-size: 12.5px;
+ font-family: var(--mono);
+ }
+
+ select { color: var(--text-dim); font-family: var(--sans); cursor: pointer; }
+
+ input::placeholder { color: var(--text-ghost); font-family: var(--sans); }
+ }
+
+ &__quick {
+ display: flex;
+ flex-wrap: wrap;
+ gap: 5px;
+ padding: 2px 4px 6px;
+
+ button {
+ padding: 5px 9px;
+ border-radius: 7px;
+ border: 1px solid var(--border);
+ background: var(--surface-3);
+ font-size: 11.5px;
+ color: var(--text-dim);
+ cursor: pointer;
+
+ &:hover { border-color: var(--accent-dim); color: var(--accent-bright); }
+ }
+ }
+
+ &__foot {
+ display: flex;
+ gap: 6px;
+ padding: 6px 4px 0;
+ margin-top: 4px;
+ border-top: 1px solid var(--border-soft);
+
+ button {
+ flex: 1;
+ padding: 7px;
+ border: none;
+ border-radius: 7px;
+ font-size: 12px;
+ font-weight: 500;
+ font-family: inherit;
+ color: var(--text-dim);
+ background: var(--surface-3);
+ cursor: pointer;
+
+ &:hover:not(:disabled) { color: var(--text); background: var(--border); }
+ &:disabled { opacity: 0.45; cursor: default; }
+
+ &.is-primary { background: var(--accent); color: #fff; }
+ &.is-primary:hover:not(:disabled) { background: var(--accent-bright); }
+ }
+ }
+}
+
+// ---------------------------------------------------------------- drawer
+.sk-griddrawer {
+ // ds/Drawer hands children to .sk-drawer__body, which is a plain scrolling
+ // block. This drawer owns three regions of its own (tab strip, scroll area,
+ // pinned footer), so the slot has to become the flex column and give the
+ // scroll to __body — otherwise the footer floats directly under the last
+ // control with dead space beneath it.
+ .sk-drawer__body {
+ display: flex;
+ flex-direction: column;
+ overflow: hidden;
+ padding: 0;
+ }
+
+ &__tabs {
+ display: flex;
+ gap: 2px;
+ padding: 0 16px;
+ border-bottom: 1px solid var(--border);
+ background: var(--surface-0);
+ flex-shrink: 0;
+
+ button {
+ position: relative;
+ display: flex;
+ align-items: center;
+ gap: 8px;
+ padding: 11px 13px 12px;
+ border: none;
+ background: transparent;
+ font-size: 13px;
+ font-weight: 500;
+ font-family: inherit;
+ color: var(--text-faint);
+ cursor: pointer;
+ transition: color 0.13s;
+
+ &:hover { color: var(--text-dim); }
+ &.is-on { color: var(--text); }
+
+ &.is-on::after {
+ content: '';
+ position: absolute;
+ left: 8px;
+ right: 8px;
+ bottom: -1px;
+ height: 2px;
+ border-radius: 2px 2px 0 0;
+ background: var(--accent);
+ box-shadow: 0 -1px 12px var(--accent-glow);
+ }
+
+ .n {
+ font-family: var(--mono);
+ font-size: 10.5px;
+ color: var(--text-ghost);
+ background: var(--surface-2);
+ border: 1px solid var(--border-soft);
+ border-radius: 5px;
+ padding: 1px 5px;
+ }
+
+ &.is-on .n { color: var(--text-dim); background: var(--surface-3); border-color: var(--border); }
+ }
+ }
+
+ &__body { flex: 1; overflow-y: auto; }
+
+ &__foot {
+ display: flex;
+ align-items: center;
+ gap: 8px;
+ padding: 14px 20px;
+ border-top: 1px solid var(--border);
+ background: var(--surface-0);
+ flex-shrink: 0;
+ }
+
+ &__sp { flex: 1; }
+}
+
+.sk-gridsec {
+ padding: 18px 20px;
+ border-bottom: 1px solid var(--border-soft);
+
+ &__head {
+ display: flex;
+ align-items: center;
+ gap: 10px;
+ margin-bottom: 13px;
+ }
+
+ &__t {
+ font-family: var(--mono);
+ font-size: 10.5px;
+ letter-spacing: 0.11em;
+ text-transform: uppercase;
+ color: var(--text-faint);
+ flex: 1;
+ }
+
+ &__add {
+ display: flex;
+ align-items: center;
+ gap: 5px;
+ font-size: 12px;
+ font-family: inherit;
+ color: var(--accent-bright);
+ padding: 4px 8px;
+ border: none;
+ border-radius: 7px;
+ background: transparent;
+ cursor: pointer;
+
+ &:hover { background: var(--accent-bg); }
+ }
+
+ &__none {
+ padding: 14px;
+ border: 1px dashed var(--border);
+ border-radius: 10px;
+ text-align: center;
+ font-size: 12.5px;
+ color: var(--text-ghost);
+ }
+
+ &__hint {
+ font-size: 12.5px;
+ color: var(--text-faint);
+ margin-bottom: 10px;
+ }
+
+ &__tags { display: flex; flex-wrap: wrap; gap: 6px; }
+}
+
+.sk-gridmatch {
+ display: inline-flex;
+ align-items: center;
+ gap: 8px;
+ font-size: 12.5px;
+ color: var(--text-faint);
+ margin-bottom: 11px;
+}
+
+.sk-gridseg {
+ display: inline-flex;
+ gap: 2px;
+ background: var(--surface-3);
+ border: 1px solid var(--border);
+ border-radius: 8px;
+ padding: 2px;
+
+ button {
+ padding: 4px 10px;
+ border: none;
+ border-radius: 6px;
+ background: transparent;
+ font-size: 11.5px;
+ font-weight: 500;
+ font-family: inherit;
+ color: var(--text-faint);
+ cursor: pointer;
+
+ &.is-on { background: var(--accent-bg); color: var(--accent-bright); }
+ }
+
+ &--wide { width: fit-content; }
+}
+
+.sk-gridrule {
+ display: grid;
+ grid-template-columns: 1fr 116px 26px;
+ gap: 6px;
+ align-items: center;
+ margin-bottom: 9px;
+
+ &__value { grid-column: 1 / -1; }
+
+ &__sel {
+ position: relative;
+
+ select {
+ appearance: none;
+ width: 100%;
+ padding: 8px 22px 8px 10px;
+ border-radius: 8px;
+ border: 1px solid var(--border);
+ background: var(--surface-2);
+ color: var(--text);
+ font-size: 12.5px;
+ font-family: inherit;
+ outline: none;
+ cursor: pointer;
+ text-overflow: ellipsis;
+
+ &:focus { border-color: var(--accent-dim); }
+ }
+
+ svg {
+ position: absolute;
+ right: 7px;
+ top: 50%;
+ transform: translateY(-50%);
+ pointer-events: none;
+ color: var(--text-ghost);
+ }
+ }
+
+ input[type='text'],
+ input[type='number'],
+ input[type='date'] {
+ width: 100%;
+ padding: 8px 10px;
+ border-radius: 8px;
+ border: 1px solid var(--border);
+ background: var(--surface-2);
+ color: var(--text);
+ font-size: 12.5px;
+ font-family: var(--mono);
+ outline: none;
+
+ &:focus { border-color: var(--accent-dim); }
+ }
+
+ &__del {
+ width: 26px;
+ height: 30px;
+ border: none;
+ border-radius: 7px;
+ background: transparent;
+ display: grid;
+ place-items: center;
+ color: var(--text-ghost);
+ cursor: pointer;
+
+ &:hover { background: var(--red-bg); color: var(--red); }
+ }
+
+ &__join {
+ font-family: var(--mono);
+ font-size: 10px;
+ letter-spacing: 0.1em;
+ text-transform: uppercase;
+ color: var(--text-ghost);
+ padding: 1px 0 6px 2px;
+ }
+
+ &__enum { display: flex; flex-wrap: wrap; gap: 6px; }
+
+ &__tag {
+ padding: 5px 10px;
+ border-radius: 7px;
+ border: 1px solid var(--border);
+ background: var(--surface-2);
+ font-size: 11.5px;
+ font-family: inherit;
+ color: var(--text-dim);
+ cursor: pointer;
+ transition: 0.12s;
+ text-transform: capitalize;
+
+ &:hover { border-color: var(--border-strong); color: var(--text); }
+
+ &.is-on {
+ border-color: var(--accent-dim);
+ background: var(--accent-bg);
+ color: var(--accent-bright);
+ }
+ }
+}
+
+.sk-gridcol {
+ display: flex;
+ align-items: center;
+ gap: 10px;
+ padding: 7px 9px;
+ border-radius: 8px;
+ border: 1px solid transparent;
+ font-size: 12.5px;
+ color: var(--text-dim);
+ transition: 0.11s;
+
+ &:hover { background: var(--surface-2); border-color: var(--border); }
+ &.is-drag { opacity: 0.35; }
+ &.is-off .sk-gridcol__nm { color: var(--text-ghost); }
+
+ &__grip { color: var(--text-ghost); display: grid; place-items: center; cursor: grab; }
+ &__nm { flex: 1; min-width: 0; }
+
+ &__lock {
+ font-family: var(--mono);
+ font-size: 9.5px;
+ letter-spacing: 0.08em;
+ text-transform: uppercase;
+ color: var(--text-ghost);
+ }
+}
+
+@keyframes sk-grid-pop {
+ from { opacity: 0; transform: translateY(-4px); }
+ to { opacity: 1; transform: none; }
+}
+
+// ---------------------------------------------------------------- responsive
+// Below the tablet breakpoint the grid scrolls sideways rather than crushing
+// every track to unreadable width.
+@media (max-width: 900px) {
+ .sk-grid {
+ overflow-x: auto;
+
+ &__head,
+ &__row { min-width: 760px; }
+ }
+
+ .sk-viewpick__title { font-size: 17px; }
+}
diff --git a/frontend/src/styles/main.scss b/frontend/src/styles/main.scss
index 7b3804cd..1baf22a0 100644
--- a/frontend/src/styles/main.scss
+++ b/frontend/src/styles/main.scss
@@ -72,6 +72,7 @@
@import 'components/_ui';
@import 'components/_staging-banner';
@import 'components/_design-system'; // redesign shared primitives (sk-* namespace)
+@import 'components/_datagrid'; // DataGrid list surface (sk-grid*, ds/grid/)
@import 'components/_dashboard-widgets'; // configurable dashboard grid (skw-* namespace)
@import 'components/_widget-editor'; // wide preview+settings widget drawer (skwe-* namespace)
@import 'components/_system-notices';