import { Fragment, useCallback, useEffect, useId, useLayoutEffect, useMemo, useRef, useState, type Dispatch, type FormEvent, type ReactNode, type SetStateAction, } from "react"; import { ArrowCounterClockwise } from "@phosphor-icons/react/dist/csr/ArrowCounterClockwise"; import { ArrowRight } from "@phosphor-icons/react/dist/csr/ArrowRight"; import { CalendarBlank } from "@phosphor-icons/react/dist/csr/CalendarBlank"; import { Funnel } from "@phosphor-icons/react/dist/csr/Funnel"; import { MagnifyingGlass } from "@phosphor-icons/react/dist/csr/MagnifyingGlass"; import { X } from "@phosphor-icons/react/dist/csr/X"; import { useEscapeClose } from "../../ui/useEscapeClose"; import ProjectTasks from "./ProjectTasks"; import ProjectSkuPicker from "./ProjectSkuPicker"; import { PdpApprovalRow, PdpOverviewRows, PdpStep, type ProjectPdp } from "./pdp/ContinueWorkflow"; import { removeItems } from "./pdp/api"; import { EMPTY_FILTER, GRAINS, ProductToolbar, SelectBox, TABLES, normalizeProducts, number, readPage, scopedNodes, type Field, type FilterTree, type Row, type Sorts, } from "./ProjectSkuPicker"; import { CenteredPopup, GRAIN_LABEL, PROJECT_PRIORITIES, HealthChip, Owner, OwnerSelect, PriorityGlyph, ProjectFooter, ProjectRequestError, StatusPicker, StatusPill, call, clampPercent, draftOf, enc, messageOf, pictureSrc, text, type Detail, type Priority, type Project, type ProjectDraft, type ProjectGrain, type ProjectInput, type Status, type Target, } from "./ProjectsShared"; import "../../styles/sdlc85/project-overview.css"; type ProjectPerson = { username: string; name: string }; type OverviewProject = Project & { contributors?: ProjectPerson[] }; type OverviewDraft = ProjectDraft & { contributors: string[] }; type OverviewInput = ProjectInput & { contributors?: string[] }; type OverviewField = keyof OverviewDraft | "targets"; type TargetPair = { grain: ProjectGrain; key: string }; type RemoveRefusal = { grain?: ProjectGrain; key: string | null; reason: string }; type RemoveAnswer = { project: Project; targets: Target[]; refused?: RemoveRefusal[]; cause?: string }; type RemoveOutcome = { refused: RemoveRefusal[] } | { error: string }; function overviewDraftOf(project: OverviewProject): OverviewDraft { return { ...draftOf(project), contributors: (project.contributors ?? []).map(person => person.username).sort() }; } /** The product row a Projects cell opened from. It scopes the SKU list and the Dashboard until cleared. */ export type RowScope = { grain: ProjectGrain; key: string }; /** A SKU target matches by key, an ASIN by `asin` and a Parent ASIN by `parentAsin`. ASIN keys ignore case. */ const ROW_SCOPE_VALUE: Record string> = { sku: target => target.grain === "sku" ? text(target.key) : text(target.sku), asin: target => target.grain === "asin" ? text(target.key) : text(target.asin), parent_asin: target => target.grain === "parent_asin" ? text(target.key) : text(target.parentAsin), }; export function inRowScope(target: Target, scope: RowScope) { const value = ROW_SCOPE_VALUE[scope.grain](target); return scope.grain === "sku" ? value === scope.key : value.toUpperCase() === scope.key.toUpperCase(); } /** The row filter chip wears the filter kit's active Filter look. Its clear control removes the scope. */ export function RowScopeChip({ scope, onClear }: { scope: RowScope; onClear: () => void }) { const name = GRAIN_LABEL[scope.grain]; const label = `${name} is ${scope.key}`; return
; } type PeoplePickerProps = { label: string; selected: string[]; people: ProjectPerson[]; loading: boolean; error: string; disabled: boolean; active: boolean; multiple?: boolean; caption: string; onRetry: () => void; onChange: (selected: string[]) => void; }; function PeoplePicker(props: PeoplePickerProps) { const [open, setOpen] = useState(false); const trigger = useRef(null); const popupId = useId(); const visible = open && props.active; useEffect(() => { if (!props.active) setOpen(false); }, [props.active]); return
{visible ? setOpen(false)} /> : null}
; } function PeopleOptions({ id, trigger, onClose, ...props }: PeoplePickerProps & { id: string; trigger: HTMLButtonElement | null; onClose: () => void; }) { const panel = useRef(null); const search = useRef(null); const [query, setQuery] = useState(""); const term = query.trim().toLocaleLowerCase(); const matches = props.people.filter(person => `${person.name} ${person.username}`.toLocaleLowerCase().includes(term)); useEscapeClose(true, onClose, { container: () => panel.current }); useLayoutEffect(() => { search.current?.focus({ preventScroll: true }); panel.current?.scrollIntoView({ block: "nearest" }); return () => { if (trigger?.isConnected) trigger.focus({ preventScroll: true }); }; }, [trigger]); useEffect(() => { const dismiss = (event: PointerEvent) => { if (event.target instanceof Node && !panel.current?.contains(event.target) && !trigger?.contains(event.target)) onClose(); }; document.addEventListener("pointerdown", dismiss, true); return () => document.removeEventListener("pointerdown", dismiss, true); }, [onClose, trigger]); return ; } function PeopleStack({ people }: { people: Array }) { const shown = people.slice(0, 3); const remaining = people.slice(shown.length); return
{shown.map(person => )} {remaining.length ? `${person.name}, ${person.role}`).join("\n")}>+{remaining.length} : null}
; } function SetupRow({ field, label, error, children, readOnly = false }: { field: string; label: string; error?: string; children: ReactNode; readOnly?: boolean; }) { const labelId = useId(); const errorId = `${labelId}-error`; return
{label}
{children} {error ? : null}
; } function SetupDate({ label, value, canEdit, busy, onChange, max, hint, invalid }: { label: string; value: string | null; canEdit: boolean; busy: boolean; onChange: (value: string | null) => void; max?: string; hint?: string; invalid?: boolean; }) { const [editing, setEditing] = useState(false); const trigger = useRef(null); const caption = value ? new Date(`${value}T00:00:00`).toLocaleDateString("en-US", { month: "short", day: "numeric", year: "numeric" }) : "Not set"; if (!canEdit) return value ? : Not set; return editing ? { if (event.key === "Escape") { event.preventDefault(); event.stopPropagation(); setEditing(false); window.requestAnimationFrame(() => trigger.current?.focus()); } else if (event.key === "Enter") { event.preventDefault(); setEditing(false); window.requestAnimationFrame(() => trigger.current?.focus()); } }} onChange={event => onChange(event.target.value || null)} onBlur={() => setEditing(false)} /> : ; } function ProjectDeleteDialog({ name, busy, error, onCancel, onConfirm }: { name: string; busy: boolean; error: string; onCancel: () => void; onConfirm: () => void; }) { const [typedName, setTypedName] = useState(""); const inputId = useId(); const dismiss = () => { if (!busy) onCancel(); }; return
{ event.preventDefault(); event.stopPropagation(); if (!busy && typedName === name) onConfirm(); }}>

This permanently deletes the project.

{error || (busy ? "Deleting project…" : "")}

; } export default function ProjectOverview({ id, detail, canEdit: mayEdit, onChanged, onDeleted, onCancel, error, setError, setDetail, setTick, formId, active, rowScope = null, onClearRowScope, pdp }: { id: string; detail: Detail; canEdit: boolean; onChanged: () => void; onDeleted: () => void; onCancel: () => void; error: string; setError: Dispatch>; setDetail: Dispatch>; setTick: Dispatch>; formId: string; active: boolean; rowScope?: RowScope | null; onClearRowScope?: () => void; pdp?: ProjectPdp; }) { const [draft, setDraft] = useState(() => overviewDraftOf(detail.project)); const [people, setPeople] = useState([]); const [peopleLoading, setPeopleLoading] = useState(true); const [peopleError, setPeopleError] = useState(""); const [peopleAttempt, setPeopleAttempt] = useState(0); const [busy, setBusy] = useState(false); const [adding, setAdding] = useState(false); const [confirming, setConfirming] = useState(false); const [editingDescription, setEditingDescription] = useState(false); const [fieldErrors, setFieldErrors] = useState>>({}); const [saved, setSaved] = useState(false); const [taskCount, setTaskCount] = useState(null); const writing = useRef(false); const taskProjectChanged = useCallback((change: Partial) => { setDetail(current => current ? { ...current, project: { ...current.project, ...change } } : current); const progress = change.progress; if (typeof progress === "number") setDraft(current => ({ ...current, progress })); }, [setDetail]); const tasksLoaded = useCallback((summary: { count: number; progress: number | null }) => { setTaskCount(summary.count); if (summary.progress !== null) taskProjectChanged({ progress: summary.progress }); }, [taskProjectChanged]); const taskChanged = () => { setTick(value => value + 1); onChanged(); }; const write = useCallback(async (path: string, method: string, body: unknown, after?: () => void, fields?: OverviewField[]) => { if (writing.current || !mayEdit || !detail?.canEdit) return; writing.current = true; setBusy(true); const fallback = method === "DELETE" ? "The project was not deleted." : "The change was not saved."; if (method === "DELETE") setError(""); try { const answer = await call<{ project?: Project; targets?: Target[] }>(path, { method, body }, fallback); if (answer.project) { const project = answer.project; setDetail((current) => current ? { ...current, project, targets: answer.targets ?? current.targets } : current); if (method === "PATCH") setDraft(overviewDraftOf(project)); } setError(""); setFieldErrors({}); if (method === "PATCH") setSaved(true); if (after) after(); else setTick((value) => value + 1); onChanged(); } catch (reason) { const message = messageOf(reason, fallback); if (fields?.length) { const dateFields = fields.filter(field => field === "startOn" || field === "targetOn"); const namedField = fields.find(field => message.toLowerCase().includes( ({ startOn: "start_on", targetOn: "target_on", completedOn: "completed_on", ownerUsername: "owner", contributors: "contribut" } as Partial>)[field] ?? field.toLowerCase())); const affected = message === "Target date cannot be before the start date." && dateFields.length ? dateFields : namedField ? [namedField] : fields; setFieldErrors(Object.fromEntries(affected.map(field => [field, message]))); setError(""); } else setError(message); if (reason instanceof ProjectRequestError && reason.status === 403) { setDetail((current) => current ? { ...current, canEdit: false } : current); onChanged(); } } finally { writing.current = false; setBusy(false); } }, [detail?.canEdit, mayEdit, onChanged, setDetail, setError, setTick]); const patch = useCallback((change: OverviewInput, fields: Array) => write(`/${enc(id)}`, "PATCH", change, undefined, fields), [id, write]); // One POST carries every selected target. A key still linked in the answer is a refusal. const removeTargets = useCallback(async (pairs: TargetPair[]): Promise => { if (writing.current || !mayEdit || !detail?.canEdit || !pairs.length) return null; writing.current = true; setBusy(true); const fallback = "Products were not removed."; try { if (pdp) { if (!pdp.detail?.canEdit) throw new Error("The workflow is unavailable. Reload the project."); pdp.accept((await removeItems(id, pairs.map(pair => pair.key))).workflow); setTick(value => value + 1); return { refused: [] }; } const answer = await call(`/${enc(id)}/targets/remove`, { method: "POST", body: { targets: pairs } }, fallback); if (!answer?.project || !Array.isArray(answer.targets)) throw new Error("The remove answer is incomplete. Reload the project."); setDetail(current => current ? { ...current, targets: answer.targets, project: answer.project, cause: answer.cause } : current); setError(""); setFieldErrors(current => ({ ...current, targets: undefined })); setTick(value => value + 1); onChanged(); const named = Array.isArray(answer.refused) ? answer.refused.filter(item => item && typeof item.reason === "string") : []; const namedKeys = new Set(named.map(item => item.key)); const linked = new Set(answer.targets.map(target => `${target.grain}:${target.key}`)); const kept = pairs.filter(pair => linked.has(`${pair.grain}:${pair.key}`) && !namedKeys.has(pair.key)) .map(pair => ({ ...pair, reason: "Still linked after removal" })); return { refused: [...named, ...kept] }; } catch (reason) { if (reason instanceof ProjectRequestError && reason.status === 403) { setDetail(current => current ? { ...current, canEdit: false } : current); onChanged(); } return { error: messageOf(reason, fallback) }; } finally { writing.current = false; setBusy(false); } }, [detail?.canEdit, id, mayEdit, onChanged, setDetail, setError, setTick, pdp]); const { project, targets } = detail; const canEdit = mayEdit && detail.canEdit && (!pdp || Boolean(pdp.detail?.canEdit)); const deleteOpen = confirming && canEdit && active; useEffect(() => { if (!canEdit || !active) { setConfirming(false); setAdding(false); } }, [canEdit, active]); // Readers load names too: the owners door admits every reader, and assignees show by name. useEffect(() => { const controller = new AbortController(); setPeopleLoading(true); setPeopleError(""); void call<{ owners: ProjectPerson[] }>("/owners", { signal: controller.signal }, "People did not load.") .then(answer => { if (!controller.signal.aborted) setPeople(answer.owners); }) .catch(reason => { if (!controller.signal.aborted) setPeopleError(messageOf(reason, "People did not load.")); }) .finally(() => { if (!controller.signal.aborted) setPeopleLoading(false); }); return () => controller.abort(); }, [canEdit, peopleAttempt]); const display = canEdit ? draft : project; const progress = Number.isFinite(display.progress) ? clampPercent(display.progress) : 0; const summaryOwner = project.owner || project.ownerUsername || null; const savedContributors = (project as OverviewProject).contributors ?? []; const identities = new Map([...savedContributors, ...people].map(person => [person.username, person])); const ownerName = (display.ownerUsername ? identities.get(display.ownerUsername)?.name : null) || display.owner || (display.ownerUsername === project.ownerUsername ? project.owner : null) || display.ownerUsername; const contributors = canEdit ? draft.contributors.map(username => identities.get(username) ?? { username, name: username }) : savedContributors; const projectPeople = [ ...(ownerName ? [{ username: display.ownerUsername || "__legacy_owner__", name: ownerName, role: "Owner" }] : []), ...contributors.filter(person => person.username !== display.ownerUsername).map(person => ({ ...person, role: "Contributor" })), ]; const pickerProps = { people, loading: peopleLoading, error: peopleError, disabled: busy, active, onRetry: () => setPeopleAttempt(value => value + 1) }; const dirty = JSON.stringify(draft) !== JSON.stringify(overviewDraftOf(project)); // A row scope applies only with its clear control, so the list never narrows without a way back. const scope = rowScope && onClearRowScope ? { ...rowScope, clear: onClearRowScope } : null; const scopedCount = scope ? targets.filter(target => inRowScope(target, scope)).length : null; const set =(key: K, value: OverviewDraft[K]) => { setSaved(false); setFieldErrors(current => ({ ...current, [key]: undefined })); setDraft(current => current ? { ...current, [key]: value, ...(key === "status" && value !== "Completed" ? { completedOn: null } : {}), ...(key === "completedOn" && value ? { status: "Completed" as Status } : {}), } : current); }; const save = (event: FormEvent) => { event.preventDefault(); if (!canEdit || !dirty) return; const name = draft.name.trim(); if (!name) { setFieldErrors({ name: "Name the project." }); return; } if (!Number.isInteger(draft.progress) || draft.progress < 0 || draft.progress > 100) { setFieldErrors({ progress: "Enter a whole percent from 0 to 100." }); return; } const today = new Date().toISOString().slice(0, 10); if (draft.completedOn && draft.completedOn > today) { setFieldErrors({ completedOn: "Choose today or an earlier date." }); return; } if (project.completedOn && draft.status === "Completed" && !draft.completedOn) { setFieldErrors({ completedOn: "Choose a completed date, or change Status to reopen the project." }); return; } const original = overviewDraftOf(project); const changed = (Object.keys(draft) as Array) .filter(key => JSON.stringify(draft[key]) !== JSON.stringify(original[key])); const fields = Object.fromEntries(changed.filter(key => key !== "owner").map(key => [key, draft[key]])) as OverviewInput; if (changed.includes("owner")) fields.ownerUsername = draft.ownerUsername; if (changed.includes("name")) fields.name = name; if (changed.includes("notes")) fields.notes = draft.notes?.trim() || null; setSaved(false); setFieldErrors({}); void patch(fields, changed); }; return

{canEdit ? <> set("name", event.target.value)} /> : project.name}

{fieldErrors.name ? : null}
{scope ? : null}

Project status: {display.status.toLowerCase()}

Summary

{progress}% complete. {project.health ? `Health is ${project.health.toLowerCase()}.` : "Health is not set."}

Owner: {summaryOwner || "No owner"} Updated: {project.updatedAt ? : "Not available"}
{project.type === "pdp" && pdp ? : null} {canEdit ? set("status", value)} /> : }
{canEdit ? : {project.priority}}
{canEdit ? { set("ownerUsername", values[0] ?? null); set("owner", null); }} /> : project.owner || project.ownerUsername ? : No owner} {project.type === "pdp" && pdp ? : null}
{contributors.map(person => {canEdit ? : null} )} {canEdit ? set("contributors", values)} /> : !contributors.length ? No contributors : null}
{([ ["startOn", "Start"], ["targetOn", "Target"] ] as const) .map(([field, label], index) =>
{index === 1 ?
)}
set("completedOn", value)} /> {canEdit && taskCount === 0 ?
set("progress", event.target.valueAsNumber)} />%
: {progress}%}
{project.health ? : Not set} {canEdit ? draft.notes || editingDescription ?