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.
Python astracloudflarecontrol-panelcyberpaneldnsfablehosting-control-panelhosting-panelkimi-k3server-managementserverkitubuntu-web-panelwebserver
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.jsxnew file mode 100644index 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.jsxnew file mode 100644index 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.jsxnew file mode 100644index 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.jsxnew file mode 100644index 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.jsxnew file mode 100644index 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.jsxnew file mode 100644index 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.jsxnew file mode 100644index 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.jsxnew file mode 100644index 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.jsxnew file mode 100644index 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 & 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.jsnew file mode 100644index 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.jsnew file mode 100644index 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.jsnew file mode 100644index 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.jsnew file mode 100644index 00000000..056047a7Binary files /dev/null and b/frontend/src/components/ds/grid/useGridRows.js differdiff --git a/frontend/src/data/themeTokens.js b/frontend/src/data/themeTokens.jsindex 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.scssindex 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.scssnew file mode 100644index 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.scssindex 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';