Download web/src/apps/amazon-profit/ProjectOverview.tsx from fsanyoto/loopable: direct link, hf CLI and curl.
- Browser
- Download file 59.9 kB
-
https://huggingface.co/spaces/fsanyoto/loopable/resolve/main/web/src/apps/amazon-profit/ProjectOverview.tsx
- Command line
-
hf download hf://spaces/fsanyoto/loopable/web/src/apps/amazon-profit/ProjectOverview.tsx
-
curl -L -o ProjectOverview.tsx https://huggingface.co/spaces/fsanyoto/loopable/resolve/main/web/src/apps/amazon-profit/ProjectOverview.tsx
59.9 kB
| 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<ProjectGrain, (target: Target) => 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 <div className="lp-proj-section-head"> | |
| <span className="cg-tb-btn cg-tb-btn--filter is-active" role="group" aria-label={`Filter: ${label}`} | |
| data-row-scope={scope.grain}> | |
| <Funnel size={16} aria-hidden="true" /> | |
| <span className="lp-proj-clip" title={label}>{label}</span> | |
| <button type="button" className="lp-proj-person-remove" aria-label={`Clear ${name} filter`} title="Clear filter" | |
| onClick={onClear}><X size={12} aria-hidden="true" /></button> | |
| </span> | |
| </div>; | |
| } | |
| 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<HTMLButtonElement>(null); | |
| const popupId = useId(); | |
| const visible = open && props.active; | |
| useEffect(() => { if (!props.active) setOpen(false); }, [props.active]); | |
| return <div className="lp-proj-people-picker"> | |
| <button ref={trigger} type="button" className="lp-proj-setup-edit" disabled={props.disabled} | |
| data-empty={!props.selected.length || undefined} aria-label={`Choose ${props.label.toLowerCase()}`} | |
| aria-haspopup="dialog" aria-expanded={visible} aria-controls={visible ? popupId : undefined} | |
| onClick={() => setOpen(value => !value)}>{props.caption}</button> | |
| {visible ? <PeopleOptions {...props} id={popupId} trigger={trigger.current} onClose={() => setOpen(false)} /> : null} | |
| </div>; | |
| } | |
| function PeopleOptions({ id, trigger, onClose, ...props }: PeoplePickerProps & { | |
| id: string; trigger: HTMLButtonElement | null; onClose: () => void; | |
| }) { | |
| const panel = useRef<HTMLDivElement>(null); | |
| const search = useRef<HTMLInputElement>(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 <div ref={panel} id={id} className="lp-proj-people-popover" role="dialog" | |
| aria-label={`Choose ${props.label.toLowerCase()}`} aria-busy={props.loading}> | |
| <div className="lp-proj-people-search"> | |
| <input ref={search} type="search" className="lp-proj-input" aria-label="Search people" | |
| placeholder="Search people" value={query} onChange={event => setQuery(event.target.value)} | |
| onKeyDown={event => { if (event.key === "Enter") event.preventDefault(); }} /> | |
| <button type="button" className="lp-proj-setup-edit" onClick={onClose}>Done</button> | |
| </div> | |
| {props.loading ? <p className="lp-proj-muted" role="status">Loading people…</p> : props.error ? <div> | |
| <p className="lp-proj-error" role="alert">{props.error}</p> | |
| <button type="button" className="lp-proj-setup-edit" disabled={props.disabled} onClick={props.onRetry}>Retry</button> | |
| </div> : <ul className="lp-proj-people-options" aria-label="Workspace people"> | |
| {!props.multiple ? <li><label className="lp-proj-person-option"> | |
| <input type="radio" name={id} checked={!props.selected.length} disabled={props.disabled} | |
| onChange={() => { props.onChange([]); onClose(); }} /> | |
| <span>No owner</span> | |
| </label></li> : null} | |
| {matches.map(person => <li key={person.username}><label className="lp-proj-person-option"> | |
| <input type={props.multiple ? "checkbox" : "radio"} name={id} | |
| checked={props.selected.includes(person.username)} disabled={props.disabled} | |
| onChange={() => { | |
| props.onChange(props.multiple | |
| ? props.selected.includes(person.username) ? props.selected.filter(username => username !== person.username) | |
| : [...props.selected, person.username].sort() | |
| : [person.username]); | |
| if (!props.multiple) onClose(); | |
| }} /> | |
| <Owner name={person.name} compact /> | |
| <span className="lp-proj-person-name"><span>{person.name}</span> | |
| <span className="lp-proj-muted">{person.username}</span></span> | |
| </label></li>)} | |
| </ul>} | |
| {!props.loading && !props.error && !matches.length | |
| ? <p className="lp-proj-muted" role="status">{term ? "No people match" : "No people available"}</p> : null} | |
| </div>; | |
| } | |
| function PeopleStack({ people }: { people: Array<ProjectPerson & { role: string }> }) { | |
| const shown = people.slice(0, 3); | |
| const remaining = people.slice(shown.length); | |
| return <div className="lp-proj-people-stack" role="group" aria-label={`${people.length} project people`}> | |
| {shown.map(person => <span key={person.username} className="lp-proj-person-avatar" data-role={person.role} | |
| role="img" aria-label={`${person.name}, ${person.role}`} | |
| title={`${person.name}, ${person.role}`}><Owner name={person.name} compact /></span>)} | |
| {remaining.length ? <span className="lp-proj-people-count" role="img" aria-label={`${remaining.length} more people`} | |
| title={remaining.map(person => `${person.name}, ${person.role}`).join("\n")}>+{remaining.length}</span> : null} | |
| </div>; | |
| } | |
| 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 <div className="lp-proj-setup-row" data-field={field} data-read-only={readOnly || undefined} | |
| data-error={Boolean(error) || undefined} role="group" aria-labelledby={labelId} | |
| aria-describedby={error ? errorId : undefined}> | |
| <span className="lp-proj-setup-label" id={labelId}>{label}</span> | |
| <div className="lp-proj-setup-value"> | |
| {children} | |
| {error ? <p id={errorId} className="lp-proj-error lp-proj-setup-error" role="alert">{error}</p> : null} | |
| </div> | |
| </div>; | |
| } | |
| 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<HTMLButtonElement>(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 ? <time dateTime={value}>{caption}</time> : <span className="lp-proj-muted">Not set</span>; | |
| return editing ? <input className="lp-proj-setup-input" type="date" aria-label={label} | |
| value={value ?? ""} disabled={busy} max={max} autoFocus aria-invalid={invalid || undefined} | |
| onKeyDown={event => { | |
| 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)} /> | |
| : <button ref={trigger} type="button" className="lp-proj-setup-edit lp-proj-date-edit" data-empty={!value || undefined} | |
| aria-label={`${value ? "Edit" : "Add"} ${label.toLowerCase()}`} title={hint} | |
| disabled={busy} onClick={() => setEditing(true)}> | |
| <CalendarBlank size={16} aria-hidden="true" /> | |
| {value ? caption : `Add ${label.toLowerCase()}`} | |
| </button>; | |
| } | |
| 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 <CenteredPopup title="Delete project" size="narrow" className="lp-proj-delete-popup" onClose={dismiss}> | |
| <form className="lp-proj-delete-form" aria-label="Confirm project deletion" aria-busy={busy} | |
| onSubmit={event => { | |
| event.preventDefault(); | |
| event.stopPropagation(); | |
| if (!busy && typedName === name) onConfirm(); | |
| }}> | |
| <p id={`${inputId}-hint`} className="lp-proj-muted">This permanently deletes the project.</p> | |
| <label className="lp-proj-delete-name" htmlFor={inputId}> | |
| <span>Type <strong>{name}</strong> to confirm</span> | |
| <input id={inputId} type="text" className="lp-proj-input" value={typedName} disabled={busy} | |
| autoComplete="off" autoCapitalize="none" spellCheck={false} | |
| aria-describedby={`${inputId}-hint ${inputId}-feedback`} | |
| onChange={event => setTypedName(event.target.value)} /> | |
| </label> | |
| <p id={`${inputId}-feedback`} className="lp-proj-delete-feedback" role={error ? "alert" : "status"}> | |
| {error || (busy ? "Deleting project…" : "")} | |
| </p> | |
| <div className="lp-proj-delete-actions"> | |
| <button type="button" className="lp-proj-btn lp-proj-btn-quiet" disabled={busy} onClick={dismiss}>Cancel</button> | |
| <button type="submit" className="lp-proj-btn lp-proj-delete-button" disabled={busy || typedName !== name}>Delete</button> | |
| </div> | |
| </form> | |
| </CenteredPopup>; | |
| } | |
| 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<SetStateAction<string>>; setDetail: Dispatch<SetStateAction<Detail | null>>; | |
| setTick: Dispatch<SetStateAction<number>>; formId: string; active: boolean; | |
| rowScope?: RowScope | null; onClearRowScope?: () => void; | |
| pdp?: ProjectPdp; | |
| }) { | |
| const [draft, setDraft] = useState<OverviewDraft>(() => overviewDraftOf(detail.project)); | |
| const [people, setPeople] = useState<ProjectPerson[]>([]); | |
| 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<Partial<Record<OverviewField, string>>>({}); | |
| const [saved, setSaved] = useState(false); | |
| const [taskCount, setTaskCount] = useState<number | null>(null); | |
| const writing = useRef(false); | |
| const taskProjectChanged = useCallback((change: Partial<Project>) => { | |
| 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<Record<OverviewField, string>>)[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<keyof OverviewDraft>) => | |
| 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<RemoveOutcome | null> => { | |
| 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<RemoveAnswer>(`/${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 =<K extends keyof OverviewDraft>(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<keyof OverviewDraft>) | |
| .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 <form id={formId} className="lp-proj-detail lp-proj-accent" data-status={display.status} | |
| data-can-edit={canEdit ? "true" : "false"} onSubmit={save} aria-label="Project overview" aria-busy={busy} noValidate> | |
| <div className="lp-proj-main"> | |
| <div data-field="name"> | |
| <div className="lp-proj-overview-heading"> | |
| <h2 className="lp-proj-title" tabIndex={-1} aria-label={display.name || "Untitled project"}> | |
| {canEdit ? <> | |
| <span className="lp-proj-title-measure" aria-hidden="true">{draft.name || " "}</span> | |
| <input className="lp-proj-title-input" value={draft.name} aria-label="Project name" | |
| aria-invalid={Boolean(fieldErrors.name)} disabled={busy} required maxLength={300} | |
| aria-describedby={fieldErrors.name ? `${formId}-name-error` : undefined} | |
| onChange={event => set("name", event.target.value)} /> | |
| </> : project.name} | |
| </h2> | |
| <StatusPill status={display.status} progress={progress} /> | |
| <PeopleStack people={projectPeople} /> | |
| </div> | |
| {fieldErrors.name ? <p id={`${formId}-name-error`} className="lp-proj-error lp-proj-setup-error" role="alert"> | |
| {fieldErrors.name} | |
| </p> : null} | |
| </div> | |
| {scope ? <RowScopeChip scope={scope} onClear={scope.clear} /> : null} | |
| <section className="lp-proj-status-card" aria-label="Project status"> | |
| <h3 className="lp-proj-status-card-heading">Project status: {display.status.toLowerCase()}</h3> | |
| <div className="lp-proj-status-card-summary"> | |
| <h4>Summary</h4> | |
| <p>{progress}% complete. {project.health ? `Health is ${project.health.toLowerCase()}.` : "Health is not set."}</p> | |
| </div> | |
| <footer className="lp-proj-status-card-footer"> | |
| <Owner name={summaryOwner} compact /> | |
| <div className="lp-proj-status-card-metadata"> | |
| <span className="lp-proj-status-card-owner">Owner: {summaryOwner || "No owner"}</span> | |
| <span className="lp-proj-status-card-updated">Updated: {project.updatedAt | |
| ? <time dateTime={project.updatedAt} title={project.updatedAt}> | |
| {new Date(project.updatedAt).toLocaleDateString("en-US", { month: "short", day: "numeric", year: "numeric" })} | |
| </time> | |
| : "Not available"}</span> | |
| </div> | |
| </footer> | |
| </section> | |
| <div className="lp-proj-setup-fields"> | |
| {project.type === "pdp" && pdp ? <PdpOverviewRows pdp={pdp} /> : null} | |
| <SetupRow field="status" label="Status" error={fieldErrors.status} readOnly={!canEdit}> | |
| {canEdit | |
| ? <StatusPicker value={draft.status} disabled={busy} onChange={value => set("status", value)} /> | |
| : <StatusPill status={project.status} progress={progress} />} | |
| </SetupRow> | |
| <SetupRow field="priority" label="Priority" error={fieldErrors.priority} readOnly={!canEdit}> | |
| <div className="lp-proj-setup-inline"><PriorityGlyph priority={display.priority} /> | |
| {canEdit | |
| ? <select className="lp-proj-setup-input" aria-label="Priority" value={draft.priority} disabled={busy} | |
| data-empty={draft.priority === "No priority" || undefined} aria-invalid={Boolean(fieldErrors.priority)} | |
| onChange={(event) => set("priority", event.target.value as Priority)}> | |
| {PROJECT_PRIORITIES.map((value) => <option key={value} value={value}>{value === "No priority" ? "Add priority" : value}</option>)} | |
| </select> | |
| : <span className={project.priority === "No priority" ? "lp-proj-muted" : undefined}>{project.priority}</span>} | |
| </div> | |
| </SetupRow> | |
| <SetupRow field="ownerUsername" label="Owner" error={fieldErrors.ownerUsername || fieldErrors.owner} readOnly={!canEdit}> | |
| {canEdit ? <PeoplePicker {...pickerProps} label="Owner" selected={draft.ownerUsername ? [draft.ownerUsername] : []} | |
| caption={ownerName || "Add owner"} | |
| onChange={values => { set("ownerUsername", values[0] ?? null); set("owner", null); }} /> : project.owner || project.ownerUsername | |
| ? <Owner name={project.owner || project.ownerUsername || null} /> : <span className="lp-proj-muted">No owner</span>} | |
| </SetupRow> | |
| {project.type === "pdp" && pdp ? <PdpApprovalRow pdp={pdp} canEdit={canEdit} /> : null} | |
| <SetupRow field="contributors" label="Contributors" error={fieldErrors.contributors} readOnly={!canEdit}> | |
| <div className="lp-proj-contributors"> | |
| {contributors.map(person => <span key={person.username} className="lp-proj-contributor"> | |
| <Owner name={person.name} /> | |
| {canEdit ? <button type="button" className="lp-proj-person-remove" disabled={busy} | |
| aria-label={`Remove ${person.name} from contributors`} | |
| onClick={() => set("contributors", draft.contributors.filter(username => username !== person.username))}> | |
| <X size={12} aria-hidden="true" /> | |
| </button> : null} | |
| </span>)} | |
| {canEdit ? <PeoplePicker {...pickerProps} label="Contributors" selected={draft.contributors} multiple | |
| caption="Add people" onChange={values => set("contributors", values)} /> | |
| : !contributors.length ? <span className="lp-proj-muted">No contributors</span> : null} | |
| </div> | |
| </SetupRow> | |
| <div className="lp-proj-date-range" role="group" aria-label="Start to target"> | |
| {([ ["startOn", "Start"], ["targetOn", "Target"] ] as const) | |
| .map(([field, label], index) => <div key={field} className="lp-proj-date-property"> | |
| {index === 1 ? <ArrowRight size={16} className="lp-proj-date-arrow" aria-hidden="true" /> : null} | |
| <SetupRow field={field} label={label} error={fieldErrors[field]} readOnly={!canEdit}> | |
| <SetupDate label={`${label} date`} value={display[field]} canEdit={canEdit} busy={busy} | |
| invalid={Boolean(fieldErrors[field])} onChange={value => set(field, value)} /> | |
| </SetupRow> | |
| </div>)} | |
| </div> | |
| <SetupRow field="completedOn" label="Completed" error={fieldErrors.completedOn} readOnly={!canEdit}> | |
| <SetupDate label="Completed date" value={display.completedOn} canEdit={canEdit} busy={busy} | |
| max={new Date().toISOString().slice(0, 10)} invalid={Boolean(fieldErrors.completedOn)} | |
| hint={display.status !== "Completed" ? "Also sets Status to Completed" : undefined} | |
| onChange={value => set("completedOn", value)} /> | |
| </SetupRow> | |
| <SetupRow field="progress" label="Progress" error={fieldErrors.progress} readOnly={!canEdit || taskCount !== 0}> | |
| {canEdit && taskCount === 0 ? <div className="lp-proj-setup-inline"> | |
| <input className="lp-proj-setup-input lp-proj-setup-percent" type="number" aria-label="Progress" | |
| min={0} max={100} step={1} value={Number.isNaN(draft.progress) ? "" : draft.progress} disabled={busy} | |
| aria-invalid={Boolean(fieldErrors.progress)} | |
| onChange={event => set("progress", event.target.valueAsNumber)} /><span>%</span> | |
| </div> : <span title={taskCount ? "Calculated from active leaf tasks" : undefined}>{progress}%</span>} | |
| </SetupRow> | |
| <SetupRow field="health" label="Health" readOnly> | |
| {project.health ? <HealthChip health={project.health} /> : <span className="lp-proj-muted">Not set</span>} | |
| </SetupRow> | |
| <SetupRow field="notes" label="Description" error={fieldErrors.notes} readOnly={!canEdit}> | |
| {canEdit ? draft.notes || editingDescription | |
| ? <textarea className="lp-proj-setup-input lp-proj-setup-description" aria-label="Description" | |
| placeholder="Add description" value={draft.notes ?? ""} rows={4} disabled={busy} | |
| autoFocus={editingDescription} aria-invalid={Boolean(fieldErrors.notes)} | |
| onChange={event => set("notes", event.target.value)} | |
| onBlur={() => setEditingDescription(false)} /> | |
| : <button type="button" className="lp-proj-setup-edit" data-empty disabled={busy} | |
| onClick={() => setEditingDescription(true)}>Add description</button> | |
| : <p className="lp-proj-notes-text">{project.notes || <span className="lp-proj-muted">Not set</span>}</p>} | |
| </SetupRow> | |
| </div> | |
| <ProjectTasks projectId={id} canEdit={canEdit} active={active} disabled={busy} | |
| people={people} peopleLoading={peopleLoading} peopleError={peopleError} | |
| onRetryPeople={() => setPeopleAttempt(value => value + 1)} onTasksLoaded={tasksLoaded} | |
| onProjectChanged={taskProjectChanged} onChanged={taskChanged} | |
| onForbidden={() => setDetail(current => current ? { ...current, canEdit: false } : current)} /> | |
| {error && !deleteOpen ? <p className="lp-proj-error" role="alert">{error}</p> : null} | |
| {detail.cause ? <p className="lp-proj-muted" role="status">{detail.cause}</p> : null} | |
| <SetupRow field="targets" label="SKUs" error={fieldErrors.targets} readOnly={!canEdit}> | |
| <section className="lp-proj-section" aria-label="SKUs"> | |
| <div className="lp-proj-section-head"> | |
| <span className="lp-proj-muted">{!targets.length ? "None linked" : scopedCount !== null | |
| ? `${number(scopedCount)} of ${number(targets.length)} linked` : `${number(targets.length)} linked`}</span> | |
| {canEdit && !adding | |
| ? <button type="button" className="lp-proj-setup-edit" data-empty disabled={busy} onClick={() => setAdding(true)}>Add SKUs</button> | |
| : null} | |
| </div> | |
| {canEdit && active && adding | |
| ? <ProjectSkuPicker projectId={id} existing={targets} canEdit={canEdit && !busy} onClose={() => setAdding(false)} pdp={pdp} | |
| onAdded={answer => { | |
| setDetail(current => current ? { ...current, project: answer.project, targets: answer.targets, | |
| cause: answer.cause } : current); | |
| setFieldErrors(current => ({ ...current, targets: undefined })); | |
| setTick(value => value + 1); | |
| onChanged(); | |
| }} /> | |
| : null} | |
| {targets.length | |
| ? <ProjectSkuList targets={targets} scope={scope} canEdit={canEdit} busy={busy} active={active} | |
| onRemove={removeTargets} pdp={pdp} /> | |
| : null} | |
| </section> | |
| </SetupRow> | |
| <div className="lp-proj-setup-footer" aria-label="Project timestamps"> | |
| {([ ["createdAt", "Created"], ["updatedAt", "Updated"] ] as const).map(([field, label]) => | |
| <SetupRow key={field} field={field} label={label} readOnly> | |
| {project[field] ? <time dateTime={project[field]} title={project[field]}> | |
| {new Date(project[field]).toLocaleDateString("en-US", { month: "short", day: "numeric", year: "numeric" })} | |
| </time> : <span>Not available</span>} | |
| </SetupRow>)} | |
| </div> | |
| {saved && !dirty ? <span className="lp-proj-muted" role="status">Changes saved</span> : null} | |
| </div> | |
| <aside className="lp-proj-side"> | |
| <ProjectFooter>{active ? <div className="lp-proj-save"> | |
| <button type="button" className="lp-proj-btn lp-proj-btn-quiet" disabled={busy} onClick={onCancel}>Cancel</button> | |
| {canEdit ? <button type="submit" form={formId} className="lp-proj-btn lp-proj-btn-primary" disabled={busy || !dirty}> | |
| {busy ? "Saving…" : "Save changes"} | |
| </button> : null} | |
| {canEdit && dirty ? <button type="button" className="lp-proj-btn lp-proj-btn-quiet" disabled={busy} | |
| onClick={() => { setDraft(overviewDraftOf(project)); setError(""); setFieldErrors({}); setSaved(false); }}>Discard changes</button> : null} | |
| </div> : null}</ProjectFooter> | |
| {canEdit | |
| ? <div className="lp-proj-delete"> | |
| <button type="button" className="lp-proj-btn lp-proj-delete-button" disabled={busy} | |
| aria-haspopup="dialog" aria-expanded={deleteOpen} | |
| onClick={() => { setError(""); setConfirming(true); }}>Delete project</button> | |
| </div> | |
| : null} | |
| </aside> | |
| {deleteOpen ? <ProjectDeleteDialog key={project.name} name={project.name} busy={busy} error={error} | |
| onCancel={() => setConfirming(false)} | |
| onConfirm={() => void write(`/${enc(id)}`, "DELETE", undefined, onDeleted)} /> : null} | |
| </form>; | |
| } | |
| type LinkedView = { signature: string; linked: Set<string>; keys: string[]; values: Map<string, Row> }; | |
| type ListRow = { key: string; target: Target; values: Row | null }; | |
| type ReadFailure = { message: string; forbidden: boolean }; | |
| /** Identities the project detail already carries, so grouping by them needs no row read. */ | |
| const TARGET_VALUES = new Map<string, (target: Target) => string>([ | |
| ["sku", target => text(target.sku)], ["asin", target => text(target.asin)], | |
| ["parent_asin", target => text(target.parentAsin)], ["title", target => text(target.title)], | |
| ]); | |
| const LIST_COLUMNS: Record<ProjectGrain, Array<{ key: string; label: string; value: (target: Target) => string }>> = { | |
| sku: [{ key: "sku", label: "SKU", value: target => target.key }, | |
| { key: "asin", label: "Child ASIN", value: target => text(target.asin) }, | |
| { key: "parent_asin", label: "Parent ASIN", value: target => text(target.parentAsin) }], | |
| asin: [{ key: "asin", label: "Child ASIN", value: target => target.key }, | |
| { key: "parent_asin", label: "Parent ASIN", value: target => text(target.parentAsin) }], | |
| parent_asin: [{ key: "parent_asin", label: "Parent ASIN", value: target => target.key }], | |
| }; | |
| /** The text a list search matches: key, title, SKU, Child ASIN and Parent ASIN, lower case. */ | |
| const searchTextOf = (row: ListRow) => [row.key, row.target.title, row.target.sku, row.target.asin, row.target.parentAsin, | |
| row.values?.title, row.values?.sku, row.values?.asin, row.values?.parent_asin] | |
| .map(value => text(value)).join("\n").toLocaleLowerCase(); | |
| const failureOf = (reason: unknown, fallback: string): ReadFailure => ({ message: messageOf(reason, fallback), | |
| forbidden: reason instanceof ProjectRequestError && [401, 403].includes(reason.status) }); | |
| /** Page the server's filtered, ordered rows until every linked key is placed or the rows end. */ | |
| async function readLinked(table: string, grain: ProjectGrain, tree: FilterTree, order: Sorts, linked: Set<string>, | |
| abort: AbortSignal): Promise<Pick<LinkedView, "keys" | "values">> { | |
| const keys: string[] = []; | |
| const values = new Map<string, Row>(); | |
| const visited = new Set<string | number>(); | |
| let cursor: string | number | null = null; | |
| while (true) { | |
| const page = await readPage(table, tree, order, cursor, abort); | |
| for (const row of normalizeProducts(page.rows, grain)) { | |
| const key = text(row[grain]); | |
| if (linked.has(key) && !values.has(key)) { keys.push(key); values.set(key, row); } | |
| } | |
| if (page.next_cursor === null || keys.length === linked.size) return { keys, values }; | |
| if (page.next_cursor === cursor || visited.has(page.next_cursor)) { | |
| throw new Error("The next product page did not advance. Try again."); | |
| } | |
| if (cursor !== null) visited.add(cursor); | |
| cursor = page.next_cursor; | |
| } | |
| } | |
| function ProjectSkuList({ targets: linked, scope, canEdit, busy, active, onRemove, pdp }: { | |
| targets: Target[]; scope: (RowScope & { clear: () => void }) | null; canEdit: boolean; busy: boolean; active: boolean; | |
| onRemove: (pairs: TargetPair[]) => Promise<RemoveOutcome | null>; | |
| pdp?: ProjectPdp; | |
| }) { | |
| const id = useId(); | |
| const [chosen, setChosen] = useState<ProjectGrain>("sku"); | |
| // A row scope lists only the targets that match it. Clearing it lists every linked target again. | |
| const targets = scope ? linked.filter(target => inRowScope(target, scope)) : linked; | |
| const grains = GRAINS.filter(value => targets.some(target => target.grain === value)); | |
| const grain = grains.includes(chosen) ? chosen : grains[0] ?? "sku"; | |
| const tabbed = grains.length > 1; | |
| if (scope && !targets.length) return <div className="lp-proj-skus"> | |
| <div className="lp-proj-skus-state" role="status"><span>No linked products match this filter</span> | |
| <button type="button" className="lp-proj-btn" onClick={scope.clear}>Clear filter</button></div> | |
| </div>; | |
| return <div className="lp-proj-skus"> | |
| {tabbed ? <div className="lp-proj-sku-tabs" role="tablist" aria-label="Product type"> | |
| {grains.map((value, index) => <button type="button" key={value} role="tab" id={`${id}-tab-${value}`} | |
| aria-controls={`${id}-panel`} aria-selected={grain === value} tabIndex={grain === value ? 0 : -1} | |
| disabled={busy} onClick={() => setChosen(value)} onKeyDown={event => { | |
| const next = event.key === "ArrowRight" ? (index + 1) % grains.length | |
| : event.key === "ArrowLeft" ? (index + grains.length - 1) % grains.length | |
| : event.key === "Home" ? 0 : event.key === "End" ? grains.length - 1 : null; | |
| if (next === null) return; | |
| event.preventDefault(); event.stopPropagation(); | |
| setChosen(grains[next]); | |
| document.getElementById(`${id}-tab-${grains[next]}`)?.focus(); | |
| }}>{GRAIN_LABEL[value]}{" "}<span className="lp-proj-skus-tab-count"> | |
| {number(targets.filter(target => target.grain === value).length)}</span></button>)} | |
| </div> : null} | |
| <SkuGrainList key={grain} grain={grain} panelId={`${id}-panel`} tabId={tabbed ? `${id}-tab-${grain}` : null} | |
| targets={targets.filter(target => target.grain === grain)} canEdit={canEdit} busy={busy} active={active} | |
| onRemove={onRemove} pdp={pdp} /> | |
| </div>; | |
| } | |
| function SkuGrainList({ grain, panelId, tabId, targets, canEdit, busy, active, onRemove, pdp }: { | |
| grain: ProjectGrain; panelId: string; tabId: string | null; targets: Target[]; canEdit: boolean; | |
| busy: boolean; active: boolean; onRemove: (pairs: TargetPair[]) => Promise<RemoveOutcome | null>; | |
| pdp?: ProjectPdp; | |
| }) { | |
| const table = TABLES[grain]; | |
| const label = GRAIN_LABEL[grain]; | |
| const plural = `${label}s`; | |
| const [fields, setFields] = useState<Field[] | null>(null); | |
| const [fieldsFailure, setFieldsFailure] = useState<ReadFailure | null>(null); | |
| const [fieldsAttempt, setFieldsAttempt] = useState(0); | |
| const [filters, setFilters] = useState<FilterTree>(EMPTY_FILTER); | |
| const [sorts, setSorts] = useState<Sorts>([]); | |
| const [group, setGroup] = useState<string | null>(null); | |
| const [view, setView] = useState<LinkedView | null>(null); | |
| const [failure, setFailure] = useState<ReadFailure & { signature: string } | null>(null); | |
| const [attempt, setAttempt] = useState(0); | |
| const [selected, setSelected] = useState<Set<string>>(new Set()); | |
| const [refused, setRefused] = useState<RemoveRefusal[]>([]); | |
| const [removeError, setRemoveError] = useState(""); | |
| const [search, setSearch] = useState(""); | |
| const submitting = useRef(false); | |
| const byKey = useMemo(() => new Map(targets.map(target => [target.key, target])), [targets]); | |
| const linkedSignature = JSON.stringify(targets.map(target => target.key)); | |
| const tree = useMemo<FilterTree>(() => ({ ...filters, nodes: scopedNodes(filters.nodes, group) }), [filters, group]); | |
| const order = useMemo<Sorts>(() => group | |
| ? [{ colId: group, dir: "asc" }, ...sorts.filter(sort => sort.colId !== group)] : sorts, [group, sorts]); | |
| const filtered = filters.nodes.length > 0; | |
| const serverOrder = filtered || sorts.length > 0 || (group !== null && !TARGET_VALUES.has(group)); | |
| const signature = JSON.stringify([table, tree, order, attempt]); | |
| const readFor = view?.linked; | |
| // A removal keeps the read valid. Any newly linked key needs a fresh read to find its place. | |
| const stale = serverOrder && (view === null || view.signature !== signature | |
| || targets.some(target => !readFor?.has(target.key))); | |
| const failed = stale && failure?.signature === signature ? failure : null; | |
| const loading = stale && !failed; | |
| useEffect(() => { | |
| if (!active || fields !== null) return; | |
| const controller = new AbortController(); | |
| void readPage(table, EMPTY_FILTER, [], null, controller.signal, 1) | |
| .then(page => { if (!controller.signal.aborted) { setFields(page.fields); setFieldsFailure(null); } }) | |
| .catch(reason => { if (!controller.signal.aborted) setFieldsFailure(failureOf(reason, "Product fields did not load.")); }); | |
| return () => controller.abort(); | |
| }, [active, table, fields, fieldsAttempt]); | |
| useEffect(() => { | |
| if (!stale || !active) return; | |
| const controller = new AbortController(); | |
| const linked = new Set<string>(JSON.parse(linkedSignature) as string[]); | |
| void readLinked(table, grain, tree, order, linked, controller.signal) | |
| .then(answer => { if (!controller.signal.aborted) { setView({ ...answer, linked, signature }); setFailure(null); } }) | |
| .catch(reason => { | |
| if (!controller.signal.aborted) setFailure({ ...failureOf(reason, `${plural} did not load.`), signature }); | |
| }); | |
| return () => controller.abort(); | |
| }, [stale, active, signature, table, grain, tree, order, linkedSignature, plural]); | |
| let rows: ListRow[] = targets.map(target => ({ key: target.key, target, values: null })); | |
| if (serverOrder) { | |
| const placed = view && view.signature === signature ? view.keys.flatMap(key => { | |
| const target = byKey.get(key); | |
| return target ? [{ key, target, values: view.values.get(key) ?? null }] : []; | |
| }) : []; | |
| const found = new Set(placed.map(row => row.key)); | |
| // Without a filter every linked target stays listed, even one the product table no longer holds. | |
| rows = filtered ? placed : [...placed, ...rows.filter(row => !found.has(row.key))]; | |
| } | |
| if (loading || failed) rows = []; | |
| // The search narrows the rows already listed. It sends no request and keeps every row it matches. | |
| const term = search.trim().toLocaleLowerCase(); | |
| if (term) rows = rows.filter(row => searchTextOf(row).includes(term)); | |
| const groupValue = (row: ListRow) => group === null ? "" | |
| : row.values ? text(row.values[group]) : TARGET_VALUES.get(group)?.(row.target) ?? ""; | |
| const buckets = new Map<string, ListRow[]>(); | |
| for (const row of rows) { | |
| const value = groupValue(row); | |
| const bucket = buckets.get(value); | |
| if (bucket) bucket.push(row); else buckets.set(value, [row]); | |
| } | |
| const groups = Array.from(buckets); | |
| // The server orders grouped rows. A detail-only grouping orders its buckets here, blanks last. | |
| if (group !== null && !serverOrder) groups.sort(([a], [b]) => a === b ? 0 : !a ? 1 : !b ? -1 : a.localeCompare(b)); | |
| const visibleKeys = rows.map(row => row.key); | |
| const chosenKeys = visibleKeys.filter(key => selected.has(key)); | |
| const shownSignature = JSON.stringify(visibleKeys); | |
| const blocked = loading || Boolean(failed); | |
| // A row the search hides loses its selection, so Remove never acts on a row the user cannot see. | |
| useEffect(() => { | |
| if (!term || blocked) return; | |
| const shown = new Set<string>(JSON.parse(shownSignature) as string[]); | |
| setSelected(current => Array.from(current).every(key => shown.has(key)) ? current | |
| : new Set(Array.from(current).filter(key => shown.has(key)))); | |
| }, [term, blocked, shownSignature]); | |
| const columns = LIST_COLUMNS[grain]; | |
| const span = (canEdit ? 1 : 0) + 1 + columns.length + (pdp ? 2 : 0); | |
| const resetView = () => { setSelected(new Set()); setRefused([]); setRemoveError(""); }; | |
| const clearView = () => { resetView(); setFilters(EMPTY_FILTER); setSorts([]); setGroup(null); setSearch(""); }; | |
| const viewSet = filtered || sorts.length > 0 || group !== null || selected.size > 0 || search !== ""; | |
| const toggle = (keys: string[], checked: boolean) => setSelected(current => { | |
| const next = new Set(current); | |
| for (const key of keys) { if (checked) next.add(key); else next.delete(key); } | |
| return next; | |
| }); | |
| const boxFor = (keys: string[], name: string) => { | |
| const count = keys.filter(key => selected.has(key)).length; | |
| return <SelectBox checked={keys.length > 0 && count === keys.length} mixed={count > 0 && count < keys.length} | |
| disabled={busy || !keys.length} label={name} onChange={checked => toggle(keys, checked)} />; | |
| }; | |
| const remove = async () => { | |
| if (!canEdit || busy || loading || submitting.current || !chosenKeys.length) return; | |
| submitting.current = true; | |
| setRefused([]); setRemoveError(""); | |
| try { | |
| const outcome = await onRemove(chosenKeys.map(key => ({ grain, key }))); | |
| if (!outcome) return; | |
| if ("error" in outcome) { setRemoveError(outcome.error); return; } | |
| setRefused(outcome.refused); | |
| setSelected(new Set(outcome.refused.flatMap(item => item.key ? [item.key] : []))); | |
| } finally { submitting.current = false; } | |
| }; | |
| return <div className="lp-proj-skus-body"> | |
| <div className="lp-proj-skus-controls"> | |
| <ProductToolbar table={table} grain={grain} fields={fields ?? []} filters={filters} sorts={sorts} group={group} | |
| disabled={busy || !fields?.length} label={`${label} list controls`} | |
| onFilters={next => { resetView(); setFilters(next); }} onSorts={next => { resetView(); setSorts(next); }} | |
| onGroup={next => { resetView(); setGroup(next); }} /> | |
| {fieldsFailure ? <span className="lp-proj-skus-note" role="status"> | |
| {fieldsFailure.forbidden ? "No access to product fields" : fieldsFailure.message} | |
| {!fieldsFailure.forbidden ? <button type="button" className="lp-proj-btn lp-proj-btn-quiet" | |
| onClick={() => { setFieldsFailure(null); setFieldsAttempt(value => value + 1); }}>Retry</button> : null} | |
| </span> : null} | |
| <button type="button" className="lp-proj-skus-reset" disabled={busy || !viewSet} onClick={clearView}> | |
| <ArrowCounterClockwise size={16} aria-hidden="true" />Reset</button> | |
| </div> | |
| <label className="lp-proj-skus-search"> | |
| <MagnifyingGlass size={16} aria-hidden="true" /> | |
| <input type="search" value={search} disabled={busy} aria-label={`Search ${plural}`} placeholder={`Search ${plural}`} | |
| autoComplete="off" spellCheck={false} onChange={event => setSearch(event.target.value)} | |
| onKeyDown={event => { if (event.key === "Enter") event.preventDefault(); }} /> | |
| </label> | |
| <div className="lp-proj-skus-results" id={panelId} role={tabId ? "tabpanel" : "region"} | |
| aria-labelledby={tabId ?? undefined} aria-label={tabId ? undefined : `Linked ${plural}`} | |
| aria-busy={loading || busy} tabIndex={0}> | |
| {loading ? <p className="lp-proj-skus-state" role="status">Loading {plural}…</p> | |
| : failed ? <div className="lp-proj-skus-state" role="alert"> | |
| <span>{failed.forbidden ? "You do not have access to these products" : failed.message}</span> | |
| <div>{!failed.forbidden ? <button type="button" className="lp-proj-btn" | |
| onClick={() => setAttempt(value => value + 1)}>Retry</button> : null} | |
| <button type="button" className="lp-proj-btn lp-proj-btn-quiet" onClick={clearView}>Clear filters</button></div> | |
| </div> | |
| : !rows.length ? <div className="lp-proj-skus-state" role="status"><span>No {plural} match</span> | |
| <button type="button" className="lp-proj-btn" onClick={clearView}>Clear filters</button></div> | |
| : <table className="lp-proj-sku-table lp-proj-skus-table" aria-label={`Linked ${plural}`}> | |
| <thead><tr> | |
| {canEdit ? <th scope="col" className="lp-proj-skus-check">{boxFor(visibleKeys, `Select all shown ${plural}`)}</th> : null} | |
| <th scope="col">Product</th> | |
| {columns.map(column => <th scope="col" key={column.key}>{column.label}</th>)} | |
| {pdp ? <><th scope="col">Step</th><th scope="col"><span className="lp-proj-sku-sr">Workflow</span></th></> : null} | |
| </tr></thead> | |
| <tbody>{groups.map(([value, members]) => <Fragment key={value}> | |
| {group !== null ? <tr className="lp-proj-sku-group"><th scope="rowgroup" colSpan={span}> | |
| <div className="lp-proj-skus-group-head"> | |
| {canEdit ? boxFor(members.map(row => row.key), `Select all in ${value || "No value"}`) : null} | |
| {value || "No value"} | |
| <span>{number(members.length)} {members.length === 1 ? label : plural}</span> | |
| </div> | |
| </th></tr> : null} | |
| {members.map(row => { | |
| const picture = pictureSrc(text(row.target.picture) || text(row.values?.picture)); | |
| return <tr key={row.key} data-selected={(canEdit && selected.has(row.key)) || undefined}> | |
| {canEdit ? <td className="lp-proj-skus-check">{boxFor([row.key], `Select ${label} ${row.key}`)}</td> : null} | |
| <td><div className="lp-proj-sku-product"> | |
| {picture ? <img src={picture} alt="" loading="lazy" /> : <span className="lp-proj-sku-picture" aria-hidden="true" />} | |
| <span><span>{text(row.target.title) || text(row.values?.title) || row.key}</span></span> | |
| </div></td> | |
| {columns.map(column => { | |
| const shown = column.value(row.target) || text(row.values?.[column.key]); | |
| return <td key={column.key} className="lp-proj-sku-code" title={shown || undefined}> | |
| {shown || <span className="lp-proj-muted">Not set</span>}</td>; | |
| })} | |
| {pdp ? <PdpSkuCells pdp={pdp} target={row.target} /> : null} | |
| </tr>; | |
| })} | |
| </Fragment>)}</tbody> | |
| </table>} | |
| </div> | |
| {refused.length ? <div className="lp-proj-skus-refusals" role="alert"> | |
| <p>Some {plural} were not removed</p> | |
| <ul>{refused.map((item, index) => <li key={`${item.key}:${index}`}> | |
| <strong>{item.key || "Unknown product"}</strong>: {item.reason} | |
| </li>)}</ul> | |
| </div> : null} | |
| {removeError ? <p className="lp-proj-error" role="alert">{removeError}</p> : null} | |
| <footer className="lp-proj-skus-footer"> | |
| <span aria-live="polite">{canEdit | |
| ? `${number(chosenKeys.length)} of ${number(rows.length)} selected` : `${number(rows.length)} shown`}</span> | |
| {canEdit ? <div> | |
| {chosenKeys.length ? <button type="button" className="lp-proj-btn lp-proj-btn-quiet" disabled={busy} | |
| onClick={() => setSelected(new Set())}>Clear selection</button> : null} | |
| <button type="button" className="lp-proj-btn lp-proj-btn-danger" disabled={busy || loading || !chosenKeys.length} | |
| onClick={() => void remove()}>{chosenKeys.length ? `Remove ${number(chosenKeys.length)}` : "Remove"}</button> | |
| </div> : null} | |
| </footer> | |
| </div>; | |
| } | |
| function PdpSkuCells({ pdp, target }: { pdp: ProjectPdp; target: Target }) { | |
| const asin = target.grain === "asin" ? target.key : target.asin; | |
| const item = pdp.detail?.workflow.items.find(item => item.asin === asin); | |
| return <><td>{item ? <PdpStep item={item} /> : <span className="lp-proj-muted">Unavailable</span>}</td> | |
| <td><button type="button" className="lp-proj-btn lp-proj-btn-quiet" disabled={!item || !pdp.open} | |
| onClick={() => { if (item) pdp.open?.(item); }}>Open</button></td></>; | |
| } | |
| export function ProjectForm({ targets, onCreated, onCancel, onForbidden }: { | |
| targets: Array<{ grain: ProjectGrain; key: string }>; onCreated: (project: Project) => void; | |
| onCancel: () => void; onForbidden: () => void; | |
| }) { | |
| const [draft, setDraft] = useState<ProjectDraft>({ | |
| name: "", status: "Planned", priority: "Medium", owner: "", ownerUsername: null, | |
| startOn: "", targetOn: "", completedOn: null, progress: 0, notes: "", | |
| }); | |
| const formId = useId(); | |
| const [busy, setBusy] = useState(false); | |
| const [error, setError] = useState(""); | |
| const submitting = useRef(false); | |
| const set = <K extends keyof typeof draft>(key: K, value: (typeof draft)[K]) => setDraft((prev) => ({ ...prev, [key]: value })); | |
| const submit = async (event: FormEvent) => { | |
| event.preventDefault(); | |
| if (submitting.current) return; | |
| const name = draft.name.trim(); | |
| if (!name) { setError("Name the project."); return; } | |
| if (!Number.isInteger(draft.progress) || draft.progress < 0 || draft.progress > 100) { | |
| setError("Enter a whole percent from 0 to 100."); return; | |
| } | |
| submitting.current = true; | |
| setBusy(true); | |
| try { | |
| const body: ProjectInput = { | |
| name, status: draft.status, priority: draft.priority, ownerUsername: draft.ownerUsername, | |
| startOn: draft.startOn || null, targetOn: draft.targetOn || null, progress: draft.progress, | |
| notes: draft.notes?.trim() || null, targets, | |
| }; | |
| const answer = await call<{ project: Project }>("", { method: "POST", body }, "The project was not created."); | |
| onCreated(answer.project); | |
| } catch (reason) { | |
| setError(messageOf(reason, "The project was not created.")); | |
| setBusy(false); | |
| submitting.current = false; | |
| if (reason instanceof ProjectRequestError && reason.status === 403) onForbidden(); | |
| } | |
| }; | |
| return <form id={formId} className="lp-proj-form" onSubmit={(event) => void submit(event)} aria-label="New project"> | |
| <label className="lp-proj-field lp-proj-field-wide"><span>Project name</span> | |
| <input className="lp-proj-input" value={draft.name} onChange={(event) => set("name", event.target.value)} | |
| placeholder="Name your project" autoFocus required maxLength={300} disabled={busy} /></label> | |
| <div className="lp-proj-field"><span>Status</span> | |
| <StatusPicker value={draft.status} disabled={busy} onChange={value => set("status", value)} /></div> | |
| <label className="lp-proj-field"><span>Owner</span> | |
| <OwnerSelect value={draft.ownerUsername} disabled={busy} onChange={value => set("ownerUsername", value)} /></label> | |
| <label className="lp-proj-field"><span>Priority</span> | |
| <select className="lp-proj-input" value={draft.priority} disabled={busy} onChange={(event) => set("priority", event.target.value as Priority)}> | |
| {PROJECT_PRIORITIES.map((value) => <option key={value} value={value}>{value}</option>)} | |
| </select></label> | |
| <label className="lp-proj-field"><span>Start date</span> | |
| <input type="date" className="lp-proj-input" value={draft.startOn ?? ""} disabled={busy} onChange={(event) => set("startOn", event.target.value)} /></label> | |
| <label className="lp-proj-field"><span>Target date</span> | |
| <input type="date" className="lp-proj-input" value={draft.targetOn ?? ""} disabled={busy} onChange={(event) => set("targetOn", event.target.value)} /></label> | |
| <label className="lp-proj-field lp-proj-field-wide"><span>Description</span> | |
| <textarea className="lp-proj-input" rows={3} placeholder="Describe the work" value={draft.notes ?? ""} disabled={busy} onChange={(event) => set("notes", event.target.value)} /></label> | |
| {error ? <p className="lp-proj-error lp-proj-field-wide" role="alert">{error}</p> : null} | |
| <ProjectFooter><div className="lp-proj-form-actions lp-proj-field-wide"> | |
| <button type="button" className="lp-proj-btn lp-proj-btn-quiet" disabled={busy} onClick={onCancel}>Cancel</button> | |
| <button type="submit" form={formId} className="lp-proj-btn lp-proj-btn-primary" disabled={busy}>{busy ? "Creating…" : "Create project"}</button> | |
| </div></ProjectFooter> | |
| </form>; | |
| } | |