overseerandClaude Opus 5.5
5a28fddfe2
Tasks tab lists quest definitions (assignees · recurrence · windows, inactive rows, per-child filter chips) and a bottom edit sheet with multi-select assignees, repeats + interval, per-window due times, multi-select windows and a skip-on-away toggle. Saving POSTs or PATCHes the admin quest-definition routes and re-fetches the list; 403 and 422 responses are shown in the sheet. Task: 2e96585c-ca63-413d-bf99-7e203c39ddde Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
732 lines
24 KiB
TypeScript
732 lines
24 KiB
TypeScript
/**
|
||
* Definitions ("Tasks") tab — list + edit sheet (design/ADMIN-SPEC.md §3.1–3.2).
|
||
*
|
||
* The icon picker (§3.3) and the occurrence preview are separate tasks: an
|
||
* existing definition's icon is carried through unchanged by never sending it.
|
||
*/
|
||
import { useEffect, useRef, useState, type ReactNode } from "react";
|
||
import { ApiForbiddenError } from "../api/client";
|
||
import {
|
||
ApiRequestError,
|
||
createDefinition,
|
||
fetchChildren,
|
||
fetchDefinitions,
|
||
updateDefinition,
|
||
type AdminChild,
|
||
type DefinitionCreateBody,
|
||
type DefinitionRule,
|
||
type QuestDefinition,
|
||
type WindowEntry,
|
||
type WindowName,
|
||
} from "../api/definitions";
|
||
import {
|
||
MONTH_SHORT,
|
||
WEEKDAY_SHORT,
|
||
WINDOW_LABELS,
|
||
WINDOW_ORDER,
|
||
assigneeSummary,
|
||
recurrenceSummary,
|
||
windowSummary,
|
||
} from "./format";
|
||
import {
|
||
CheckGlyph,
|
||
ChevronDownGlyph,
|
||
ChevronRightGlyph,
|
||
PlusGlyph,
|
||
TaskGlyph,
|
||
} from "./glyphs";
|
||
import "./DefinitionsTab.css";
|
||
|
||
/** ADMIN-SPEC §1: every scroll column ends with 92px so content clears the tab bar. */
|
||
export const SCROLL_BOTTOM_PADDING = "92px";
|
||
|
||
type Repeats = "daily" | "weekly" | "monthly" | "yearly" | "custom";
|
||
|
||
const REPEATS_OPTIONS: { value: Repeats; label: string }[] = [
|
||
{ value: "daily", label: "Daily" },
|
||
{ value: "weekly", label: "Weekly" },
|
||
{ value: "monthly", label: "Monthly" },
|
||
{ value: "yearly", label: "Yearly" },
|
||
{ value: "custom", label: "Custom" },
|
||
];
|
||
|
||
const REPEATS_BY_RULE: Record<DefinitionRule["rule_type"], Repeats> = {
|
||
daily: "daily",
|
||
weekly: "weekly",
|
||
monthly_day: "monthly",
|
||
monthly_weekday: "monthly",
|
||
yearly: "yearly",
|
||
custom_days: "custom",
|
||
};
|
||
|
||
const WEEKDAY_LONG = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"];
|
||
|
||
interface Draft {
|
||
title: string;
|
||
assigneeIds: number[];
|
||
repeats: Repeats;
|
||
interval: string;
|
||
weekdays: number[];
|
||
dayOfMonth: string;
|
||
month: string;
|
||
/** An existing "nth weekday" monthly rule, kept while Repeats stays Monthly. */
|
||
monthlyWeekday: { nth: number; weekday: number } | null;
|
||
windows: WindowName[];
|
||
dueTimes: Record<WindowName, string>;
|
||
skipOnAway: boolean;
|
||
startDate: string;
|
||
endDate: string | null;
|
||
}
|
||
|
||
type LoadState =
|
||
| { kind: "loading" }
|
||
| { kind: "error"; message: string }
|
||
| { kind: "ready"; definitions: QuestDefinition[]; children: AdminChild[] };
|
||
|
||
/** `null` = closed, `"new"` = creating, a definition = editing it. */
|
||
type SheetTarget = null | "new" | QuestDefinition;
|
||
|
||
function pad2(n: number): string {
|
||
return String(n).padStart(2, "0");
|
||
}
|
||
|
||
function localIsoDate(date: Date): string {
|
||
return `${date.getFullYear()}-${pad2(date.getMonth() + 1)}-${pad2(date.getDate())}`;
|
||
}
|
||
|
||
function emptyDueTimes(): Record<WindowName, string> {
|
||
return { morning: "", afternoon: "", evening: "" };
|
||
}
|
||
|
||
function newDraft(activeChildren: AdminChild[]): Draft {
|
||
const today = new Date();
|
||
return {
|
||
title: "",
|
||
assigneeIds: activeChildren.length === 1 ? [activeChildren[0].id] : [],
|
||
repeats: "daily",
|
||
interval: "1",
|
||
weekdays: [(today.getDay() + 6) % 7],
|
||
dayOfMonth: String(today.getDate()),
|
||
month: String(today.getMonth() + 1),
|
||
monthlyWeekday: null,
|
||
windows: [],
|
||
dueTimes: emptyDueTimes(),
|
||
// Mirrors the API's create default: no instance on an away day.
|
||
skipOnAway: true,
|
||
startDate: localIsoDate(today),
|
||
endDate: null,
|
||
};
|
||
}
|
||
|
||
function draftFrom(definition: QuestDefinition, activeChildren: AdminChild[]): Draft {
|
||
const { rule } = definition;
|
||
const today = new Date();
|
||
const active = new Set(activeChildren.map((child) => child.id));
|
||
const dueTimes = emptyDueTimes();
|
||
for (const w of definition.windows) dueTimes[w.window] = w.due_time ?? "";
|
||
return {
|
||
title: definition.title,
|
||
// Inactive children cannot be submitted (the API rejects them with 422).
|
||
assigneeIds: definition.assignees.map((a) => a.id).filter((id) => active.has(id)),
|
||
repeats: REPEATS_BY_RULE[rule.rule_type],
|
||
interval: String(rule.interval),
|
||
weekdays:
|
||
rule.rule_type === "weekly" || rule.rule_type === "custom_days"
|
||
? [...(rule.weekday_set ?? [])]
|
||
: [(today.getDay() + 6) % 7],
|
||
dayOfMonth: String(rule.day_of_month ?? today.getDate()),
|
||
month: String(rule.month ?? today.getMonth() + 1),
|
||
monthlyWeekday:
|
||
rule.rule_type === "monthly_weekday"
|
||
? { nth: rule.nth_weekday ?? 1, weekday: rule.nth_weekday_weekday ?? 0 }
|
||
: null,
|
||
windows: WINDOW_ORDER.filter((w) => definition.windows.some((d) => d.window === w)),
|
||
dueTimes,
|
||
skipOnAway: definition.skip_on_away,
|
||
startDate: rule.start_date,
|
||
endDate: rule.end_date,
|
||
};
|
||
}
|
||
|
||
function parseWhole(value: string, min: number, max: number): number | null {
|
||
if (!/^\d+$/.test(value.trim())) return null;
|
||
const n = Number(value);
|
||
return n >= min && n <= max ? n : null;
|
||
}
|
||
|
||
/** Build the request rule from the draft, or return a message naming what to fix. */
|
||
function buildRule(draft: Draft): DefinitionRule | string {
|
||
const interval = parseWhole(draft.interval, 1, 999);
|
||
if (interval === null) return "Interval must be a whole number of at least 1.";
|
||
const rule: DefinitionRule = {
|
||
rule_type: "daily",
|
||
interval,
|
||
weekday_set: null,
|
||
day_of_month: null,
|
||
nth_weekday: null,
|
||
nth_weekday_weekday: null,
|
||
month: null,
|
||
start_date: draft.startDate,
|
||
end_date: draft.endDate,
|
||
};
|
||
switch (draft.repeats) {
|
||
case "daily":
|
||
return rule;
|
||
case "weekly":
|
||
case "custom":
|
||
if (draft.weekdays.length === 0) return "Pick at least one day.";
|
||
return {
|
||
...rule,
|
||
rule_type: draft.repeats === "weekly" ? "weekly" : "custom_days",
|
||
weekday_set: [...draft.weekdays].sort((a, b) => a - b),
|
||
};
|
||
case "monthly": {
|
||
if (draft.monthlyWeekday) {
|
||
return {
|
||
...rule,
|
||
rule_type: "monthly_weekday",
|
||
nth_weekday: draft.monthlyWeekday.nth,
|
||
nth_weekday_weekday: draft.monthlyWeekday.weekday,
|
||
};
|
||
}
|
||
const day = parseWhole(draft.dayOfMonth, 1, 31);
|
||
if (day === null) return "Day of month must be 1 to 31.";
|
||
return { ...rule, rule_type: "monthly_day", day_of_month: day };
|
||
}
|
||
case "yearly": {
|
||
const month = parseWhole(draft.month, 1, 12);
|
||
const day = parseWhole(draft.dayOfMonth, 1, 31);
|
||
if (month === null || day === null) return "Pick a month and a day (1 to 31).";
|
||
return { ...rule, rule_type: "yearly", month, day_of_month: day };
|
||
}
|
||
}
|
||
}
|
||
|
||
function buildBody(draft: Draft): DefinitionCreateBody | string {
|
||
const title = draft.title.trim();
|
||
if (!title) return "Give the task a title.";
|
||
if (draft.assigneeIds.length === 0) return "Assign at least one child.";
|
||
if (draft.windows.length === 0) return "Pick at least one window.";
|
||
const rule = buildRule(draft);
|
||
if (typeof rule === "string") return rule;
|
||
const windows: WindowEntry[] = WINDOW_ORDER.filter((w) => draft.windows.includes(w)).map(
|
||
(w) => [w, draft.dueTimes[w] || null],
|
||
);
|
||
return {
|
||
title,
|
||
rule,
|
||
assignee_child_ids: [...draft.assigneeIds],
|
||
windows,
|
||
skip_on_away: draft.skipOnAway,
|
||
};
|
||
}
|
||
|
||
function saveErrorMessage(error: unknown): string {
|
||
if (error instanceof ApiForbiddenError) return error.message;
|
||
if (error instanceof ApiRequestError && error.detail) return error.detail;
|
||
return "The task could not be saved. Check your connection and try again.";
|
||
}
|
||
|
||
function toggle<T>(list: T[], value: T): T[] {
|
||
return list.includes(value) ? list.filter((item) => item !== value) : [...list, value];
|
||
}
|
||
|
||
/* ── List ───────────────────────────────────────────────────────────── */
|
||
|
||
function FilterChips({
|
||
options,
|
||
filter,
|
||
onChange,
|
||
}: {
|
||
options: AdminChild[];
|
||
filter: number | "all";
|
||
onChange: (filter: number | "all") => void;
|
||
}) {
|
||
const chips: { key: number | "all"; label: string }[] = [
|
||
{ key: "all", label: "All" },
|
||
...options.map((child) => ({ key: child.id, label: child.display_name })),
|
||
];
|
||
return (
|
||
<div className="defs-chips" role="group" aria-label="Filter by child">
|
||
{chips.map((chip) => (
|
||
<button
|
||
key={chip.key}
|
||
type="button"
|
||
className={chip.key === filter ? "defs-chip defs-chip--active" : "defs-chip"}
|
||
aria-pressed={chip.key === filter}
|
||
onClick={() => onChange(chip.key)}
|
||
>
|
||
{chip.label}
|
||
</button>
|
||
))}
|
||
</div>
|
||
);
|
||
}
|
||
|
||
function DefinitionRow({
|
||
definition,
|
||
activeChildren,
|
||
editing,
|
||
onOpen,
|
||
}: {
|
||
definition: QuestDefinition;
|
||
activeChildren: AdminChild[];
|
||
editing: boolean;
|
||
onOpen: () => void;
|
||
}) {
|
||
let meta = [
|
||
assigneeSummary(definition.assignees, activeChildren),
|
||
recurrenceSummary(definition.rule),
|
||
windowSummary(definition.windows),
|
||
].join(" · ");
|
||
if (!definition.is_active) meta += " · inactive";
|
||
let className = "defs-row";
|
||
if (!definition.is_active) className += " defs-row--inactive";
|
||
if (editing) className += " defs-row--editing";
|
||
return (
|
||
<li>
|
||
<button
|
||
type="button"
|
||
className={className}
|
||
data-testid={`definition-${definition.id}`}
|
||
aria-expanded={editing}
|
||
onClick={onOpen}
|
||
>
|
||
<span className="defs-row-glyph">
|
||
<TaskGlyph />
|
||
</span>
|
||
<span className="defs-row-text">
|
||
<span className="defs-row-title">{definition.title}</span>
|
||
<span className="defs-row-meta">{editing ? "Editing" : meta}</span>
|
||
</span>
|
||
<span className="defs-row-chevron">
|
||
{editing ? <ChevronDownGlyph /> : <ChevronRightGlyph />}
|
||
</span>
|
||
</button>
|
||
</li>
|
||
);
|
||
}
|
||
|
||
/* ── Edit sheet ─────────────────────────────────────────────────────── */
|
||
|
||
function Field({ label, id, children }: { label: string; id: string; children: ReactNode }) {
|
||
return (
|
||
<div className="defs-field" role="group" aria-labelledby={id}>
|
||
<span className="defs-label" id={id}>
|
||
{label}
|
||
</span>
|
||
{children}
|
||
</div>
|
||
);
|
||
}
|
||
|
||
function EditSheet({
|
||
target,
|
||
activeChildren,
|
||
onCancel,
|
||
onSaved,
|
||
}: {
|
||
target: "new" | QuestDefinition;
|
||
activeChildren: AdminChild[];
|
||
onCancel: () => void;
|
||
onSaved: () => void;
|
||
}) {
|
||
const [draft, setDraft] = useState<Draft>(() =>
|
||
target === "new" ? newDraft(activeChildren) : draftFrom(target, activeChildren),
|
||
);
|
||
const [pickerOpen, setPickerOpen] = useState(false);
|
||
const [saving, setSaving] = useState(false);
|
||
const [error, setError] = useState<string | null>(null);
|
||
// A ref, not state: two taps in one frame must not both see `saving === false`.
|
||
const inFlight = useRef(false);
|
||
|
||
const update = (patch: Partial<Draft>) => setDraft((d) => ({ ...d, ...patch }));
|
||
|
||
const selectedAssignees = activeChildren
|
||
.filter((child) => draft.assigneeIds.includes(child.id))
|
||
.map((child) => ({ id: child.id, display_name: child.display_name }));
|
||
const orderedWindows = WINDOW_ORDER.filter((w) => draft.windows.includes(w));
|
||
|
||
async function save() {
|
||
if (inFlight.current) return;
|
||
const body = buildBody(draft);
|
||
if (typeof body === "string") {
|
||
setError(body);
|
||
return;
|
||
}
|
||
inFlight.current = true;
|
||
setSaving(true);
|
||
setError(null);
|
||
try {
|
||
if (target === "new") await createDefinition(body);
|
||
else await updateDefinition(target.id, body);
|
||
onSaved();
|
||
} catch (err) {
|
||
setError(saveErrorMessage(err));
|
||
inFlight.current = false;
|
||
setSaving(false);
|
||
}
|
||
}
|
||
|
||
return (
|
||
<div className="defs-sheet-layer">
|
||
<div
|
||
className="defs-scrim"
|
||
data-testid="sheet-scrim"
|
||
onClick={() => {
|
||
if (!inFlight.current) onCancel();
|
||
}}
|
||
/>
|
||
<div
|
||
className="defs-sheet"
|
||
role="dialog"
|
||
aria-modal="true"
|
||
aria-labelledby="defs-sheet-title"
|
||
>
|
||
<div className="defs-grabber" aria-hidden="true" />
|
||
<h3 className="defs-sheet-title" id="defs-sheet-title">
|
||
{target === "new" ? "New task" : "Edit task"}
|
||
</h3>
|
||
<div className="defs-fields">
|
||
<Field label="Title" id="defs-label-title">
|
||
<input
|
||
className="defs-input"
|
||
aria-labelledby="defs-label-title"
|
||
value={draft.title}
|
||
onChange={(e) => update({ title: e.target.value })}
|
||
/>
|
||
</Field>
|
||
|
||
<Field label="Assigned children" id="defs-label-children">
|
||
<button
|
||
type="button"
|
||
className="defs-select-row"
|
||
aria-expanded={pickerOpen}
|
||
aria-labelledby="defs-label-children defs-children-summary"
|
||
onClick={() => setPickerOpen((open) => !open)}
|
||
>
|
||
<span id="defs-children-summary">
|
||
{selectedAssignees.length > 0
|
||
? assigneeSummary(selectedAssignees, activeChildren)
|
||
: "Choose children"}
|
||
</span>
|
||
{pickerOpen ? <ChevronDownGlyph /> : <ChevronRightGlyph />}
|
||
</button>
|
||
{pickerOpen ? (
|
||
<ul className="defs-picker" aria-label="Children">
|
||
{activeChildren.map((child) => {
|
||
const checked = draft.assigneeIds.includes(child.id);
|
||
return (
|
||
<li key={child.id}>
|
||
<button
|
||
type="button"
|
||
role="checkbox"
|
||
aria-checked={checked}
|
||
className="defs-picker-option"
|
||
onClick={() => update({ assigneeIds: toggle(draft.assigneeIds, child.id) })}
|
||
>
|
||
<span>{child.display_name}</span>
|
||
<span className="defs-picker-check">{checked ? <CheckGlyph /> : null}</span>
|
||
</button>
|
||
</li>
|
||
);
|
||
})}
|
||
</ul>
|
||
) : null}
|
||
</Field>
|
||
|
||
<Field label="Repeats" id="defs-label-repeats">
|
||
<div className="defs-repeats">
|
||
<select
|
||
className="defs-input"
|
||
aria-label="Repeats"
|
||
value={draft.repeats}
|
||
onChange={(e) =>
|
||
update({
|
||
repeats: e.target.value as Repeats,
|
||
// Leaving Monthly drops a carried nth-weekday rule for good.
|
||
monthlyWeekday: e.target.value === "monthly" ? draft.monthlyWeekday : null,
|
||
})
|
||
}
|
||
>
|
||
{REPEATS_OPTIONS.map((option) => (
|
||
<option key={option.value} value={option.value}>
|
||
{option.label}
|
||
</option>
|
||
))}
|
||
</select>
|
||
<label className="defs-interval">
|
||
<span>Every</span>
|
||
<input
|
||
className="defs-input"
|
||
type="number"
|
||
min={1}
|
||
aria-label="Interval"
|
||
value={draft.interval}
|
||
onChange={(e) => update({ interval: e.target.value })}
|
||
/>
|
||
</label>
|
||
</div>
|
||
{draft.repeats === "weekly" || draft.repeats === "custom" ? (
|
||
<div className="defs-weekdays" role="group" aria-label="Days">
|
||
{WEEKDAY_SHORT.map((label, day) => (
|
||
<button
|
||
key={label}
|
||
type="button"
|
||
aria-pressed={draft.weekdays.includes(day)}
|
||
aria-label={WEEKDAY_LONG[day]}
|
||
className={
|
||
draft.weekdays.includes(day) ? "defs-day defs-day--on" : "defs-day"
|
||
}
|
||
onClick={() => update({ weekdays: toggle(draft.weekdays, day) })}
|
||
>
|
||
{label.charAt(0)}
|
||
</button>
|
||
))}
|
||
</div>
|
||
) : null}
|
||
{draft.repeats === "monthly" && draft.monthlyWeekday ? (
|
||
<p className="defs-hint">
|
||
{recurrenceSummary({
|
||
rule_type: "monthly_weekday",
|
||
interval: parseWhole(draft.interval, 1, 999) ?? 1,
|
||
weekday_set: null,
|
||
day_of_month: null,
|
||
nth_weekday: draft.monthlyWeekday.nth,
|
||
nth_weekday_weekday: draft.monthlyWeekday.weekday,
|
||
month: null,
|
||
start_date: draft.startDate,
|
||
end_date: draft.endDate,
|
||
})}
|
||
</p>
|
||
) : null}
|
||
{draft.repeats === "yearly" ? (
|
||
<select
|
||
className="defs-input"
|
||
aria-label="Month"
|
||
value={draft.month}
|
||
onChange={(e) => update({ month: e.target.value })}
|
||
>
|
||
{MONTH_SHORT.map((label, index) => (
|
||
<option key={label} value={String(index + 1)}>
|
||
{label}
|
||
</option>
|
||
))}
|
||
</select>
|
||
) : null}
|
||
{(draft.repeats === "monthly" && !draft.monthlyWeekday) || draft.repeats === "yearly" ? (
|
||
<input
|
||
className="defs-input"
|
||
type="number"
|
||
min={1}
|
||
max={31}
|
||
aria-label="Day of month"
|
||
value={draft.dayOfMonth}
|
||
onChange={(e) => update({ dayOfMonth: e.target.value })}
|
||
/>
|
||
) : null}
|
||
</Field>
|
||
|
||
<Field label="Due time" id="defs-label-due">
|
||
{orderedWindows.length === 0 ? (
|
||
<p className="defs-hint">Pick a window to set its due time.</p>
|
||
) : (
|
||
<div className="defs-due-times">
|
||
{orderedWindows.map((w) => (
|
||
<label key={w} className="defs-due">
|
||
<span>{WINDOW_LABELS[w]}</span>
|
||
<input
|
||
className="defs-input"
|
||
type="time"
|
||
aria-label={`${WINDOW_LABELS[w]} due time`}
|
||
value={draft.dueTimes[w]}
|
||
onChange={(e) =>
|
||
update({ dueTimes: { ...draft.dueTimes, [w]: e.target.value } })
|
||
}
|
||
/>
|
||
</label>
|
||
))}
|
||
</div>
|
||
)}
|
||
</Field>
|
||
|
||
<Field label="Window" id="defs-label-window">
|
||
<div className="defs-segmented">
|
||
{WINDOW_ORDER.map((w) => (
|
||
<button
|
||
key={w}
|
||
type="button"
|
||
aria-pressed={draft.windows.includes(w)}
|
||
className={
|
||
draft.windows.includes(w) ? "defs-segment defs-segment--on" : "defs-segment"
|
||
}
|
||
onClick={() => update({ windows: toggle(draft.windows, w) })}
|
||
>
|
||
{WINDOW_LABELS[w]}
|
||
</button>
|
||
))}
|
||
</div>
|
||
</Field>
|
||
|
||
<div className="defs-toggle-row">
|
||
<div>
|
||
<div className="defs-toggle-title" id="defs-label-skip">
|
||
Skip on away days
|
||
</div>
|
||
<div className="defs-toggle-sub">No instance when the child is absent</div>
|
||
</div>
|
||
<button
|
||
type="button"
|
||
role="switch"
|
||
aria-checked={draft.skipOnAway}
|
||
aria-labelledby="defs-label-skip"
|
||
className={draft.skipOnAway ? "defs-switch defs-switch--on" : "defs-switch"}
|
||
onClick={() => update({ skipOnAway: !draft.skipOnAway })}
|
||
>
|
||
<span className="defs-switch-knob" />
|
||
</button>
|
||
</div>
|
||
</div>
|
||
|
||
{error ? (
|
||
<p className="defs-sheet-error" role="alert" data-testid="sheet-error">
|
||
{error}
|
||
</p>
|
||
) : null}
|
||
|
||
<div className="defs-sheet-footer">
|
||
<button type="button" className="defs-cancel" onClick={onCancel} disabled={saving}>
|
||
Cancel
|
||
</button>
|
||
<button type="button" className="defs-save" onClick={save} disabled={saving}>
|
||
{saving ? "Saving…" : "Save changes"}
|
||
</button>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
);
|
||
}
|
||
|
||
/* ── Screen ─────────────────────────────────────────────────────────── */
|
||
|
||
export default function DefinitionsTab() {
|
||
const [state, setState] = useState<LoadState>({ kind: "loading" });
|
||
const [attempt, setAttempt] = useState(0);
|
||
const [filter, setFilter] = useState<number | "all">("all");
|
||
const [sheet, setSheet] = useState<SheetTarget>(null);
|
||
|
||
useEffect(() => {
|
||
let cancelled = false;
|
||
// Keep the list on screen during a post-save re-fetch; spin only on first load.
|
||
setState((current) => (current.kind === "ready" ? current : { kind: "loading" }));
|
||
Promise.all([fetchDefinitions(), fetchChildren()])
|
||
.then(([definitions, children]) => {
|
||
if (!cancelled) setState({ kind: "ready", definitions, children });
|
||
})
|
||
.catch((error: unknown) => {
|
||
if (cancelled) return;
|
||
const message =
|
||
error instanceof ApiForbiddenError
|
||
? error.message
|
||
: "Tasks could not be loaded. Check your connection and try again.";
|
||
setState({ kind: "error", message });
|
||
});
|
||
return () => {
|
||
cancelled = true;
|
||
};
|
||
}, [attempt]);
|
||
|
||
const activeChildren =
|
||
state.kind === "ready"
|
||
? [...state.children]
|
||
.filter((child) => child.is_active)
|
||
.sort((a, b) => a.sort_order - b.sort_order)
|
||
: [];
|
||
|
||
let sub = "";
|
||
let body;
|
||
if (state.kind === "loading") {
|
||
body = (
|
||
<div className="defs-status" role="status" data-testid="definitions-loading">
|
||
Loading tasks…
|
||
</div>
|
||
);
|
||
} else if (state.kind === "error") {
|
||
body = (
|
||
<div className="defs-status defs-status--error" role="alert" data-testid="definitions-error">
|
||
<p>{state.message}</p>
|
||
<button type="button" className="defs-retry" onClick={() => setAttempt((n) => n + 1)}>
|
||
Try again
|
||
</button>
|
||
</div>
|
||
);
|
||
} else {
|
||
const { definitions } = state;
|
||
sub = `${definitions.length} definitions · ${activeChildren.length} children`;
|
||
const shown =
|
||
filter === "all"
|
||
? definitions
|
||
: definitions.filter((d) => d.assignees.some((a) => a.id === filter));
|
||
const editingId = sheet !== null && sheet !== "new" ? sheet.id : null;
|
||
body = (
|
||
<>
|
||
<FilterChips options={activeChildren} filter={filter} onChange={setFilter} />
|
||
{shown.length > 0 ? (
|
||
<ul className="defs-card defs-list" aria-label="Task definitions">
|
||
{shown.map((definition) => (
|
||
<DefinitionRow
|
||
key={definition.id}
|
||
definition={definition}
|
||
activeChildren={activeChildren}
|
||
editing={definition.id === editingId}
|
||
onOpen={() => setSheet(definition)}
|
||
/>
|
||
))}
|
||
</ul>
|
||
) : (
|
||
<div className="defs-card defs-empty">No tasks yet.</div>
|
||
)}
|
||
</>
|
||
);
|
||
}
|
||
|
||
return (
|
||
<div className="defs-screen">
|
||
<header className="defs-header">
|
||
<div>
|
||
<h2 className="defs-title">Tasks</h2>
|
||
<p className="defs-sub">{sub}</p>
|
||
</div>
|
||
<button
|
||
type="button"
|
||
className="defs-new"
|
||
disabled={state.kind !== "ready"}
|
||
onClick={() => setSheet("new")}
|
||
>
|
||
<PlusGlyph />
|
||
New
|
||
</button>
|
||
</header>
|
||
<div
|
||
className="defs-scroll"
|
||
data-testid="definitions-scroll"
|
||
style={{ paddingBottom: SCROLL_BOTTOM_PADDING }}
|
||
>
|
||
{body}
|
||
</div>
|
||
{sheet !== null && state.kind === "ready" ? (
|
||
<EditSheet
|
||
key={sheet === "new" ? "new" : sheet.id}
|
||
target={sheet}
|
||
activeChildren={activeChildren}
|
||
onCancel={() => setSheet(null)}
|
||
onSaved={() => {
|
||
setSheet(null);
|
||
setAttempt((n) => n + 1);
|
||
}}
|
||
/>
|
||
) : null}
|
||
</div>
|
||
);
|
||
}
|