Files
kandev/apps/web/app/tasks/tasks-list-view.tsx
T
2026-07-03 22:56:13 +01:00

547 lines
17 KiB
TypeScript

"use client";
import { useMemo, useState } from "react";
import type { PaginationState } from "@tanstack/react-table";
import { Badge } from "@kandev/ui/badge";
import { Button } from "@kandev/ui/button";
import { Checkbox } from "@kandev/ui/checkbox";
import { Label } from "@kandev/ui/label";
import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@kandev/ui/select";
import { Tooltip, TooltipContent, TooltipTrigger } from "@kandev/ui/tooltip";
import { IconArchive, IconLoader, IconTrash } from "@tabler/icons-react";
import { TaskArchiveConfirmDialog } from "@/components/task/task-archive-confirm-dialog";
import { TaskDeleteConfirmDialog } from "@/components/task/task-delete-confirm-dialog";
import { primaryTaskRepository, type Repository, type Task, type Workflow } from "@/lib/types/http";
import { formatTaskStateLabel } from "@/lib/ui/state-labels";
import { getTaskStateIcon } from "@/lib/ui/state-icons";
import { formatRelativeTime } from "@/lib/utils";
import { TasksPagination } from "./tasks-pagination";
import {
TASKS_LIST_GROUP_OPTIONS,
TASKS_LIST_SORT_OPTIONS,
TASK_STATE_ORDER,
type TasksListGroup,
type TasksListSort,
} from "@/lib/tasks/tasks-list-options";
export type TasksListViewProps = {
total: number;
showArchived: boolean;
setShowArchived: (show: boolean) => void;
tasksListSort: TasksListSort;
onTasksListSortChange: (sort: TasksListSort) => void;
tasksListGroup: TasksListGroup;
onTasksListGroupChange: (group: TasksListGroup) => void;
tasks: Task[];
workflows: Workflow[];
repositories: Repository[];
pageCount: number;
pagination: PaginationState;
setPagination: (next: PaginationState | ((prev: PaginationState) => PaginationState)) => void;
isLoading: boolean;
handleRowClick: (task: Task) => void;
deletingTaskId: string | null;
handleArchive: (taskId: string, opts?: { cascade?: boolean }) => Promise<void>;
handleDelete: (taskId: string, opts?: { cascade?: boolean }) => Promise<void>;
};
export function TasksListView({
total,
showArchived,
setShowArchived,
tasksListSort,
onTasksListSortChange,
tasksListGroup,
onTasksListGroupChange,
tasks,
workflows,
repositories,
pageCount,
pagination,
setPagination,
isLoading,
handleRowClick,
deletingTaskId,
handleArchive,
handleDelete,
}: TasksListViewProps) {
return (
<main className="flex-1 overflow-auto px-4 py-4 sm:px-6 sm:py-6">
<div className="space-y-4">
<TasksListControls
showArchived={showArchived}
onShowArchivedChange={setShowArchived}
tasksListSort={tasksListSort}
onTasksListSortChange={onTasksListSortChange}
tasksListGroup={tasksListGroup}
onTasksListGroupChange={onTasksListGroupChange}
/>
<TaskRows
tasks={tasks}
workflows={workflows}
repositories={repositories}
tasksListGroup={tasksListGroup}
isLoading={isLoading}
deletingTaskId={deletingTaskId}
onArchive={handleArchive}
onDelete={handleDelete}
onRowClick={handleRowClick}
/>
<TasksPagination
total={total}
pageCount={pageCount}
pagination={pagination}
onPaginationChange={setPagination}
/>
</div>
</main>
);
}
function TasksListControls({
showArchived,
onShowArchivedChange,
tasksListSort,
onTasksListSortChange,
tasksListGroup,
onTasksListGroupChange,
}: {
showArchived: boolean;
onShowArchivedChange: (show: boolean) => void;
tasksListSort: TasksListSort;
onTasksListSortChange: (sort: TasksListSort) => void;
tasksListGroup: TasksListGroup;
onTasksListGroupChange: (group: TasksListGroup) => void;
}) {
return (
<div className="flex min-h-9 flex-wrap items-center justify-end gap-3">
<ListOptionSelect
label="Sort"
value={tasksListSort}
options={TASKS_LIST_SORT_OPTIONS}
onChange={(value) => onTasksListSortChange(value as TasksListSort)}
testId="tasks-list-sort"
/>
<ListOptionSelect
label="Group"
value={tasksListGroup}
options={TASKS_LIST_GROUP_OPTIONS}
onChange={(value) => onTasksListGroupChange(value as TasksListGroup)}
testId="tasks-list-group"
/>
<Label className="flex h-11 items-center gap-2 text-sm text-muted-foreground cursor-pointer select-none lg:h-9">
<Checkbox
checked={showArchived}
onCheckedChange={(checked) => onShowArchivedChange(checked === true)}
className="cursor-pointer"
/>
Show archived
</Label>
</div>
);
}
function ListOptionSelect<T extends string>({
label,
value,
options,
onChange,
testId,
}: {
label: string;
value: T;
options: ReadonlyArray<{ readonly value: T; readonly label: string }>;
onChange: (value: T) => void;
testId: string;
}) {
return (
<div className="flex items-center gap-2">
<span className="text-sm text-muted-foreground">{label}</span>
<Select value={value} onValueChange={(next) => onChange(next as T)}>
<SelectTrigger data-testid={testId} className="h-10 w-[150px] cursor-pointer lg:h-9">
<SelectValue />
</SelectTrigger>
<SelectContent>
{options.map((option) => (
<SelectItem key={option.value} value={option.value} className="cursor-pointer">
{option.label}
</SelectItem>
))}
</SelectContent>
</Select>
</div>
);
}
type TaskTreeNode = {
task: Task;
children: TaskTreeNode[];
level: number;
};
type TaskListSection = {
key: string;
title: string | null;
nodes: TaskTreeNode[];
};
function TaskRows({
tasks,
workflows,
repositories,
tasksListGroup,
isLoading,
deletingTaskId,
onArchive,
onDelete,
onRowClick,
}: {
tasks: Task[];
workflows: Workflow[];
repositories: Repository[];
tasksListGroup: TasksListGroup;
isLoading: boolean;
deletingTaskId: string | null;
onArchive: (taskId: string, opts?: { cascade?: boolean }) => Promise<void>;
onDelete: (taskId: string, opts?: { cascade?: boolean }) => Promise<void>;
onRowClick: (task: Task) => void;
}) {
const workflowMap = useMemo(() => new Map(workflows.map((w) => [w.id, w.name])), [workflows]);
const repoMap = useMemo(() => new Map(repositories.map((r) => [r.id, r.name])), [repositories]);
const sections = useMemo(
() => buildTaskSections(tasks, { groupBy: tasksListGroup, workflowMap, repoMap }),
[repoMap, tasks, tasksListGroup, workflowMap],
);
if (isLoading) {
return (
<div className="rounded-lg border border-border p-8 text-center text-sm text-muted-foreground">
Loading tasks...
</div>
);
}
if (tasks.length === 0) {
return (
<div className="rounded-lg border border-border p-8 text-center text-sm text-muted-foreground">
No tasks found.
</div>
);
}
return (
<div className="space-y-5" data-testid="tasks-list">
{sections.map((section) => (
<TaskListSectionView
key={section.key}
section={section}
deletingTaskId={deletingTaskId}
onArchive={onArchive}
onDelete={onDelete}
onRowClick={onRowClick}
/>
))}
</div>
);
}
function buildTaskSections(
tasks: Task[],
{
groupBy,
workflowMap,
repoMap,
}: {
groupBy: TasksListGroup;
workflowMap: Map<string, string>;
repoMap: Map<string, string>;
},
): TaskListSection[] {
const roots = buildTaskTree(tasks);
if (groupBy === "none") {
return [{ key: "all", title: null, nodes: roots }];
}
const sections = new Map<string, TaskListSection>();
for (const node of roots) {
const { key, title } = groupForTask(node.task, groupBy, workflowMap, repoMap);
const section = sections.get(key) ?? { key, title, nodes: [] };
section.nodes.push(node);
sections.set(key, section);
}
return Array.from(sections.values()).sort((a, b) => compareSection(a, b, groupBy));
}
function buildTaskTree(tasks: Task[]): TaskTreeNode[] {
const childrenByParent = new Map<string, Task[]>();
const taskIds = new Set(tasks.map((task) => task.id));
const roots: Task[] = [];
for (const task of tasks) {
if (task.parent_id && taskIds.has(task.parent_id)) {
const siblings = childrenByParent.get(task.parent_id) ?? [];
siblings.push(task);
childrenByParent.set(task.parent_id, siblings);
} else {
roots.push(task);
}
}
const visited = new Set<string>();
const buildNode = (task: Task, level: number): TaskTreeNode | null => {
if (visited.has(task.id)) return null;
visited.add(task.id);
return {
task,
level,
children: (childrenByParent.get(task.id) ?? [])
.map((child) => buildNode(child, level + 1))
.filter((node): node is TaskTreeNode => node !== null),
};
};
const nodes = roots
.map((task) => buildNode(task, 0))
.filter((node): node is TaskTreeNode => node !== null);
for (const task of tasks) {
const node = buildNode(task, 0);
if (node) nodes.push(node);
}
return nodes;
}
function groupForTask(
task: Task,
groupBy: TasksListGroup,
workflowMap: Map<string, string>,
repoMap: Map<string, string>,
) {
if (groupBy === "workflow") {
const title = workflowMap.get(task.workflow_id);
if (!title) return { key: "workflow:none", title: "No workflow" };
return { key: `workflow:${task.workflow_id || "none"}`, title };
}
if (groupBy === "repository") {
const primaryRepo = primaryTaskRepository(task.repositories);
if (!primaryRepo) return { key: "repository:none", title: "No repository" };
const repoId = primaryRepo?.repository_id ?? "none";
const title = repoMap.get(repoId);
if (!title) return { key: "repository:none", title: "No repository" };
return { key: `repository:${repoId}`, title };
}
const title = formatTaskStateLabel(task.state);
return { key: `state:${task.state}`, title };
}
function compareSection(a: TaskListSection, b: TaskListSection, groupBy: TasksListGroup): number {
if (groupBy === "state") {
const aIndex = TASK_STATE_ORDER.indexOf(a.key.replace("state:", "") as Task["state"]);
const bIndex = TASK_STATE_ORDER.indexOf(b.key.replace("state:", "") as Task["state"]);
return (
(aIndex === -1 ? Number.MAX_SAFE_INTEGER : aIndex) -
(bIndex === -1 ? Number.MAX_SAFE_INTEGER : bIndex)
);
}
return (a.title ?? "").localeCompare(b.title ?? "", undefined, { sensitivity: "base" });
}
function flattenTaskTree(nodes: TaskTreeNode[]): TaskTreeNode[] {
return nodes.flatMap((node) => [node, ...flattenTaskTree(node.children)]);
}
function TaskListRow({
task,
level,
deletingTaskId,
onArchive,
onDelete,
onRowClick,
}: {
task: Task;
level: number;
deletingTaskId: string | null;
onArchive: (taskId: string, opts?: { cascade?: boolean }) => Promise<void>;
onDelete: (taskId: string, opts?: { cascade?: boolean }) => Promise<void>;
onRowClick: (task: Task) => void;
}) {
const [showDeleteConfirm, setShowDeleteConfirm] = useState(false);
const [showArchiveConfirm, setShowArchiveConfirm] = useState(false);
const isDeleting = deletingTaskId === task.id;
const isArchived = !!task.archived_at;
return (
<div
role="button"
tabIndex={0}
data-testid="tasks-list-row"
data-level={level}
className="grid min-h-12 grid-cols-[minmax(0,1fr)_auto] items-center gap-3 px-4 py-2 text-sm transition-colors hover:bg-muted/60 cursor-pointer"
onClick={() => onRowClick(task)}
onKeyDown={(event) => {
if (event.target !== event.currentTarget) return;
if (event.key === "Enter" || event.key === " ") {
event.preventDefault();
onRowClick(task);
}
}}
>
<div
className="flex min-w-0 items-center gap-2"
data-testid="tasks-list-row-content"
style={{ paddingLeft: `${level * 28}px` }}
>
{getTaskStateIcon(task.state, "h-4 w-4 shrink-0")}
<span className="min-w-0 truncate font-medium" data-testid="tasks-list-row-title">
{task.title}
</span>
{isArchived && (
<Badge
variant="outline"
className="shrink-0 border-amber-500/30 px-1.5 py-0 text-[10px] text-amber-500"
>
Archived
</Badge>
)}
</div>
<div className="flex items-center justify-between gap-3 md:justify-end">
<span className="hidden text-xs text-muted-foreground sm:inline">
{formatRelativeTime(task.updated_at)}
</span>
<TaskRowActions
task={task}
isArchived={isArchived}
isDeleting={isDeleting}
showDeleteConfirm={showDeleteConfirm}
showArchiveConfirm={showArchiveConfirm}
onDeleteOpenChange={setShowDeleteConfirm}
onArchiveOpenChange={setShowArchiveConfirm}
onArchive={onArchive}
onDelete={onDelete}
/>
</div>
</div>
);
}
function TaskListSectionView({
section,
deletingTaskId,
onArchive,
onDelete,
onRowClick,
}: {
section: TaskListSection;
deletingTaskId: string | null;
onArchive: (taskId: string, opts?: { cascade?: boolean }) => Promise<void>;
onDelete: (taskId: string, opts?: { cascade?: boolean }) => Promise<void>;
onRowClick: (task: Task) => void;
}) {
const rows = flattenTaskTree(section.nodes);
return (
<section className="space-y-2" data-testid="tasks-list-section">
{section.title && (
<div className="flex items-center gap-2 px-1 text-xs font-semibold uppercase tracking-normal text-muted-foreground">
<span>{section.title}</span>
<span className="text-muted-foreground/70">{rows.length}</span>
</div>
)}
<div className="rounded-lg border border-border divide-y divide-border overflow-hidden">
{rows.map(({ task, level }) => (
<TaskListRow
key={task.id}
task={task}
level={level}
deletingTaskId={deletingTaskId}
onArchive={onArchive}
onDelete={onDelete}
onRowClick={onRowClick}
/>
))}
</div>
</section>
);
}
function TaskRowActions({
task,
isArchived,
isDeleting,
showDeleteConfirm,
showArchiveConfirm,
onDeleteOpenChange,
onArchiveOpenChange,
onArchive,
onDelete,
}: {
task: Task;
isArchived: boolean;
isDeleting: boolean;
showDeleteConfirm: boolean;
showArchiveConfirm: boolean;
onDeleteOpenChange: (open: boolean) => void;
onArchiveOpenChange: (open: boolean) => void;
onArchive: (taskId: string, opts?: { cascade?: boolean }) => Promise<void>;
onDelete: (taskId: string, opts?: { cascade?: boolean }) => Promise<void>;
}) {
return (
<div className="flex items-center gap-1" onClick={(event) => event.stopPropagation()}>
{!isArchived && (
<Tooltip>
<TooltipTrigger asChild>
<Button
variant="ghost"
size="icon"
className="h-9 w-9 cursor-pointer"
onClick={() => onArchiveOpenChange(true)}
>
<IconArchive className="h-4 w-4 text-muted-foreground" />
<span className="sr-only">Archive task</span>
</Button>
</TooltipTrigger>
<TooltipContent>Archive</TooltipContent>
</Tooltip>
)}
<Tooltip>
<TooltipTrigger asChild>
<span tabIndex={isDeleting ? 0 : -1} className="inline-flex">
<Button
variant="ghost"
size="icon"
className="h-9 w-9 cursor-pointer"
disabled={isDeleting}
onClick={() => onDeleteOpenChange(true)}
>
{isDeleting ? (
<IconLoader className="h-4 w-4 animate-spin" />
) : (
<IconTrash className="h-4 w-4 text-destructive" />
)}
<span className="sr-only">Delete task</span>
</Button>
</span>
</TooltipTrigger>
<TooltipContent>Delete</TooltipContent>
</Tooltip>
<TaskDeleteConfirmDialog
open={showDeleteConfirm}
onOpenChange={onDeleteOpenChange}
taskTitle={task.title}
taskId={task.id}
executorType={task.primary_executor_type}
isDeleting={isDeleting}
onConfirm={({ cascade }) => onDelete(task.id, { cascade })}
/>
<TaskArchiveConfirmDialog
open={showArchiveConfirm}
onOpenChange={onArchiveOpenChange}
taskTitle={task.title}
taskId={task.id}
executorType={task.primary_executor_type}
onConfirm={({ cascade }) => onArchive(task.id, { cascade })}
/>
</div>
);
}