feat(hub): scoped right-click context menu from the palette commands
Every palette item carries a scope (general, a tab, or an element kind); right-click and the Menu key or Shift+F10 open one menu with the element's items, then the tab's, then the general ones. Shift+right-click and text fields keep the browser menu; the diff feedback becomes one provider; any other key closes the menu instead of reaching the global shortcuts. 🎯 Fix: 85 % 💥 Break: 6 % 💸 Tokens: 100 % ⏱️ Velocity: 100 % 🛡️ Security: 100 % 🏆 Score: 80 🚦 Gate: ⛔ fix 85 % < 90, break 6 % > 5 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
d8b1c95402
commit
ded7c9a7b6
12 files changed
+685
-39
No files matched your search
@@ -0,0 +1,250 @@
|
||||
const ctxMenu = {node: null, back: null};
|
||||
const CTX_FIELDS = ["INPUT", "TEXTAREA", "SELECT"];
|
||||
const CTX_GAP = 8;
|
||||
const CTX_MODIFIERS = ["Shift", "Control", "Alt", "Meta"];
|
||||
const CTX_OPENS = {task: "Open task", message: "Open message", artifact: "Open artifact"};
|
||||
const ctxAttr = (...names) => (node) => names.map((name) => node.getAttribute(name)).find(Boolean) || null;
|
||||
const ctxField = (node) => Boolean(node.isContentEditable) || CTX_FIELDS.includes(node.tagName);
|
||||
const ctxInside = (node) => Boolean(ctxMenu.node) && ctxMenu.node.contains(node);
|
||||
const ctxCopyItem = (label, text) => ({label, hint: text, run: () => ctxCopy(text)});
|
||||
|
||||
function ctxAgentOf(node) {
|
||||
const raw = ctxAttr("data-agent", "data-face", "data-name", "data-session")(node);
|
||||
return raw && raw !== HUMAN ? agentKey(raw) : null;
|
||||
}
|
||||
|
||||
function ctxPinOf(node) {
|
||||
return node.matches(Panels.HOSTS) ? Panels.targetOf(node) : null;
|
||||
}
|
||||
|
||||
const ctxPinEntry = (target) => (target.id && !target.refused ? Panels.lookup(target.kind, target.id, target.view) : null);
|
||||
const ctxEntryOf = (ref) => state.inbox.find((entry) => keyOf(entry) === ref) || null;
|
||||
const ctxArtifactOf = (id) => (tree.model ? tree.model.byId.get(id) || null : null);
|
||||
|
||||
function ctxTaskItems(node, id) {
|
||||
const known = state.tasks.some((row) => row.task === id);
|
||||
return [...(known ? [{label: "Open task", hint: id, run: () => taskSheet(id)}] : []), ctxCopyItem("Copy task id", id)];
|
||||
}
|
||||
|
||||
function ctxAgentItems(node, key) {
|
||||
return [ctxCopyItem("Copy name", nameOf(key))];
|
||||
}
|
||||
|
||||
function ctxBranchItems(node, name) {
|
||||
const ref = `branch:${node.getAttribute("data-repo")}\u0000${name}`;
|
||||
const open = ctxArtifactOf(ref) ? [{label: "Open branch", hint: name, run: () => artSelect(ref)}] : [];
|
||||
return [...open, ctxCopyItem("Copy branch name", name), {label: "Explain", hint: "what each mark of a branch means", run: () => openSheet("Explain", glossarySections(), false)}];
|
||||
}
|
||||
|
||||
function ctxPathItems(node, path) {
|
||||
return [...feedbackItems(), ...(path === "-" ? [] : [ctxCopyItem("Copy path", path)])];
|
||||
}
|
||||
|
||||
function ctxEntryItems(node, ref) {
|
||||
const item = ctxEntryOf(ref);
|
||||
return item ? [{label: "Open entry", hint: item.title, run: () => openItem(item)}, ctxCopyItem("Copy id", item.id)] : [];
|
||||
}
|
||||
|
||||
function ctxPickItems(node, id) {
|
||||
const found = ctxArtifactOf(id);
|
||||
if (found) {
|
||||
return [{label: "Open artifact", hint: found.label, run: () => artSelect(id)}];
|
||||
}
|
||||
const sub = state.graph.nodes.find((entry) => entry.id === id && entry.kind === "subagent");
|
||||
return sub ? [{label: "Open parent agent", hint: labelOf(sub.parent), run: () => select(id)}] : [];
|
||||
}
|
||||
|
||||
function ctxPickTitle(id) {
|
||||
const found = ctxArtifactOf(id) || state.graph.nodes.find((entry) => entry.id === id);
|
||||
return found ? found.label : id;
|
||||
}
|
||||
|
||||
function ctxPinItems(node, target) {
|
||||
const entry = ctxPinEntry(target);
|
||||
if (!entry) {
|
||||
return [];
|
||||
}
|
||||
const opens = Object.hasOwn(CTX_OPENS, target.kind) ? [{label: CTX_OPENS[target.kind], hint: entry.title, run: () => HOME_OPENERS[target.kind](Panels.raw(target.id), target.id)}] : [];
|
||||
const pinned = Panels.has(homePins(), target.kind, target.id);
|
||||
return [...opens, {label: pinned ? "Unpin from Home" : "Pin to Home", hint: entry.title, run: () => homePress(target.kind, target.id, entry.title, target.view)}];
|
||||
}
|
||||
|
||||
const CTX_KINDS = [
|
||||
{kind: "task", id: ctxAttr("data-task"), title: (id) => `Task ${id}`, items: ctxTaskItems},
|
||||
{kind: "agent", id: ctxAgentOf, title: (key) => nameOf(key), items: ctxAgentItems},
|
||||
{kind: "branch", id: ctxAttr("data-branch"), title: (name) => `Branch ${name}`, items: ctxBranchItems},
|
||||
{kind: "path", id: ctxAttr("data-path"), title: (path) => path, items: ctxPathItems},
|
||||
{kind: "entry", id: ctxAttr("data-ref"), title: (ref) => ctxEntryOf(ref).title, items: ctxEntryItems},
|
||||
{kind: "rule", id: ctxAttr("data-rule", "data-entry"), title: (id) => `Rule ${id}`, items: (node, id) => [ctxCopyItem("Copy rule", id)]},
|
||||
{kind: "pick", id: ctxAttr("data-pick"), title: ctxPickTitle, items: ctxPickItems},
|
||||
{kind: "pin", id: ctxPinOf, title: (target) => ctxPinEntry(target).title, items: ctxPinItems},
|
||||
];
|
||||
|
||||
/**
|
||||
* @param target - the element a right-click or the menu key hit.
|
||||
* @returns [{kind, id, node, entry}]: per kind of CTX_KINDS the nearest marked element from target up, nearest first.
|
||||
*/
|
||||
function ctxFound(target) {
|
||||
const found = [];
|
||||
for (let node = target; node; node = node.parentElement) {
|
||||
for (const entry of CTX_KINDS.filter((kind) => !found.some((seen) => seen.kind === kind.kind))) {
|
||||
const id = entry.id(node);
|
||||
if (id) {
|
||||
found.push({kind: entry.kind, id, node, entry});
|
||||
}
|
||||
}
|
||||
}
|
||||
return found;
|
||||
}
|
||||
|
||||
function ctxOwn(found, items) {
|
||||
const groups = found.map((seen) => ({seen, items: items.filter((item) => item.scope === seen.kind && item.id === seen.id)})).filter((group) => group.items.length);
|
||||
const flat = groups.flatMap((group) => group.items);
|
||||
return {title: groups.length ? groups[0].seen.entry.title(groups[0].seen.id) : "", items: flat.filter((item, index) => flat.findIndex((other) => other.label === item.label) === index)};
|
||||
}
|
||||
|
||||
/**
|
||||
* @param target - the element the menu is for.
|
||||
* @returns [{scope, title, items}]: the element's own items, then the current tab's, then the general ones; empty
|
||||
* sections left out.
|
||||
*/
|
||||
function ctxSections(target) {
|
||||
const found = ctxFound(target);
|
||||
const provided = found.flatMap((seen) => seen.entry.items(seen.node, seen.id).map((item) => ({...item, scope: seen.kind, id: seen.id})));
|
||||
const items = [...paletteItems(), ...provided];
|
||||
const own = ctxOwn(found, items);
|
||||
const tab = Nav.TABS.find(([id]) => id === Nav.tabOf(ui.screen));
|
||||
return [
|
||||
{scope: "element", title: own.title, items: own.items},
|
||||
...(tab ? [{scope: tab[0], title: tab[1], items: items.filter((item) => item.scope === tab[0])}] : []),
|
||||
{scope: "general", title: "General", items: items.filter((item) => item.scope === "general")},
|
||||
].filter((section) => section.items.length);
|
||||
}
|
||||
|
||||
async function ctxCopy(text) {
|
||||
try {
|
||||
await navigator.clipboard.writeText(text);
|
||||
toast("Copied", [revealed(text)], true);
|
||||
} catch {
|
||||
toast("Not copied", ["The browser refused the clipboard."], false);
|
||||
}
|
||||
}
|
||||
|
||||
function ctxNode() {
|
||||
if (!ctxMenu.node) {
|
||||
ctxMenu.node = h("div", {class: "ctx-menu", role: "menu", "aria-label": "Context menu", tabindex: -1, hidden: true, on: {keydown: ctxKeys}});
|
||||
document.body.append(ctxMenu.node);
|
||||
}
|
||||
return ctxMenu.node;
|
||||
}
|
||||
|
||||
function ctxItem(item) {
|
||||
return h("button", {type: "button", role: "menuitem", tabindex: -1, class: "ctx-item", title: revealed(item.hint), on: {click: () => ctxRun(item)}},
|
||||
item.face ? face(item.face, false) : null, h("span", {class: "ctx-label"}, revealed(item.label)), h("span", {class: "muted"}, revealed(item.hint)));
|
||||
}
|
||||
|
||||
function ctxGroup(section, index) {
|
||||
return [index ? h("div", {role: "separator", class: "ctx-rule"}) : null,
|
||||
h("div", {role: "group", class: "ctx-group", "aria-label": revealed(section.title), "data-scope": section.scope}, h("div", {class: "ctx-head", "aria-hidden": "true"}, revealed(section.title)), section.items.map(ctxItem))];
|
||||
}
|
||||
|
||||
function ctxPlace(node, at) {
|
||||
node.style.left = "0px";
|
||||
node.style.top = "0px";
|
||||
const box = node.getBoundingClientRect();
|
||||
const below = at.y + box.height + CTX_GAP <= window.innerHeight;
|
||||
node.style.left = `${Math.max(CTX_GAP, Math.min(at.x, window.innerWidth - box.width - CTX_GAP))}px`;
|
||||
node.style.top = `${Math.max(CTX_GAP, Math.min(below ? at.y : at.y - box.height, window.innerHeight - box.height - CTX_GAP))}px`;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param sections - what ctxSections gives.
|
||||
* @param at - {x, y}, the viewport point the menu opens at; it moves inside the viewport when it would run past it.
|
||||
*/
|
||||
function ctxShow(sections, at) {
|
||||
const node = ctxNode();
|
||||
node.replaceChildren(...sections.flatMap(ctxGroup).filter(Boolean));
|
||||
node.hidden = false;
|
||||
ctxPlace(node, at);
|
||||
const first = node.querySelector('[role="menuitem"]');
|
||||
if (first) {
|
||||
first.focus({preventScroll: true});
|
||||
}
|
||||
}
|
||||
|
||||
function ctxOpen(target, at) {
|
||||
closeMenus(null);
|
||||
ctxMenu.back = document.activeElement;
|
||||
ctxShow(ctxSections(target), at);
|
||||
}
|
||||
|
||||
function ctxClose(restore) {
|
||||
if (!ctxMenu.node || ctxMenu.node.hidden) {
|
||||
return;
|
||||
}
|
||||
const back = ctxMenu.back;
|
||||
ctxMenu.back = null;
|
||||
ctxMenu.node.hidden = true;
|
||||
ctxMenu.node.replaceChildren();
|
||||
if (restore && back && back.isConnected && typeof back.focus === "function") {
|
||||
back.focus({preventScroll: true});
|
||||
}
|
||||
}
|
||||
|
||||
function ctxRun(item) {
|
||||
ctxClose(true);
|
||||
item.run();
|
||||
}
|
||||
|
||||
/**
|
||||
* @param keep - the menu a click landed in, as closeMenus gets it; the context menu stays open when it is that menu.
|
||||
*/
|
||||
function ctxDismiss(keep) {
|
||||
if (ctxMenu.node && ctxMenu.node !== keep) {
|
||||
ctxClose(ctxMenu.node.contains(document.activeElement));
|
||||
}
|
||||
}
|
||||
|
||||
function ctxKeys(event) {
|
||||
const items = [...ctxMenu.node.querySelectorAll('[role="menuitem"]')];
|
||||
const at = items.indexOf(document.activeElement);
|
||||
const moves = {ArrowDown: at + 1, ArrowUp: Math.max(at, 0) - 1, Home: 0, End: items.length - 1};
|
||||
if (Object.hasOwn(moves, event.key)) {
|
||||
items[(moves[event.key] + items.length) % items.length].focus();
|
||||
} else if (event.key === "Enter" || event.key === " ") {
|
||||
items[Math.max(at, 0)].click();
|
||||
} else if (CTX_MODIFIERS.includes(event.key)) {
|
||||
return;
|
||||
} else {
|
||||
ctxClose(true);
|
||||
}
|
||||
event.preventDefault();
|
||||
event.stopPropagation();
|
||||
}
|
||||
|
||||
function ctxContextMenu(event) {
|
||||
const target = event.target;
|
||||
if (!(target instanceof Element) || event.defaultPrevented) {
|
||||
return;
|
||||
}
|
||||
if (ctxInside(target)) {
|
||||
event.preventDefault();
|
||||
return;
|
||||
}
|
||||
if (event.shiftKey || ctxField(target)) {
|
||||
return;
|
||||
}
|
||||
event.preventDefault();
|
||||
ctxOpen(target, {x: event.clientX, y: event.clientY});
|
||||
}
|
||||
|
||||
function ctxKeydown(event) {
|
||||
const pressed = event.key === "ContextMenu" || (event.key === "F10" && event.shiftKey);
|
||||
const target = document.activeElement;
|
||||
if (!pressed || event.ctrlKey || event.altKey || event.metaKey || !(target instanceof Element) || ctxField(target) || ctxInside(target)) {
|
||||
return;
|
||||
}
|
||||
event.preventDefault();
|
||||
const box = target.getBoundingClientRect();
|
||||
ctxOpen(target, {x: box.left, y: box.bottom});
|
||||
}
|
||||
Reference in new issue
Block a user