// priority-modal.jsx — cross-coordinator priority conflict picker
//
// Globally-mounted host () plus a window-level
// helper `window.requestPriorityChange(task, newPriority, opts)` that
// returns a Promise. Any code path that wants to change a
// task's priority should:
//
// const ok = await window.requestPriorityChange(task, "high");
// if (ok) actualPatchToHigh();
//
// The host's behaviour:
//
// * newPriority NOT in {high, critical} or NOT an upgrade
// → resolves true immediately (no prompt).
// * No assignee or self-assigned only → resolves true (no conflict
// possible by definition).
// * Otherwise fetches /api/priority/load for the assignee, computes
// would-be-total = current count + 1, and:
// - under the workspace cap → friendly "Set anyway"
// picker with the current
// high list visible.
// - at/over the workspace cap → red banner + downgrade
// choices + admin-override
// button. The user still
// decides — caps are soft.
//
// The picker NEVER blocks irreversibly — coordinators retain final
// say. Its job is to surface the conflict so the choice is informed.
(function () {
if (typeof window === "undefined") return;
let _resolvers = [];
// Public helper. Returns Promise: true → caller proceeds
// with the patch; false → caller cancels (user picked Cancel or
// closed the modal). Falls back to `true` when the host isn't
// mounted yet (no UX regression for code that ran before app
// finished hydrating).
window.requestPriorityChange = function requestPriorityChange(task, nextPriority, opts) {
opts = opts || {};
// Fast paths — anything not an upgrade to high/critical bypasses
// the picker entirely.
if (!task) return Promise.resolve(true);
if (nextPriority !== "high" && nextPriority !== "critical") {
return Promise.resolve(true);
}
const current = task.prio || task.priority;
// Same value → no-op.
if (current === nextPriority) return Promise.resolve(true);
// Already at critical, downshifting to high — not a conflict.
const RANK = { critical: 0, high: 1, medium: 2, low: 3, none: 4 };
if (RANK[current] != null && RANK[current] < RANK[nextPriority]) {
return Promise.resolve(true);
}
// No assignees → can't conflict with anyone.
if (!Array.isArray(task.owners) || task.owners.length === 0) {
return Promise.resolve(true);
}
// Only the current user assigned → self-conflict, not coordinator
// pressure. Skip the picker.
const me = opts.currentUserId || window.__currentUserId || null;
if (me && task.owners.length === 1 && task.owners[0] === me) {
return Promise.resolve(true);
}
return new Promise(resolve => {
const event = new CustomEvent("priority:request", {
detail: {
task,
nextPriority,
currentUserId: me,
resolve,
},
});
_resolvers.push(resolve);
window.dispatchEvent(event);
// Safety net — if the host doesn't pick it up within 50ms,
// resolve true so we never deadlock a write path. The host
// sets a flag in the event detail when it consumes the event.
setTimeout(() => {
if (event.detail._consumed) return;
try { resolve(true); } catch {}
}, 50);
});
};
// ── Host component ───────────────────────────────────────────
function PriorityConflictHost() {
const [pending, setPending] = React.useState(null);
React.useEffect(() => {
function onRequest(e) {
if (!e || !e.detail) return;
e.detail._consumed = true;
setPending(e.detail);
}
window.addEventListener("priority:request", onRequest);
return () => window.removeEventListener("priority:request", onRequest);
}, []);
if (!pending) return null;
return (
{
try { pending.resolve(!!ok); } catch {}
setPending(null);
}}/>
);
}
function PriorityConflictPicker({ task, nextPriority, currentUserId, onResolve }) {
const targetUserId = (task.owners && task.owners[0]) || null;
const [loading, setLoading] = React.useState(true);
const [data, setData] = React.useState(null);
const [err, setErr] = React.useState("");
React.useEffect(() => {
let cancelled = false;
(async () => {
try {
const r = await window.api.priority.load({
userId: targetUserId,
excludeTaskId: task && task.id,
});
if (!cancelled) setData(r);
} catch (e) {
if (!cancelled) setErr((e && (e.body && e.body.message)) || (e && e.message) || "Could not load priority context");
} finally {
if (!cancelled) setLoading(false);
}
})();
return () => { cancelled = true; };
}, [targetUserId, task && task.id]);
// Auto-resolve when we can't fetch the context — coordinators
// shouldn't be blocked by a degraded backend.
React.useEffect(() => {
if (!loading && err) {
const t = setTimeout(() => onResolve(true), 1500);
return () => clearTimeout(t);
}
}, [loading, err, onResolve]);
const ownerPerson = ((window.PEOPLE || []).find(p => p.id === targetUserId)) || null;
const ownerName = (ownerPerson && ownerPerson.name) || targetUserId;
if (loading) {
return ReactDOM.createPortal(
onResolve(false)}>
e.stopPropagation()}>
Checking {ownerName}'s priority load…
,
document.body
);
}
if (err) {
return ReactDOM.createPortal(
{ownerName} already has {counts.critical} critical
{" · "}{counts.high} high open
{sameLevelCap > 0 && (
<> · cap for {titleLabel}: {sameLevelCap}
)}
{overCap && (
Setting this {titleLabel} would put {ownerName} at {totalAfter} {titleLabel} tasks — over the
workspace cap of {sameLevelCap}.
{youAreAlreadyOver && (
<> You already have {myCountAtLevel} {titleLabel} task{myCountAtLevel === 1 ? "" : "s"} on
their plate from previous assignments.
)}
)}
{items.length > 0 ? (
Currently {sameLevelCount > 0 ? "on their plate" : "open from you"}