diff --git a/dashboard-v2/package.json b/dashboard-v2/package.json index 7e334ff9b..3620dafae 100644 --- a/dashboard-v2/package.json +++ b/dashboard-v2/package.json @@ -14,6 +14,7 @@ "@astryxdesign/theme-neutral": "0.7.4", "@heroicons/react": "^2.2.0", "@stylexjs/stylex": "^0.19.0", + "lucide-react": "^1.18.0", "@tanstack/react-query": "^5.0.0", "react": "^19.1.0", "react-dom": "^19.1.0" @@ -22,6 +23,7 @@ "@astryxdesign/cli": "0.7.4", "@types/react": "^19.1.0", "@types/react-dom": "^19.1.0", + "@stylexjs/rollup-plugin": "^0.19.0", "@vitejs/plugin-react": "^5.0.0", "typescript": "~6.0.3", "vite": "^8.3.0" diff --git a/dashboard-v2/pnpm-lock.yaml b/dashboard-v2/pnpm-lock.yaml index 387aeba36..45f230032 100644 --- a/dashboard-v2/pnpm-lock.yaml +++ b/dashboard-v2/pnpm-lock.yaml @@ -181,6 +181,9 @@ importers: '@tanstack/react-query': specifier: ^5.0.0 version: 5.104.5(@types/react@19.3.0)(react@19.3.1) + lucide-react: + specifier: ^1.18.0 + version: 1.61.0(@types/react@19.3.0)(react@19.3.1) react: specifier: ^19.1.0 version: 19.3.1 @@ -191,6 +194,9 @@ importers: '@astryxdesign/cli': specifier: 0.7.4 version: 0.7.4(@astryxdesign/core@0.7.4(@stylexjs/stylex@0.19.1)(react-dom@19.3.1(react@19.3.1))(react@19.3.1))(@astryxdesign/theme-neutral@0.7.4(@astryxdesign/core@0.7.4(@stylexjs/stylex@0.19.1)(react-dom@19.3.1(react@19.3.1))(react@19.3.1))(@types/react@19.3.0)(react@19.3.1)) + '@stylexjs/rollup-plugin': + specifier: ^0.19.0 + version: 0.19.1 '@types/react': specifier: ^19.1.0 version: 19.3.0 @@ -439,6 +445,9 @@ packages: resolution: {integrity: sha512-Vj1jF3cPfxg7OAfoI7QnVKLoILlm2JF9pnVHrX8qx7AHMiYWT+NDAA7jChlNgRS4WTLc/fD1lXLmPixluj+3Gg==} engines: {node: '>=6.9.0'} + '@dual-bundle/import-meta-resolve@4.2.1': + resolution: {integrity: sha512-id+7YRUgoUX6CgV0DtuhirQWodeeA7Lf4i2x71JS/vtA5pRb/hIGWlw+G6MeXvsM+MXrz0VAydTGElX1rAfgPg==} + '@formatjs/fast-memoize@3.1.7': resolution: {integrity: sha512-zXfhLpvA6T7+efdt9JLbBwZ00tT7NsBMDVnDu8rpHeNNv8KfRZAMo2gkG0k9lK/Nzc//3kJ9pImsfuJxk3KhUA==} @@ -574,6 +583,15 @@ packages: '@rolldown/pluginutils@1.0.1': resolution: {integrity: sha512-2j9bGt5Jh8hj+vPtgzPtl72j0yRxHAyumoo6TNfAjsLB04UtpSvPbPcDcBMxz7n+9CYB0c1GxQFxYRg2jimqGw==} + '@stylexjs/babel-plugin@0.19.1': + resolution: {integrity: sha512-Ig3crX6MuGWDEAx+f89aLxTQUWVeEc2Aco2moIdcObyvo7hZJgU26rxJN3k7geFjhi+5dfna6TNR8iTRK0PQGA==} + + '@stylexjs/rollup-plugin@0.19.1': + resolution: {integrity: sha512-+f9Ktlq3CqXq6dqcbF3PmHkrqiPZ4kirvVBlFnOF0wBD1Ws+0tC3QcGBqQmp7cw9SjqH5EVJPGBO15xap//kKA==} + + '@stylexjs/shared@0.19.1': + resolution: {integrity: sha512-oFBtW0NPNLJOT1gLweWRNKrIJHjJMwOmSV7fgd6ewok4fwb/Nh95PEaYGKu+ZONk0nNghjLFfOwiIsxJdvh3TQ==} + '@stylexjs/stylex@0.19.1': resolution: {integrity: sha512-JwNFm0MOYPqi+M4Ax5Un4ZxfZp4HEAX2sAWetZ88KALFcv1eEiHNJs75oO3V3U7RVWnzfkiM8i9eBowC3hqgUw==} @@ -931,6 +949,9 @@ packages: resolution: {integrity: sha512-wWBro/7hJ40ye6TPiXkUQoXKCw23xSsjriUvqd7Uls9Sso3oLiON1flc18cCdnjgCRXw4fBVqUJJeOdDTh3P3g==} engines: {node: '>=4'} + postcss-value-parser@4.2.0: + resolution: {integrity: sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==} + postcss@8.5.31: resolution: {integrity: sha512-YUbWYCgErwnMAVkjUnYa+KlMBzGpHwiIt/DE7f0G33AuX2LH9UcTk6KgWxd3zRU+pN3u/C+Xl3EnMLM4Hea7Sg==} engines: {node: ^10 || ^12 || >=14} @@ -1184,7 +1205,7 @@ snapshots: '@babel/helper-module-imports@7.29.7': dependencies: '@babel/traverse': 7.29.10 - '@babel/types': 7.29.8 + '@babel/types': 7.29.11 transitivePeerDependencies: - supports-color @@ -1372,6 +1393,8 @@ snapshots: '@babel/helper-string-parser': 7.29.11 '@babel/helper-validator-identifier': 7.29.7 + '@dual-bundle/import-meta-resolve@4.2.1': {} + '@formatjs/fast-memoize@3.1.7': {} '@formatjs/icu-messageformat-parser@3.5.18': @@ -1454,6 +1477,32 @@ snapshots: '@rolldown/pluginutils@1.0.1': {} + '@stylexjs/babel-plugin@0.19.1': + dependencies: + '@babel/core': 7.29.7 + '@babel/helper-module-imports': 7.29.7 + '@babel/traverse': 7.29.10 + '@babel/types': 7.29.11 + '@dual-bundle/import-meta-resolve': 4.2.1 + '@stylexjs/shared': 0.19.1 + '@stylexjs/stylex': 0.19.1 + postcss-value-parser: 4.2.0 + transitivePeerDependencies: + - supports-color + + '@stylexjs/rollup-plugin@0.19.1': + dependencies: + '@babel/core': 7.29.7 + '@babel/plugin-syntax-flow': 7.29.7(@babel/core@7.29.7) + '@babel/plugin-syntax-jsx': 7.29.7(@babel/core@7.29.7) + '@babel/plugin-syntax-typescript': 7.29.7(@babel/core@7.29.7) + '@stylexjs/babel-plugin': 0.19.1 + lightningcss: 1.33.0 + transitivePeerDependencies: + - supports-color + + '@stylexjs/shared@0.19.1': {} + '@stylexjs/stylex@0.19.1': dependencies: css-mediaquery: 0.1.2 @@ -1749,6 +1798,8 @@ snapshots: cssesc: 3.0.0 util-deprecate: 1.0.2 + postcss-value-parser@4.2.0: {} + postcss@8.5.31: dependencies: nanoid: 3.3.20 diff --git a/dashboard-v2/src/App.tsx b/dashboard-v2/src/App.tsx index 1e5ca4643..32882be6b 100644 --- a/dashboard-v2/src/App.tsx +++ b/dashboard-v2/src/App.tsx @@ -1,12 +1,35 @@ +import { Suspense, lazy, useState } from "react"; + +import { AppShell } from "@astryxdesign/core/AppShell"; +import { HStack } from "@astryxdesign/core/Layout"; +import { SideNav, SideNavHeading, SideNavItem } from "@astryxdesign/core/SideNav"; import { Center } from "@astryxdesign/core/Center"; import { Text } from "@astryxdesign/core/Text"; +import { + ClipboardDocumentListIcon, + ServerStackIcon, +} from "@heroicons/react/24/outline"; -import StatusPage from "./pages/StatusPage.tsx"; +import { ArchieMark } from "./components/ArchieLogo.tsx"; import LoginPage from "./pages/LoginPage.tsx"; import { useSession } from "./session.tsx"; +const StatusPage = lazy(() => import("./pages/StatusPage.tsx")); +const TasksPage = lazy(() => import("./pages/TasksPage.tsx")); + +function PageFallback(): React.JSX.Element { + return ( +
+ Loading… +
+ ); +} + +type Page = "tasks" | "status"; + export default function App() { const { state } = useSession(); + const [page, setPage] = useState("tasks"); if (state === "unknown") { return ( @@ -25,5 +48,37 @@ export default function App() { ); } if (state === "guest") return ; - return ; + + return ( + + + + + } + > + setPage("tasks")} + /> + setPage("status")} + /> + + } + > + }> + {page === "tasks" ? : } + + + ); } diff --git a/dashboard-v2/src/lib/api.ts b/dashboard-v2/src/lib/api.ts index f621ee991..f11185d1c 100644 --- a/dashboard-v2/src/lib/api.ts +++ b/dashboard-v2/src/lib/api.ts @@ -96,8 +96,63 @@ export interface AuthStatus { instance?: string; } +export interface StatusMeta { + id: string; + label: string; + kind: "ok" | "warn" | "danger" | "info" | "idle"; + needs_attention?: boolean; +} + +export interface TaskMeta { + statuses?: StatusMeta[]; +} + +export interface Task { + id: number | string; + title?: string; + owner?: string; + repo?: string; + status?: string; + workflow?: string; + attempt?: number; + branch?: string; + plan?: string; + park_reason?: string; + created_at?: string; + updated_at?: string; + issue_url?: string; + pr_url?: string; + actions?: string[]; +} + +export interface TaskPageParams { + status?: string; + workflow?: string; + limit?: number; + cursor?: string | null; +} + export const api = { authStatus: () => request("/api/auth/status"), + taskMeta: () => request("/api/task-meta"), + // taskPage reads one page of tasks; next is the cursor for the page + // after it, or null when this page was the last. + taskPage: async (params: TaskPageParams) => { + const q = new URLSearchParams(); + if (params.status) q.set("status", params.status); + if (params.workflow) q.set("workflow", params.workflow); + q.set("limit", String(params.limit ?? 100)); + if (params.cursor) q.set("cursor", params.cursor); + const res = await fetch(`/api/tasks?${q}`, { + headers: { Accept: "application/json" }, + signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS), + }); + if (!res.ok) throw new ApiError(await errorMessage(res), res.status); + return { + tasks: (await res.json()) as Task[], + next: res.headers.get("X-Next-Cursor"), + }; + }, services: () => request("/api/services"), version: () => request<{ components: ComponentVersion[] }>("/api/version"), signIn: (email: string, password: string) => diff --git a/dashboard-v2/src/pages/TasksPage.tsx b/dashboard-v2/src/pages/TasksPage.tsx new file mode 100644 index 000000000..fbb5611d8 --- /dev/null +++ b/dashboard-v2/src/pages/TasksPage.tsx @@ -0,0 +1,4049 @@ +// Copyright (c) Meta Platforms, Inc. and affiliates. + +'use client'; + +/** + * Table page driven by a row of filter selectors. + * + * Each filterable field is a Selector, so the closed trigger doubles as the + * filter chip: unset it reads as the bare field name against the same outlined + * chrome as the search box, and once set it fills in and expands to the whole + * clause (`Status is Overdue`) with a clear beside it. Anything the selectors + * can't express — free numeric comparisons, OR groups — swaps to power search, + * and because both modes read the same filter array, a filter built either way + * survives the swap. + * + * The saved-views toggle swaps the same row for a list of saved views. + * A saved view is the whole screen — the filters plus the columns, density, + * sticky edges and grouping — so applying one restores the table as it was, + * and there is no separate column preset to disagree with it. + * + * Clicking a row opens its details in the end panel. + */ + +import {useCallback, useEffect, useId, useMemo, useRef, useState} from 'react'; +import type { + KeyboardEvent as ReactKeyboardEvent, + PointerEvent as ReactPointerEvent, + ReactNode, + SVGProps, +} from 'react'; +import * as stylex from '@stylexjs/stylex'; +import { + HStack, + Layout, + LayoutContent, + LayoutHeader, + LayoutPanel, + StackItem, + VStack, +} from '@astryxdesign/core/Layout'; +import { + borderVars, + colorVars, + durationVars, + easeVars, + fontWeightVars, + radiusVars, + spacingVars, + typeScaleVars, +} from '@astryxdesign/core/theme/tokens.stylex'; +import {Item} from '@astryxdesign/core/Item'; +import {List} from '@astryxdesign/core/List'; +import {VisuallyHidden} from '@astryxdesign/core/VisuallyHidden'; +import {useAnnounce, useMediaQuery} from '@astryxdesign/core/hooks'; +import {BottomSheet} from '@astryxdesign/core/BottomSheet'; +import {OverflowList} from '@astryxdesign/core/OverflowList'; +import type {OverflowItem} from '@astryxdesign/core/OverflowList'; +import {Tab, TabList} from '@astryxdesign/core/TabList'; +import {MetadataList, MetadataListItem} from '@astryxdesign/core/MetadataList'; +import {Heading, Text} from '@astryxdesign/core/Text'; +import {Button} from '@astryxdesign/core/Button'; +import {Card} from '@astryxdesign/core/Card'; +import {IconButton} from '@astryxdesign/core/IconButton'; +import {ToggleButton} from '@astryxdesign/core/ToggleButton'; +import {Icon} from '@astryxdesign/core/Icon'; +import {Token} from '@astryxdesign/core/Token'; +import {Badge} from '@astryxdesign/core/Badge'; +import {TextInput} from '@astryxdesign/core/TextInput'; +import {Selector} from '@astryxdesign/core/Selector'; +import {RadioList, RadioListItem} from '@astryxdesign/core/RadioList'; +import {Popover} from '@astryxdesign/core/Popover'; +import {Link} from '@astryxdesign/core/Link'; +import {Dialog, DialogHeader} from '@astryxdesign/core/Dialog'; +import {Divider} from '@astryxdesign/core/Divider'; +import {Section} from '@astryxdesign/core/Section'; +import {EmptyState} from '@astryxdesign/core/EmptyState'; +import {MultiSelector} from '@astryxdesign/core/MultiSelector'; +import {ProgressBar} from '@astryxdesign/core/ProgressBar'; +import {ResizeHandle, useResizable} from '@astryxdesign/core/Resizable'; +import {Skeleton} from '@astryxdesign/core/Skeleton'; +import { + PowerSearch, + usePowerSearchConfig, +} from '@astryxdesign/core/PowerSearch'; +import type {PowerSearchFilter} from '@astryxdesign/core/PowerSearch'; +import { + Table, + pixel, + proportional, + useTableGroupedRows, + useTableSortable, + useTableStickyColumns, +} from '@astryxdesign/core/Table'; +import type {TableColumn, TablePlugin} from '@astryxdesign/core/Table'; +import { + Bookmark, + BookmarkPlus, + ChevronDown, + Columns3, + GripVertical, + Pencil, + Pin, + Plus, + Search, + SlidersHorizontal, + Table as TableIcon, + Table2, + X, +} from 'lucide-react'; +import {useInfiniteQuery, useQuery} from '@tanstack/react-query'; +import {ApiError, api, type StatusMeta, type Task} from '../lib/api.ts'; +import {useSession} from '../session.tsx'; + +// Lucide draws outlines, so a "filled" counterpart is the same glyph with its +// interior painted. `Icon` takes any SVG component, which is the supported way +// to hand it a variant the icon set does not ship as its own export. +const BookmarkFilled = (props: SVGProps) => ( + +); +const SlidersHorizontalFilled = (props: SVGProps) => ( + +); + +// ============================================================================= +// Data +// ============================================================================= + +/** A row of the tasks table, mapped from the served task. */ +interface TaskRow extends Record { + id: string; + title: string; + owner: string; + repo: string; + /** Server status id; labels come from the task-meta catalog. */ + status: string; + workflow: string; + attempt: number; + branch: string; + createdAt: string; + /** ISO timestamp — the column sorts on this, so it stays a string. */ + updatedAt: string; + /** + * The same instant as updatedAt, as a Date. Power search rejects a string + * date outright, so the date filters read this field while the column reads + * the string above. + */ + updatedOn: Date; + /** needs_attention when the catalog flags the row's status, else routine. */ + attention: 'needs_attention' | 'routine'; + issueUrl: string; + prUrl: string; + parkReason: string; +} + +/** + * The hue variants, not the semantic ones. `warning` and `error` paint a solid + * fill straight from --color-warning / --color-error, and a theme is free to + * tune those as ink for text rather than as a surface — the neutral theme does, + * so a danger badge comes out a muddy maroon block. The hue variants read + * their own background/text pair, which is a tint in every theme, so a column + * of these stays legible wherever the page is themed. Red is left to carry the + * states worth chasing. + */ +const KIND_BADGE = { + ok: 'green', + warn: 'orange', + danger: 'red', + info: 'blue', + idle: 'neutral', +} as const; + +/** Sort-by-status reads worst-first: danger, warn, info, idle, ok. */ +const KIND_RANK: Record = { + danger: 0, + warn: 1, + info: 2, + idle: 3, + ok: 4, +}; + +/** The needs-attention pseudo value, evaluated from the catalog's flags. */ +const NEEDS_ATTENTION = 'needs_attention'; + +/** Server page size behind the infinite scroll. */ +const TASK_PAGE_LIMIT = 100; +/** Loaded-row ceiling before the list asks for narrower filters. */ +const MAX_TASKS = 500; +/** Live refresh while the page is visible. */ +const TASK_REFRESH_MS = 15_000; +/** localStorage key for the reader's saved views. */ +const SAVED_VIEWS_KEY = 'archie-v2:tasks.views'; + +/** Plain values a filter array holds for one enum field. */ +function enumValuesOf( + filters: PowerSearchFilter[], + field: string, +): string[] { + const values: string[] = []; + for (const f of filters) { + if (f.field !== field) { + continue; + } + const v = f.value as {type?: string; value?: unknown}; + if (v.type === 'enum' && typeof v.value === 'string') { + values.push(v.value); + } else if (v.type === 'enum_list' && Array.isArray(v.value)) { + values.push(...v.value.filter((x): x is string => typeof x === 'string')); + } + } + return [...new Set(values)]; +} + +function hasFilter(filters: PowerSearchFilter[], field: string): boolean { + return filters.some(f => f.field === field); +} + +const MONTHS = [ + 'Jan', + 'Feb', + 'Mar', + 'Apr', + 'May', + 'Jun', + 'Jul', + 'Aug', + 'Sep', + 'Oct', + 'Nov', + 'Dec', +]; + +/** + * UTC-based formatters, so the fixed fixtures render identically everywhere. + * A locale-aware Timestamp would shift these by the viewer's offset and then + * disagree with the table column beside it. + */ +function formatTime(iso: string): string { + const d = new Date(iso); + const hours = d.getUTCHours(); + const minutes = String(d.getUTCMinutes()).padStart(2, '0'); + const suffix = hours < 12 ? 'am' : 'pm'; + const hour12 = hours % 12 === 0 ? 12 : hours % 12; + return `${hour12}:${minutes}${suffix}`; +} + +function formatDate(iso: string, withYear = false): string { + const d = new Date(iso); + const base = `${MONTHS[d.getUTCMonth()]} ${d.getUTCDate()}`; + return withYear ? `${base}, ${d.getUTCFullYear()}` : base; +} + +const formatUpdated = (iso: string) => + `${formatDate(iso)}, ${formatTime(iso)}`; + +// ============================================================================= +// Filter configuration +// +// One config backs both the token list and power search, so the two are always +// describing the same filter array. The configs live in the component: status +// options come from the task-meta catalog and workflow options from the +// loaded rows, so neither can be a module constant. +// ============================================================================= + +/** + * A single-value field in the filter bar, rendered as a Button-triggered + * dropdown so the closed trigger doubles as the chip. + */ +interface FilterField { + key: string; + label: string; + operator: string; + operatorLabel: string; + /** Filter value type handed to power search, so both modes agree. */ + valueType: 'enum' | 'integer'; + options: ReadonlyArray<{value: string; label: string}>; +} + +interface MultiFilterField { + key: string; + label: string; + options: ReadonlyArray<{value: string; label: string}>; +} + +// ============================================================================= +// View options +// ============================================================================= + +type ViewSection = 'columns' | 'density' | 'sticky' | 'grouping'; +type Density = 'compact' | 'balanced' | 'spacious'; +type StickyEdge = 'none' | 'one' | 'two'; +/** Field the rows section under. 'none' leaves the table flat. */ +type GroupField = 'none' | 'status' | 'workflow'; + +const VIEW_SECTIONS: ReadonlyArray<{ + key: ViewSection; + label: string; + icon: React.ReactNode; + title: string; +}> = [ + { + key: 'columns', + label: 'Columns', + icon: , + title: 'Columns', + }, + { + key: 'density', + label: 'Density', + icon: , + title: 'Density', + }, + { + key: 'sticky', + label: 'Sticky Columns', + icon: , + title: 'Sticky Columns', + }, + { + key: 'grouping', + label: 'Grouping', + icon: , + title: 'Grouping', + }, +]; + +const DENSITY_OPTIONS: ReadonlyArray<{value: Density; label: string}> = [ + {value: 'compact', label: 'Compact'}, + {value: 'balanced', label: 'Balanced'}, + {value: 'spacious', label: 'Spacious'}, +]; + +/** + * Split by edge, because an edge names its own columns — "First two columns" + * against the start, "Last two columns" against the end. Naming them here is + * what lets the radio list and a saved view's summary state a frozen edge in + * the same words. + */ +const STICKY_START_OPTIONS: ReadonlyArray<{ + value: StickyEdge; + label: string; +}> = [ + {value: 'none', label: 'None'}, + {value: 'one', label: 'First column'}, + {value: 'two', label: 'First two columns'}, +]; + +const STICKY_END_OPTIONS: ReadonlyArray<{value: StickyEdge; label: string}> = [ + {value: 'none', label: 'None'}, + {value: 'one', label: 'Last column'}, + {value: 'two', label: 'Last two columns'}, +]; + +const GROUPING_OPTIONS: ReadonlyArray<{value: GroupField; label: string}> = [ + {value: 'none', label: 'None'}, + {value: 'status', label: 'Status'}, + {value: 'workflow', label: 'Workflow'}, +]; + +/** + * The words a section is titled with. The group key is what the heading prints, + * so it has to be the label and not the stored value — grouping by status would + * otherwise head its sections "waiting_approval". Workflow names are stored as + * their own labels already, which is what the fallback covers. + */ +function groupKeyOf( + row: TaskRow, + field: GroupField, + labels: Record, +): string { + if (field === 'none') { + return ''; + } + const stored = String(row[field]); + return labels[stored] ?? stored; +} + +/** Row-key prefix the grouped-rows plugin gives its synthetic header rows. */ +const GROUP_ROW_KEY_PREFIX = '__group_'; + +/** Fed to the grouping hook while grouping is off, so it flattens nothing. */ +const NO_ROWS: TaskRow[] = []; + +const COLUMN_LABELS: Record = { + title: 'Task', + status: 'Status', + workflow: 'Workflow', + attempt: 'Attempt', + updatedAt: 'Updated', + owner: 'Owner', + repo: 'Repository', + branch: 'Branch', + createdAt: 'Created', +}; + +const ALL_COLUMN_KEYS = [ + 'title', + 'status', + 'workflow', + 'attempt', + 'updatedAt', + 'owner', + 'repo', + 'branch', + 'createdAt', +]; +const DEFAULT_COLUMN_KEYS = [ + 'title', + 'status', + 'workflow', + 'attempt', + 'updatedAt', +]; + +/** + * The column that names the row. A table of tasks with no task on it is a + * table of orphaned attributes, so this one stays: its remove control is + * disabled and says why. Position is not identity, so it still reorders like + * any other. + */ +const LOCKED_COLUMN_KEY = 'title'; +const LOCKED_COLUMN_MESSAGE = 'Task names every row, so it cannot be removed.'; + +/** Pointer travel before a press on the grip becomes a drag rather than a tap. */ +const REORDER_DRAG_THRESHOLD = 5; + +/** + * A reorder in flight. Positions are indices into the *visible* displayed list + * — the one the reader is looking at — so a search that hides rows cannot make + * the arrow keys or the drop indicator point somewhere off screen. + */ +interface ColumnReorderSession { + key: string; + mode: 'keyboard' | 'pointer'; + /** Visible order as it was when the drag began; the drag reads from this. */ + originalKeys: string[]; + fromIndex: number; + toIndex: number; + pointerId?: number; + pointerStartY?: number; + hasPointerMoved?: boolean; +} + +/** Draft of every view option, so the panel can Cancel without touching the table. */ +interface ViewState { + columnKeys: string[]; + density: Density; + stickyStart: StickyEdge; + stickyEnd: StickyEdge; + grouping: GroupField; +} + +const INITIAL_VIEW: ViewState = { + columnKeys: DEFAULT_COLUMN_KEYS, + density: 'balanced', + stickyStart: 'one', + stickyEnd: 'none', + grouping: 'none', +}; + +/** + * The screen opens on the server's recency order — most recently updated + * first — with no filters set. The Needs attention saved view is one click + * away for the operator's triage pass. + */ +const INITIAL_FILTERS: PowerSearchFilter[] = []; + +const PAGE_SIZE = 15; + + +// ============================================================================= +// Saved views +// +// Declared after ViewState so a saved view can carry one. A view is the whole +// configuration of the screen, not just its filters: the columns on show and +// their order, plus density, sticky edges and grouping. That is what makes a +// column preset redundant — the columns travel with the view that named them. +// ============================================================================= + +interface SavedView { + id: string; + name: string; + filters: PowerSearchFilter[]; + /** Columns, density, sticky edges and grouping as they were when saved. */ + view: ViewState; +} + +const INITIAL_SAVED_VIEWS: SavedView[] = [ + { + id: 'needs-attention', + name: 'Needs attention', + filters: [ + { + field: 'attention', + operator: 'is', + value: {type: 'enum', value: NEEDS_ATTENTION}, + }, + ], + view: INITIAL_VIEW, + }, + { + id: 'by-workflow', + name: 'By workflow', + filters: [], + view: {...INITIAL_VIEW, grouping: 'workflow'}, + }, +]; + +// ============================================================================= +// Helpers +// ============================================================================= + +/** + * The surfaces below swap to a bottom sheet on a compact surface. + * + * Two terms, because there are two ways to be one. The second is the query the + * Dialog adaptive-presentation block uses — up to `lg` on a device whose + * pointer is a finger — and it is what catches a tablet that has the width for + * a popover but no hover to drive one. + * + * The first is width alone, at any input. A 660px popover and a resizable side + * panel need room the window no longer has well before the pointer changes: + * below `md` the popover has nowhere to sit, and the panel leaves the table a + * couple of columns wide. A mouse does not rescue a layout that does not fit, + * so the narrow window gets sheets too. + */ +const COMPACT_SURFACE_QUERY = + '(max-width: 768px), (max-width: 1024px) and (pointer: coarse) and (hover: none)'; + +/** + * Top padding for whatever opens a BottomSheet, on the spacing scale. + * + * The panel's grab pill floats over the content instead of reserving layout + * space for itself: it is 4px centered in a 24px band, so it covers the top + * 10-14px of the sheet. Content that starts at the usual 16px gutter clears it + * by 2px, which does not read as a gap — it reads as the sheet being cut off. + * Opening at the full 24px band puts real space under the pill, and every + * sheet here uses this one value so they all start on the same line. + */ +const SHEET_TOP_INSET = 6; + +/** + * Width the filter row holds back, in px, for the readout that trails the + * clauses — the density toggle, the result count and Clear all. + * + * The readout sits inside the slot the overflow list measures, so without this + * the list would count the readout's width as room for another clause and + * push it off the end. The slot pays for it as padding, which is the one part + * of the slot the measurement already subtracts, and the readout takes the + * width back with a matching negative margin so it still lands against the + * last clause instead of at the far edge. + * + * Deliberately a little wider than the readout draws at the counts this page + * reaches, because the two failure directions are not symmetric: too wide only + * folds a clause marginally early, while too narrow puts the readout over the + * edge of the row. + */ +const READOUT_RESERVE = 184; + +/** + * Stands in for Relay's `usePaginationFragment` so the table can grow by + * batches instead of flipping pages. It returns the same + * `{data, hasNext, isLoadingNext, loadNext}` shape a Relay connection does, so + * a real screen swaps this line for `usePaginationFragment(QUERY, query)` and + * keeps everything below unchanged. + */ +function useInfiniteBatches( + items: readonly T[], + pageSize: number, + getGroupKey?: ((item: T) => string) | null, +): { + data: T[]; + hasNext: boolean; + isLoadingNext: boolean; + loadNext: (count: number) => void; +} { + const [loadedCount, setLoadedCount] = useState(pageSize); + const [isLoadingNext, setIsLoadingNext] = useState(false); + const inFlightRef = useRef(false); + + // A new filter/sort result is a new connection: start from the first batch. + useEffect(() => { + inFlightRef.current = false; + setIsLoadingNext(false); + setLoadedCount(pageSize); + }, [items, pageSize]); + + // A cut that lands mid-section leaves that section half-filled, and a reader + // has no way to tell one that is still arriving from one that is genuinely + // short — so the rows they can see are not a section they can trust. Carry + // the cut to the end of whichever section it lands in. Sections are + // contiguous because `results` sorts by group first, so this walks the tail + // of one section and stops. + const visibleCount = useMemo(() => { + if (loadedCount >= items.length) { + return items.length; + } + if (getGroupKey == null) { + return loadedCount; + } + const openKey = getGroupKey(items[loadedCount - 1]); + let end = loadedCount; + while (end < items.length && getGroupKey(items[end]) === openKey) { + end++; + } + return end; + }, [getGroupKey, items, loadedCount]); + + // The next batch counts from what is on screen, not from the raw cut, so + // rows a snap already pulled in are not paid for twice. Held in a ref to + // keep loadNext stable — it is an effect dependency of the sentinel. + const visibleCountRef = useRef(visibleCount); + visibleCountRef.current = visibleCount; + + const loadNext = useCallback((count: number) => { + if (inFlightRef.current) { + return; + } + inFlightRef.current = true; + setIsLoadingNext(true); + // Stands in for the network round trip Relay would make here. + setTimeout(() => { + setLoadedCount(visibleCountRef.current + count); + setIsLoadingNext(false); + inFlightRef.current = false; + }, 500); + }, []); + + const data = useMemo( + () => items.slice(0, visibleCount), + [items, visibleCount], + ); + + return {data, hasNext: visibleCount < items.length, isLoadingNext, loadNext}; +} + +/** + * Each value is looked up before the join, not after: a many-of clause carries + * a list of enum keys, and joining first would hand valueLabels the string + * "on_hold, overdue", miss, and print the wire names. + */ +function filterValueText( + filter: PowerSearchFilter, + labels: Record, +): string { + const raw = (filter.value as {value?: unknown}).value; + const label = (v: unknown) => { + const key = String(v ?? ''); + return labels[key] ?? key; + }; + return Array.isArray(raw) ? raw.map(label).join(', ') : label(raw); +} + +/** Reads as the operator does in a power search token, not as its wire name. */ +const OPERATOR_LABELS: Record = { + is: 'is', + is_any_of: 'is any of', + greater_than_or_equal: '≥', + less_than_or_equal: '≤', + after: 'after', +}; + +/** + * One clause phrased the way power search phrases it, so a saved view's filters + * read the same wherever they are shown. + */ +function filterTokenLabel( + filter: PowerSearchFilter, + defs: ReadonlyArray<{key: string; label: string}>, + labels: Record, +): string { + const field = defs.find(f => f.key === filter.field); + const name = field?.label ?? filter.field; + const operator = OPERATOR_LABELS[filter.operator] ?? filter.operator; + const raw = filter.value as {value?: unknown; unixSeconds?: number}; + let value: string; + if (typeof raw.unixSeconds === 'number') { + // A date clause carries unixSeconds rather than `value`, so it would + // otherwise render as a bare "Updated after" with nothing after it. + value = formatDate(new Date(raw.unixSeconds * 1000).toISOString(), true); + } else if (Array.isArray(raw.value) && raw.value.length > 1) { + // Spelling out every selection makes a token wider than the dialog, and a + // token that ellipsises mid-name is worse than an honest count. + const [first, ...rest] = raw.value.map(v => labels[String(v)] ?? v); + value = `${first} +${rest.length}`; + } else { + value = filterValueText(filter, labels); + } + return `${name} ${operator} ${value}`; +} + +const stickyKeys = ( + edge: StickyEdge, + keys: string[], + fromEnd: boolean, +): string[] => { + const count = edge === 'one' ? 1 : edge === 'two' ? 2 : 0; + if (count === 0) { + return []; + } + return fromEnd ? keys.slice(-count) : keys.slice(0, count); +}; + +const styles = stylex.create({ + // height="fill" resolves to height:100%, which needs a definite height the + // host's / don't set. Without it the shell grows to fit the + // table, the document scrolls, and the end panel rides away with it. + pageShell: { + height: '100dvh', + // Layout is transparent by design, so without this the shell inherits + // whatever the host paints. That reads fine on a bare UA canvas but puts + // dark-mode text on a light page the moment the host has a background of + // its own. Owning the surface makes the page legible wherever it is + // embedded. + backgroundColor: colorVars['--color-background-surface'], + // A pinned cell paints an opaque base so scrolled content cannot show + // through it, and that base defaults to the card token — right for a table + // inside a card, wrong for this one, which sits on the page surface. Both + // tokens are the same white in light mode, so the mismatch only surfaces + // in dark, as a darker band exactly where the frozen columns are. + '--table-sticky-background': colorVars['--color-background-surface'], + }, + // A wrapped row's `gap` sets both axes, and 8px between stacked lines is more + // air than these need; the row gap is tightened back to 6 on its own. + bar: { + rowGap: 6, + }, + // Collapses rather than wrapping: clauses that no longer fit fold into the + // overflow trigger, so the row is one line at every width. + filterRow: { + rowGap: 6, + }, + // This slot is what `observeParent` measures, so its width has to mean "the + // room the clauses have" and nothing else. Grow is the part that makes that + // true: as the row's only grower it settles at the width left over once the + // search box has taken its share, whatever the clauses inside happen to add + // up to. + // + // Left at grow 0 the slot is flex-basis auto, which is to say content-sized, + // and that feeds the list its own output: collapse one clause, the content + // narrows, the slot narrows with it, the list re-reads the smaller number + // and collapses again. It runs all the way down to `minVisibleItems` in one + // pass. At 1200px that showed as a single clause and a +6 next to 500px of + // empty row. Grow breaks the circuit by sizing the slot from the row instead + // of from the clauses. + // + // The slot is also the readout's container rather than its sibling, which is + // what keeps the readout beside the last clause instead of riding the row's + // trailing edge — see READOUT_RESERVE for how its width is kept out of the + // measurement. + filterOverflowSlot: { + display: 'flex', + alignItems: 'center', + flexGrow: 1, + // The held-back width, as padding because padding is the one part of the + // box the measurement already subtracts. + paddingInlineEnd: READOUT_RESERVE, + // Weighted far above the search box's 1 so the row gives in an order + // rather than proportionally. Flex shares a deficit by shrink factor times + // basis, so a 100 here means the clauses fold away to the bare count + // before the field gives up its first pixel, and the field only starts + // shrinking once there is nothing left to fold. + flexShrink: 100, + // Where folding stops. StackItem resets min-width to 0, and with a shrink + // this aggressive that lets the slot pass the collapsed state and clip the + // count itself — the filters are then set, applied, and unreachable, with + // nothing on the row to say so. The floor is the trigger's own 44px plus + // the reserve, because min-width bounds the border box and the reserve is + // padding inside it — 44 on its own would floor a slot with nothing left + // to put the trigger in. The last thing the row gives up is the way back + // to what it folded. + minWidth: 44 + READOUT_RESERVE, + }, + // See the note in FilterOverflow: a flex column stretches its child, which + // is what puts the button-backed presets on the same edge as the selectors. + overflowItem: { + display: 'flex', + flexDirection: 'column', + }, + // Queried rather than @media: opening the detail panel narrows this header + // without the viewport changing, and that is the width the toolbar actually + // has to fit in. + toolbarContainer: { + containerName: 'toolbar', + containerType: 'inline-size', + }, + // Taking the full line forces the trailing cluster onto a second row. Below + // this the filter row and the view controls were splitting the width so + // evenly that neither had enough: the filters were collapsing into overflow + // while the buttons still had room to spare. + toolbarPrimary: { + flexBasis: { + default: 0, + '@container toolbar (max-width: 860px)': '100%', + }, + }, + // Holds the cluster against the end edge on its own row, where it would + // otherwise sit under the filters at the start. + toolbarEnd: { + marginInlineStart: 'auto', + }, + // Takes back the width the slot held back for it, so the readout draws over + // the reserve rather than after it and lands against the last clause. The + // gap to that clause is a margin rather than the slot's `gap`, because a gap + // would fall on the measured side of the reserve and cost the clauses the + // last few pixels they were measured to have. + filterMeta: { + flexShrink: 0, + marginInlineStart: 8, + marginInlineEnd: -READOUT_RESERVE, + }, + savedViewsLabel: { + flexShrink: 0, + }, + // Basis auto so the slot is exactly as wide as the chips while they fit — + // shrinking only once they do not, which is the width the scroller inside + // then has to work with. + savedViewsSlot: { + flexShrink: 1, + minWidth: 0, + }, + savedViewsScroller: { + overflowX: 'auto', + // The row is one line: without this the block axis picks up a scrollbar of + // its own the moment the inline one appears. + overflowY: 'hidden', + // Keeps a swipe that runs off the end of the chips from turning into a + // page scroll, which on a phone reads as the whole view lurching sideways. + overscrollBehaviorInline: 'contain', + // No scrollbar under a 32px row: it would eat as much height as the chips + // and sit there permanently on the platforms that reserve space for it. + // The chip cut off at the edge is the affordance instead, and every chip + // is a button, so tabbing scrolls the next one into view for a keyboard. + scrollbarWidth: 'none', + }, + // In a nowrap row that scrolls, a shrinkable child squeezes to fit rather + // than overflowing: without this the chips compress into unreadable stubs + // and the scroller never has anything to scroll. + savedViewChip: { + flexShrink: 0, + }, + // A saved view can carry more clauses than the dialog is wide. + tokenWrap: { + flexWrap: 'wrap', + rowGap: 4, + }, + // Token ellipsises on overflow, but only once it is allowed to shrink below + // its content; without this a long clause runs past the dialog edge instead. + filterToken: { + minWidth: 0, + maxWidth: '100%', + }, + progress: { + position: 'absolute', + insetBlockStart: 0, + insetInline: 0, + }, + headerWrap: { + position: 'relative', + }, + + // Sits at the width of the filter selectors beside it so the row reads as + // one family of controls, and widens on focus for typing room. TextInput's + // `width` prop is the sanctioned way to size a field, but it takes one + // static value and cannot express a focus variant, so the width lives here. + // + // On the slot rather than on the field: TextInput's `xstyle` lands on an + // element inside its outer wrapper, and that wrapper is the row's actual + // flex item. Sized from within, the wrapper keeps `min-width: auto`, its + // min-content becomes the focused 240px, and no shrink factor can move it — + // the field stays rigid and pushes the readout off the end of the row. A + // StackItem resets that min-width, so the width and the give belong to the + // same box and the field can widen into space it actually has. + // + // `:focus-within` is in scope here for the same reason it was on the field: + // the focused input is a descendant either way, so no React state is needed. + searchSlot: { + // Second in line to give, behind the overflow slot's 100 and ahead of the + // readout's 0 (see filterOverflowSlot). The focus width is a request + // rather than a reservation: a 393px row cannot seat 240px of search and + // still show "Clear all", so the field takes what the folded clauses left + // and stops there — full width where the window has it, a little under it + // where it does not. + flexShrink: 1, + // Never narrower than its resting width, so a tight row cannot grind the + // field down to a stub. Costs nothing idle: 120 is where it already sits. + minWidth: 120, + width: { + default: 120, + ':focus-within': 240, + }, + transitionProperty: 'width', + transitionDuration: { + default: durationVars['--duration-fast'], + '@media (prefers-reduced-motion: reduce)': '0s', + }, + transitionTimingFunction: easeVars['--ease-standard'], + }, + // ButtonVariantMap has no outline variant, so the Button-backed toggles in + // the row paint the field chrome the selectors beside them draw natively — + // same border token, same radius — rather than reading as a different + // family of control. + filterChrome: { + borderWidth: borderVars['--border-width'], + borderStyle: 'solid', + borderColor: colorVars['--color-border-emphasized'], + borderRadius: radiusVars['--radius-element'], + }, + filterSurface: { + backgroundColor: colorVars['--color-background-surface'], + }, + // The fill a control switches to once it carries a value. This is the token + // ToggleButton paints for its own pressed state, so a set selector and a + // pressed preset land on the same value over the same backdrop instead of + // two neighbouring shades of engaged. + filterFill: { + backgroundColor: colorVars['--color-overlay-pressed'], + }, + + // A Selector states its own emptiness typographically — placeholder weight + // and secondary text unset, body weight and primary text once it holds a + // value. Button labels are medium and always primary, so without this the + // unpressed toggles sit heavier and darker than the unset selectors they + // are meant to match. + filterLabelValue: { + fontWeight: fontWeightVars['--font-weight-normal'], + }, + filterLabelEmpty: { + fontWeight: fontWeightVars['--font-weight-normal'], + color: colorVars['--color-text-secondary'], + }, + // Popover paints a 12px gutter on its content container and publishes no + // padding prop, so the only way to a flush container is xstyle. It lands on + // that same container, and these are the exact longhands Popover sets — a + // `padding` shorthand would compile to the physical properties and leave the + // logical ones standing. Flush, the rail's divider and the footer rule reach + // the popover edges, and each region below re-states its own gutter. + viewPopoverSurface: { + paddingBlockStart: 0, + paddingBlockEnd: 0, + paddingInlineStart: 0, + paddingInlineEnd: 0, + }, + // The popover's height is set here rather than left to each section, so it + // doesn't resize under the pointer as the reader moves down the rail — the + // trigger is at the top right, so a shrinking panel would walk the rail out + // from under the cursor. Columns fills this height and scrolls inside it; + // the other three are shorter and are padded out to it. + // + // A fixed height, not a minimum: min-height alone is a floor, so a long + // column list would still push the popover past it, and a panel can only + // scroll once some ancestor gives it a height to scroll within. + viewPopover: { + blockSize: 448, + }, + // ESCAPE HATCH (see report): DialogHeader takes no `padding`, and inside a + // Dialog its LayoutHeader adds the dialog's own gutter a second time — the + // title lands at 32px while a Section body lands at 16px. Section escapes + // this by negative-margining out of the container padding before it pads + // itself; Layout does the same, which is why the canonical block puts one + // between Dialog and DialogHeader. Same escape, applied to the header + // directly, so its own 16px is the only gutter. Block-end is left alone — + // the header's bottom padding is real spacing, not an edge to cancel. + dialogHeaderBleed: { + marginInlineStart: 'calc(-1 * var(--container-padding-inline-start, 0px))', + marginInlineEnd: 'calc(-1 * var(--container-padding-inline-end, 0px))', + marginBlockStart: 'calc(-1 * var(--container-padding-block-start, 0px))', + }, + // Wide enough for "Sticky Columns" on one line once the rail carries its own + // gutter rather than borrowing the popover's. + viewRail: { + width: 184, + flexShrink: 0, + }, + // Pairs with the rail's 4px gutter: the item keeps Button's own + // --radius-element and sits inside the popover's --radius-container, so the + // two corners curve together instead of the item squaring off in a rounded + // box. Both tokens move with the theme's radius multiplier, so the pairing + // survives a theme swap. + railItem: { + width: '100%', + justifyContent: 'flex-start', + }, + // Starts the strip on the sheet's own 16px gutter instead of the container + // edge, so the first tab lines up with the panel below it. Padding rather + // than margin: on a scroller the gutter has to be part of the scrollable box + // or the strip cannot scroll its last tab clear of the trailing edge. + // + // Inline only. The sheet's top inset is the wrapper's, not this box's: the + // strip's scroll arrow is absolutely positioned against this box at + // inset-block-start 0, so block padding here pushes the tabs down and leaves + // the arrow hanging above the row it scrolls. + viewSheetTabs: { + paddingInline: 16, + }, + // Full height so the transfer panels can reach the popover floor: sized to + // its content instead, the pane stops short and the rule between the panels + // ends in mid-air — most visibly when a search empties both sides. + viewPanel: { + blockSize: '100%', + flexGrow: 1, + minWidth: 0, + }, + // --- Columns transfer list ------------------------------------------------- + // Copies the lab TransferList's panel chrome rather than importing it: that + // package is unpublished and does not resolve from the template viewer, so + // the visual contract is restated here against the same tokens. + // The lab component stacks its panels under `@container (max-width: 40rem)`. + // That query is not carried over: this pane is the popover's 660px less the + // 184px rail and its gutters — about 28rem — so the stacked branch would be + // the only one that ever ran, and side by side is the layout this panel is + // for. The pane has no other width to respond to; the popover is fixed. + transferRoot: { + flexGrow: 1, + minHeight: 0, + minWidth: 0, + }, + // The pair runs to the pane's edges, so the rule between them is full height + // and each panel's header rule reaches its own edges. Nothing here is padded: + // the gutter lives on the header, the rows and the empty state instead, via + // the two Pad styles below. + transferPanels: { + flexGrow: 1, + minHeight: 0, + minWidth: 0, + }, + // flexBasis 0 with grow splits the row into two equal halves; the two minimums + // then let a half shrink below its content instead of pushing the popover + // wider or taller than the height every other section is held to, which is + // what lets a long column list scroll inside its own panel. + transferPanel: { + flexBasis: 0, + flexGrow: 1, + minBlockSize: 0, + minWidth: 0, + overflow: 'hidden', + }, + // 16px against the pane's outer edge, 12px against the divider: the outer + // gutter matches the heading above, and the inner one only has to clear a + // 1px rule. + transferPadStart: { + paddingInlineEnd: spacingVars['--spacing-3'], + paddingInlineStart: spacingVars['--spacing-4'], + }, + transferPadEnd: { + paddingInlineEnd: spacingVars['--spacing-4'], + paddingInlineStart: spacingVars['--spacing-3'], + }, + transferPanelDivider: { + borderInlineStartColor: colorVars['--color-border'], + borderInlineStartStyle: 'solid', + borderInlineStartWidth: borderVars['--border-width'], + }, + transferPanelHeader: { + borderBlockEndColor: colorVars['--color-border'], + borderBlockEndStyle: 'solid', + borderBlockEndWidth: borderVars['--border-width'], + }, + // The bulk action sits on the header rule beside a label, where button chrome + // would outweigh the list it acts on. Stripped to a text link, it reads as + // secondary to the rows without losing the accent that marks it actionable. + transferHeaderAction: { + backgroundImage: { + default: 'none', + ':hover:where(:not(:disabled,[aria-disabled="true"]))': 'none', + ':active': 'none', + }, + borderRadius: 0, + color: colorVars['--color-text-accent'], + fontSize: typeScaleVars['--text-body-size'], + fontWeight: typeScaleVars['--text-body-weight'], + height: 'auto', + lineHeight: typeScaleVars['--text-body-leading'], + paddingBlock: 0, + paddingInline: 0, + textDecoration: { + default: 'none', + ':hover:where(:not(:disabled,[aria-disabled="true"]))': 'underline', + }, + }, + // Each panel scrolls its own rows within whatever height the pane gives it, + // so adding columns lengthens a list instead of growing the popover past the + // viewport. The floor is the popover's own minHeight rather than a size set + // here, which is what keeps the four tabs the same height. + transferPanelBody: { + flexGrow: 1, + minBlockSize: 0, + overflowY: 'auto', + overscrollBehavior: 'contain', + scrollbarGutter: 'stable', + }, + // Padded by transferPadStart/End rather than Item's own gutter, so a row's + // hover and selected fill runs the full width of the panel while its text + // stays on the header's start line. The grip and the end action then pull + // back by their own button inset (transferGrip, transferEndAction) so it is + // the glyph that lands on the line, not the invisible button box. + transferItem: { + minWidth: 0, + transitionDuration: { + default: durationVars['--duration-fast'], + '@media (prefers-reduced-motion: reduce)': '0s', + }, + transitionProperty: 'background-color, opacity', + transitionTimingFunction: easeVars['--ease-standard'], + }, + // A keyboard pick-up has no pointer under it to say what is moving, so the + // row itself carries the state. + transferItemPicked: { + backgroundColor: colorVars['--color-accent-muted'], + }, + transferEmpty: { + textAlign: 'center', + }, + // A ghost IconButton insets its glyph by --spacing-1-5; cancelling that puts + // the grip itself on the panel's start line rather than the button box. + transferGrip: { + marginInlineStart: `calc(-1 * ${spacingVars['--spacing-1-5']})`, + }, + // Same cancellation at the other edge, so the row's action lands on the end + // line that "Restore" and "Select all" sit on. + transferEndAction: { + marginInlineEnd: `calc(-1 * ${spacingVars['--spacing-1-5']})`, + }, + clickableRow: { + cursor: 'pointer', + }, + // One step past hover in the same neutral ramp. A muted fill can't carry + // this on its own — --color-background-muted resolves to the identical + // value as --color-overlay-hover. Row background belongs to this state + // alone: selection opts out of its wash so the two never compete. + activeRow: { + backgroundColor: colorVars['--color-overlay-pressed'], + // A pinned cell paints an opaque background of its own, which would cover + // the row's. Publishing the overlay is how the sticky plugin picks it up + // and replays it, the same way TableRow does for striping and hover. + '--table-row-overlay': colorVars['--color-overlay-pressed'], + }, + // A flex child has no definite width for AspectRatio to derive a height + // from, so the tile is pinned here and told not to give the width back when + // the cell runs short. + jobMedia: { + backgroundColor: colorVars['--color-background-muted'], + borderRadius: radiusVars['--radius-element'], + flexShrink: 0, + width: spacingVars['--spacing-12'], + }, + detailPanel: { + minWidth: 0, + }, + skeletonRow: { + // The table drops the divider under its last row, so each placeholder + // carries its own on top — one line between every row, none trailing. + borderBlockStartColor: colorVars['--color-border'], + borderBlockStartStyle: 'solid', + borderBlockStartWidth: borderVars['--border-width'], + }, + // The table bleeds past this container to the layout edge and re-applies the + // inset on its outer cells. Matching that keeps the two grids on one axis. + skeletonBleed: { + marginInline: 'calc(-1 * var(--container-padding-inline-start, 0px))', + }, + skeletonEdgeStart: { + paddingInlineStart: 'var(--container-padding-inline-start, 0px)', + }, + skeletonEdgeEnd: { + paddingInlineEnd: 'var(--container-padding-inline-end, 0px)', + }, +}); + +/** + * The insertion rule the drop indicator draws. Absolute inside the row it marks + * and pulled half its own height clear of it, so it lands in the gap between + * two rows rather than on top of either. + */ +const reorderIndicator = { + backgroundColor: colorVars['--color-accent'], + borderRadius: radiusVars['--radius-full'], + content: '""', + height: spacingVars['--spacing-0-5'], + insetInline: 0, + pointerEvents: 'none' as const, + position: 'absolute' as const, + zIndex: 2, +}; + +/** + * The drag states a reorderable row moves through, mirroring the lab package's + * shared reorderStyles: the row being dragged fades to half, the row the + * pointer is over grows an accent rule on the side the drop would land, and the + * grip carries the grab cursors. + */ +const reorderStyles = stylex.create({ + source: { + opacity: 0.5, + userSelect: 'none', + }, + dropBefore: { + position: 'relative', + '::before': { + ...reorderIndicator, + insetBlockStart: `calc(-1 * ${spacingVars['--spacing-0-5']})`, + }, + }, + dropAfter: { + position: 'relative', + '::after': { + ...reorderIndicator, + insetBlockEnd: `calc(-1 * ${spacingVars['--spacing-0-5']})`, + }, + }, + handle: {cursor: 'grab', touchAction: 'none'}, + handleActive: {cursor: 'grabbing', touchAction: 'none'}, +}); + +/** + * Widths come straight from the column definitions, so a placeholder cell + * occupies the same track as the real one whatever the reader has configured. + */ +const skeletonCell = stylex.create({ + row: (paddingBlock: number) => ({paddingBlock}), + fixed: (width: number, paddingInline: number) => ({ + flexGrow: 0, + flexShrink: 0, + paddingInline, + width, + }), + flexible: (flexGrow: number, minWidth: number, paddingInline: number) => ({ + flexBasis: 0, + flexGrow, + minWidth, + paddingInline, + }), +}); + +/** Placeholder rows standing in for the batch being fetched. */ +const SKELETON_ROWS = 5; + + +/** Cell padding per density, mirroring the table's own scale. */ +const DENSITY_PADDING: Record = { + compact: 8, + balanced: 12, + spacious: 16, +}; + +/** + * The batch still in flight, drawn as rows rather than a spinner so the page + * keeps its shape while it loads. Cells are sized from the live column + * definitions, so each bar sits under the column it is about to fill. + */ +function LoadingRows({ + columns, + density, +}: { + columns: TableColumn[]; + density: Density; +}) { + const pad = DENSITY_PADDING[density]; + return ( + + {Array.from({length: SKELETON_ROWS}, (_, row) => ( + + {columns.map((col, index) => ( + + {col.key === 'summary' && density !== 'compact' ? ( + // The Task cell runs to two lines everywhere but compact; + // matching that keeps the placeholders on the same rhythm as + // the rows above. + + + + + ) : ( + + )} + + ))} + + ))} + + ); +} + +/** + * Everything a saved view carries besides its filters, as key/value rows, so + * the dialogs can state what is being captured instead of leaving the reader + * to assume a view is only a filter list. + * + * A setting still gets a row at its default value. Naming only the + * non-defaults reads as a diff against a baseline the reader cannot see, and + * leaves them guessing whether an absent setting is at its default or simply + * not something a view carries. + */ +function ViewSummaryList({ + view, + filters, + defs, + labels, +}: { + view: ViewState; + defs: ReadonlyArray<{key: string; label: string}>; + labels: Record; + /** + * Shown as the clauses themselves rather than a count: "3 filters" says a + * view narrows the table without saying to what, which is the one thing the + * reader is deciding on. + */ + filters: readonly PowerSearchFilter[]; +}) { + const density = DENSITY_OPTIONS.find(o => o.value === view.density); + const grouping = GROUPING_OPTIONS.find(o => o.value === view.grouping); + const stickyStart = STICKY_START_OPTIONS.find( + o => o.value === view.stickyStart, + ); + const stickyEnd = STICKY_END_OPTIONS.find(o => o.value === view.stickyEnd); + + return ( + + + {filters.length === 0 ? ( + None + ) : ( + + {filters.map(f => ( + + ))} + + )} + + + + {view.columnKeys.length} of {ALL_COLUMN_KEYS.length} + + + + {density?.label ?? view.density} + + + {grouping?.label ?? view.grouping} + + + {stickyStart?.label ?? view.stickyStart} + + + {stickyEnd?.label ?? view.stickyEnd} + + + ); +} + +/** + * The clauses the row could not fit, behind one trigger. + * + * A DropdownMenu is the usual overflow anchor and is the wrong one here: these + * items are selectors that open popovers of their own, and a popover opened + * inside a menu fights the menu for the same dismissal. A plain panel holds + * them as they already are, so a folded clause is the same control it was on + * the row rather than a menu entry that re-states it. + * + * `child` is rendered straight through rather than rebuilt from `index`: the + * element in an OverflowItem is the one the list measured, already bound to + * the same filter state, so a clause set here and a clause set on the row are + * the same control writing to the same place. + */ +function FilterOverflow({ + items, + isCompactSurface, +}: { + items: OverflowItem[]; + isCompactSurface: boolean; +}) { + const [isOpen, setIsOpen] = useState(false); + const count = items.length; + const label = `${count} more ${count === 1 ? 'filter' : 'filters'}`; + + // Each control fills the panel rather than sizing to its own label the way + // it does on the row: a column of content-width triggers reads as a ragged + // edge, not a list. The stack stretches its items, but that only reaches the + // wrapper — the selectors are block-level and follow it, while the preset + // toggles are buttons and stay at their label width. Making each wrapper a + // column stretches whatever is inside it, so both kinds land on one edge. + const body = ( + + {items.map(({child, index}) => ( + + {child} + + ))} + + ); + + const trigger = ( +