593 lines
21 KiB
JavaScript
593 lines
21 KiB
JavaScript
function issueDueState(dueDate, now) {
|
|
if (!dueDate) return null;
|
|
const due = new Date(dueDate);
|
|
if (Number.isNaN(due.getTime())) return null;
|
|
const day = value => value.getFullYear() + '-' + String(value.getMonth() + 1).padStart(2, '0') + '-' +
|
|
String(value.getDate()).padStart(2, '0');
|
|
const dueDay = day(due);
|
|
const today = day(now);
|
|
if (dueDay < today) return { label: 'Overdue', priority: 2 };
|
|
if (dueDay === today) return { label: 'Due today', priority: 2.5 };
|
|
return {
|
|
label: 'Due ' + due.toLocaleDateString(undefined, { month: 'short', day: 'numeric' }),
|
|
priority: 4,
|
|
};
|
|
}
|
|
|
|
function buildMyWork(data, now = new Date()) {
|
|
const login = data.user?.login || '';
|
|
const issues = (data.issues || []).map((item) => ({ ...item, kind: 'issue' }));
|
|
const pulls = (data.pull_requests || []).map((item) => ({ ...item, kind: 'pull' }));
|
|
const priorityLabels = ['p0', 'priority-high', 'critical'];
|
|
|
|
const work = issues.concat(pulls).map((item) => {
|
|
const labels = item.labels || [];
|
|
const priorityLabel = labels.find((label) =>
|
|
priorityLabels.includes(String(label).toLowerCase())
|
|
);
|
|
const assigned = (item.assignees || []).includes(login);
|
|
const isReview = (item.work_reasons || []).includes('review_requested');
|
|
const due = item.kind === 'issue' ? issueDueState(item.due_date, now) : null;
|
|
return {
|
|
...item,
|
|
key: (item.repository || 'unknown') + '#' + item.number,
|
|
is_review: isReview,
|
|
is_assigned: assigned,
|
|
has_update: false,
|
|
...(due ? { due_label: due.label } : {}),
|
|
reason: priorityLabel ? priorityLabel + ' priority' :
|
|
(due && due.priority < 4 ? due.label :
|
|
(isReview ? 'Needs your review' : (assigned ? 'Assigned to you' : 'Open work'))),
|
|
_priority: priorityLabel ? 0 :
|
|
(due && due.priority < 4 ? due.priority : (isReview ? 3 : (assigned ? 4 : 5))),
|
|
};
|
|
});
|
|
|
|
const byKey = new Map(work.map((item) => [item.kind + ':' + item.key, item]));
|
|
(data.notifications || []).filter((item) => item && item.unread).forEach((update) => {
|
|
const key = (update.repository || 'unknown') + '#' + update.number;
|
|
const subjectKind = String(update.subject_type || '').toLowerCase().includes('pull') ? 'pull' : 'issue';
|
|
const existing = byKey.get(subjectKind + ':' + key);
|
|
if (existing) {
|
|
existing.has_update = true;
|
|
existing.notification_id = update.id;
|
|
existing.url = update.url || existing.url;
|
|
existing.updated_at = update.updated_at || existing.updated_at;
|
|
existing._priority = Math.min(existing._priority, 1);
|
|
return;
|
|
}
|
|
if (!update.url) return;
|
|
const item = {
|
|
...update,
|
|
key,
|
|
kind: 'update',
|
|
is_review: false,
|
|
is_assigned: false,
|
|
has_update: true,
|
|
notification_id: update.id,
|
|
reason: 'Unread update',
|
|
_priority: 1,
|
|
};
|
|
work.push(item);
|
|
byKey.set(subjectKind + ':' + key, item);
|
|
});
|
|
|
|
return work.sort((left, right) =>
|
|
left._priority - right._priority ||
|
|
String(right.updated_at || '').localeCompare(String(left.updated_at || '')) ||
|
|
left.key.localeCompare(right.key)
|
|
).map(({ _priority, ...item }) => item);
|
|
}
|
|
|
|
function acknowledgeNotification(items, notificationId) {
|
|
return items.flatMap((item) => {
|
|
if (item.notification_id !== notificationId) return [item];
|
|
if (item.kind === 'update') return [];
|
|
const { notification_id, ...acknowledged } = item;
|
|
return [{ ...acknowledged, has_update: false }];
|
|
});
|
|
}
|
|
|
|
function createNotificationAcknowledger({ markRead, onItems, onStatus }) {
|
|
const pending = new Set();
|
|
return {
|
|
async acknowledge(items, notificationId) {
|
|
if (pending.has(notificationId)) return false;
|
|
pending.add(notificationId);
|
|
onItems(acknowledgeNotification(items, notificationId));
|
|
onStatus('Marking update read…');
|
|
try {
|
|
await markRead(notificationId);
|
|
onStatus('Update marked read.');
|
|
return true;
|
|
} catch (_error) {
|
|
onItems(items);
|
|
onStatus('Could not mark update read. Retry.');
|
|
return false;
|
|
} finally {
|
|
pending.delete(notificationId);
|
|
}
|
|
},
|
|
};
|
|
}
|
|
|
|
function notificationIds(items) {
|
|
return Array.from(new Set((items || [])
|
|
.filter((item) => item && item.has_update && Number.isInteger(item.notification_id))
|
|
.map((item) => item.notification_id)));
|
|
}
|
|
|
|
function createBulkNotificationAcknowledger({ markRead, onItems, onStatus }) {
|
|
let pending = false;
|
|
return {
|
|
async acknowledge(items, requestedIds) {
|
|
if (pending) return false;
|
|
const ids = Array.from(new Set((requestedIds || []).filter(Number.isInteger)));
|
|
if (!ids.length) return false;
|
|
pending = true;
|
|
onStatus('Marking ' + ids.length + ' updates read…');
|
|
try {
|
|
const result = await markRead(ids);
|
|
const marked = (result.marked || []).filter(Number.isInteger);
|
|
const failed = (result.failed || []).filter(Number.isInteger);
|
|
const updated = marked.reduce(
|
|
(current, notificationId) => acknowledgeNotification(current, notificationId),
|
|
items
|
|
);
|
|
onItems(updated);
|
|
onStatus(failed.length ?
|
|
marked.length + ' marked read · ' + failed.length + ' could not be updated — retry.' :
|
|
marked.length + ' updates marked read.');
|
|
return { marked, failed };
|
|
} catch (_error) {
|
|
onStatus('Could not mark updates read. Retry.');
|
|
return false;
|
|
} finally {
|
|
pending = false;
|
|
}
|
|
},
|
|
};
|
|
}
|
|
|
|
function createNotificationPager({ load, onNotifications, onPagination, onStatus }) {
|
|
let pagination = { page: 1, total: 0, has_more: false };
|
|
let pending = false;
|
|
return {
|
|
reset(next) {
|
|
pagination = { ...pagination, ...(next || {}) };
|
|
onPagination(pagination);
|
|
},
|
|
async loadMore(existing) {
|
|
if (pending || !pagination.has_more) return false;
|
|
pending = true;
|
|
onStatus('Loading older updates…');
|
|
try {
|
|
const result = await load(pagination.page + 1);
|
|
const byId = new Map((existing || [])
|
|
.filter(item => item && Number.isInteger(item.id))
|
|
.map(item => [item.id, item]));
|
|
(result.items || []).forEach(item => {
|
|
if (item && Number.isInteger(item.id) && !byId.has(item.id)) byId.set(item.id, item);
|
|
});
|
|
pagination = {
|
|
page: result.page,
|
|
total: result.total,
|
|
has_more: result.has_more === true,
|
|
};
|
|
const loaded = Math.min(pagination.total, pagination.page * 50);
|
|
onNotifications(Array.from(byId.values()));
|
|
onPagination(pagination);
|
|
onStatus(loaded + ' of ' + pagination.total + ' unread updates loaded.');
|
|
return true;
|
|
} catch (_error) {
|
|
onStatus('Could not load older updates. Retry.');
|
|
return false;
|
|
} finally {
|
|
pending = false;
|
|
}
|
|
},
|
|
};
|
|
}
|
|
|
|
function createWorkPager({ load, onItems, onPagination, onStatus }) {
|
|
let pagination = {};
|
|
const pending = new Set();
|
|
const labels = {
|
|
issue: 'issues',
|
|
pull: 'pull requests',
|
|
review: 'review requests',
|
|
};
|
|
return {
|
|
reset(next) {
|
|
Object.entries(next || {}).forEach(([stream, value]) => {
|
|
const current = pagination[stream];
|
|
pagination[stream] = current && current.page > 1 ?
|
|
{ ...value, page: current.page, has_more: current.page * 50 < value.total } :
|
|
{ ...value };
|
|
});
|
|
onPagination({ ...pagination });
|
|
},
|
|
async loadMore(stream, existing) {
|
|
const page = pagination[stream];
|
|
if (pending.has(stream) || !page?.has_more) return false;
|
|
pending.add(stream);
|
|
const label = labels[stream] || 'work';
|
|
onStatus('Loading older ' + label + '…');
|
|
try {
|
|
const result = await load(stream, page.page + 1);
|
|
const merged = new Map((existing || [])
|
|
.filter(item => item && Number.isInteger(item.id))
|
|
.map(item => [item.id, { ...item }]));
|
|
(result.items || []).forEach(item => {
|
|
if (!item || !Number.isInteger(item.id)) return;
|
|
const current = merged.get(item.id);
|
|
if (!current) {
|
|
merged.set(item.id, { ...item });
|
|
return;
|
|
}
|
|
const reasons = Array.from(new Set(
|
|
(current.work_reasons || []).concat(item.work_reasons || [])
|
|
));
|
|
merged.set(item.id, {
|
|
...current, ...item, ...(reasons.length ? { work_reasons: reasons } : {}),
|
|
});
|
|
});
|
|
pagination[stream] = {
|
|
page: result.page, total: result.total, has_more: result.has_more === true,
|
|
};
|
|
onItems(stream, Array.from(merged.values()));
|
|
onPagination({ ...pagination });
|
|
onStatus(Math.min(result.total, result.page * 50) + ' of ' + result.total + ' ' + label + ' loaded.');
|
|
return true;
|
|
} catch (_error) {
|
|
onStatus('Could not load older ' + label + '. Retry.');
|
|
return false;
|
|
} finally {
|
|
pending.delete(stream);
|
|
}
|
|
},
|
|
};
|
|
}
|
|
|
|
function createNotificationReader({
|
|
load, markRead, onOpen, onDetail, onItems, onStatus, onClose,
|
|
loadConversation = null,
|
|
onConversation = () => {},
|
|
createPager = typeof createConversationPager === 'function' ? createConversationPager : null,
|
|
}) {
|
|
let selected = null;
|
|
let loadVersion = 0;
|
|
let marking = false;
|
|
let conversationPager = null;
|
|
|
|
async function open(item) {
|
|
selected = item;
|
|
const version = ++loadVersion;
|
|
onOpen(item);
|
|
onStatus('Loading update…');
|
|
try {
|
|
const detail = await load(item.notification_id);
|
|
if (selected !== item || version !== loadVersion) return false;
|
|
onDetail(detail);
|
|
if (createPager && loadConversation && detail.conversation) {
|
|
conversationPager = createPager({
|
|
loadPage: page => loadConversation(item.notification_id, page),
|
|
});
|
|
onConversation(conversationPager.reset(detail.conversation));
|
|
} else {
|
|
conversationPager = null;
|
|
}
|
|
onStatus('Update ready.');
|
|
return true;
|
|
} catch (_error) {
|
|
if (selected === item && version === loadVersion) {
|
|
onStatus('Could not load update. Retry or open it in Gitea.');
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return {
|
|
open,
|
|
appendReply(comment) {
|
|
if (!conversationPager) return false;
|
|
onConversation(conversationPager.append(comment));
|
|
return true;
|
|
},
|
|
async loadOlder() {
|
|
if (!conversationPager || !selected) return false;
|
|
const pager = conversationPager;
|
|
const version = loadVersion;
|
|
onStatus('Loading older messages…');
|
|
try {
|
|
const state = await pager.loadOlder();
|
|
if (pager !== conversationPager || version !== loadVersion) return false;
|
|
onConversation(state);
|
|
onStatus(state.comments.length + ' of ' + state.total + ' messages loaded.');
|
|
return true;
|
|
} catch (_error) {
|
|
if (pager === conversationPager && version === loadVersion) {
|
|
onStatus('Could not load older messages. Retry.');
|
|
}
|
|
return false;
|
|
}
|
|
},
|
|
async markReadAndNext(items) {
|
|
if (!selected || marking) return false;
|
|
const current = selected;
|
|
marking = true;
|
|
onStatus('Marking update read…');
|
|
try {
|
|
await markRead(current.notification_id);
|
|
const updated = acknowledgeNotification(items, current.notification_id);
|
|
onItems(updated);
|
|
const currentIndex = items.indexOf(current);
|
|
const remaining = items.slice(currentIndex + 1).concat(items.slice(0, currentIndex));
|
|
const next = remaining.find(item =>
|
|
item && item.has_update && Number.isInteger(item.notification_id)
|
|
);
|
|
if (next) await open(next);
|
|
else {
|
|
selected = null;
|
|
onClose();
|
|
onStatus('Inbox cleared.');
|
|
}
|
|
return { items: updated, next: next || null };
|
|
} catch (_error) {
|
|
onStatus('Could not mark update read. Retry.');
|
|
return false;
|
|
} finally {
|
|
marking = false;
|
|
}
|
|
},
|
|
};
|
|
}
|
|
|
|
function createNotificationReplier({
|
|
post, storage, onStatus, authoredOutbox,
|
|
createOperationId = () => globalThis.crypto?.randomUUID?.() || String(Date.now()) + '-' + Math.random(),
|
|
}) {
|
|
let pending = false;
|
|
const keyFor = item => 'stackchain.update-reply.v1.' + item.notification_id;
|
|
const operationKeyFor = item => keyFor(item) + ':operation';
|
|
return {
|
|
loadDraft(item) {
|
|
try { return storage.getItem(keyFor(item)) || ''; }
|
|
catch (_error) { return ''; }
|
|
},
|
|
saveDraft(item, body) {
|
|
try {
|
|
if ((storage.getItem(keyFor(item)) || '') !== body) storage.removeItem(operationKeyFor(item));
|
|
storage.setItem(keyFor(item), body);
|
|
}
|
|
catch (_error) { /* Keep the editable textarea as the fallback. */ }
|
|
},
|
|
async submit(item, body) {
|
|
if (pending) return false;
|
|
pending = true;
|
|
this.saveDraft(item, body);
|
|
let operationId;
|
|
try {
|
|
operationId = storage.getItem(operationKeyFor(item)) || String(createOperationId()).slice(0, 128);
|
|
storage.setItem(operationKeyFor(item), operationId);
|
|
} catch (_error) { operationId = String(createOperationId()).slice(0, 128); }
|
|
onStatus('Sending reply…');
|
|
try {
|
|
const result = await post(item.notification_id, body, operationId);
|
|
try { storage.removeItem(keyFor(item)); }
|
|
catch (_error) { /* The posted reply is still authoritative. */ }
|
|
try { storage.removeItem(operationKeyFor(item)); }
|
|
catch (_error) { /* A confirmed result no longer needs replay identity. */ }
|
|
onStatus('Reply posted. You can mark this update read when ready.');
|
|
return result;
|
|
} catch (error) {
|
|
const status = Number(error?.status || 0);
|
|
if (authoredOutbox && (!status || status >= 500)) {
|
|
authoredOutbox.enqueue({
|
|
kind: 'update-reply', notificationId: item.notification_id, body, operationId,
|
|
});
|
|
onStatus('Queued for sync when the connection returns.');
|
|
return { queued: true };
|
|
}
|
|
onStatus('Could not send reply. Your draft is safe; retry.');
|
|
return false;
|
|
} finally {
|
|
pending = false;
|
|
}
|
|
},
|
|
};
|
|
}
|
|
|
|
function filterMyWork(items, selectedFilter, selectedMilestone = 'all') {
|
|
let filtered = items;
|
|
if (selectedFilter === 'attention') filtered = items.filter((item) => item.has_update || item.is_review);
|
|
else if (selectedFilter === 'review') filtered = items.filter((item) => item.is_review);
|
|
else if (selectedFilter === 'update') filtered = items.filter((item) => item.has_update);
|
|
else if (selectedFilter !== 'all') filtered = items.filter((item) => item.kind === selectedFilter);
|
|
if (selectedMilestone === 'all') return filtered;
|
|
if (selectedMilestone === 'unplanned') {
|
|
return filtered.filter(item => item.kind === 'issue' && !item.milestone);
|
|
}
|
|
return filtered.filter(item =>
|
|
item.kind === 'issue' && String(item.milestone?.id || '') === String(selectedMilestone)
|
|
);
|
|
}
|
|
|
|
function milestoneLanes(items) {
|
|
const lanes = new Map();
|
|
(items || []).forEach(item => {
|
|
if (item?.kind === 'issue' && Number.isInteger(item.milestone?.id) &&
|
|
typeof item.milestone?.title === 'string') {
|
|
lanes.set(item.milestone.id, { id: item.milestone.id, title: item.milestone.title });
|
|
}
|
|
});
|
|
return Array.from(lanes.values()).sort((left, right) => left.title.localeCompare(right.title));
|
|
}
|
|
|
|
function workIdentity(item) {
|
|
if (!item) return '';
|
|
const kind = item.is_review ? 'review' : (item.kind || 'work');
|
|
const repository = item.repository || '';
|
|
const number = Number.isInteger(item.number) ? item.number : '';
|
|
const notification = Number.isInteger(item.notification_id) ? item.notification_id : '';
|
|
return [kind, repository, number, notification].join(':');
|
|
}
|
|
|
|
function createWorkSession({ getItems, getFilter, getMilestone = () => 'all', onOpen, onProgress, onFinish }) {
|
|
let currentIdentity = '';
|
|
let currentIndex = -1;
|
|
let running = false;
|
|
|
|
const queue = () => filterMyWork(getItems() || [], getFilter(), getMilestone());
|
|
const report = (items, index) => onProgress({
|
|
index: index + 1,
|
|
total: items.length,
|
|
can_previous: index > 0,
|
|
can_next: index < items.length - 1,
|
|
});
|
|
const finish = () => {
|
|
running = false;
|
|
currentIdentity = '';
|
|
currentIndex = -1;
|
|
onFinish();
|
|
return false;
|
|
};
|
|
const openAt = (items, index) => {
|
|
if (!items.length || index < 0 || index >= items.length) return finish();
|
|
currentIndex = index;
|
|
currentIdentity = workIdentity(items[index]);
|
|
report(items, index);
|
|
onOpen(items[index]);
|
|
return true;
|
|
};
|
|
|
|
return {
|
|
active: () => running,
|
|
start() {
|
|
const items = queue();
|
|
if (!items.length) return finish();
|
|
running = true;
|
|
return openAt(items, 0);
|
|
},
|
|
reconcile() {
|
|
if (!running) return false;
|
|
const items = queue();
|
|
const index = items.findIndex(item => workIdentity(item) === currentIdentity);
|
|
if (index < 0) return items.length ? openAt(items, Math.min(currentIndex, items.length - 1)) : finish();
|
|
currentIndex = index;
|
|
report(items, index);
|
|
return true;
|
|
},
|
|
previous() {
|
|
if (!running) return false;
|
|
const items = queue();
|
|
const index = items.findIndex(item => workIdentity(item) === currentIdentity);
|
|
return index > 0 ? openAt(items, index - 1) : false;
|
|
},
|
|
next() {
|
|
if (!running) return false;
|
|
const items = queue();
|
|
const index = items.findIndex(item => workIdentity(item) === currentIdentity);
|
|
return index >= 0 && index < items.length - 1 ? openAt(items, index + 1) : finish();
|
|
},
|
|
complete() {
|
|
if (!running) return false;
|
|
const items = queue();
|
|
const stillPresent = items.findIndex(item => workIdentity(item) === currentIdentity);
|
|
if (stillPresent >= 0) {
|
|
return stillPresent < items.length - 1 ? openAt(items, stillPresent + 1) : finish();
|
|
}
|
|
return items.length ? openAt(items, Math.min(currentIndex, items.length - 1)) : finish();
|
|
},
|
|
};
|
|
}
|
|
|
|
function replaceIssueLabels(data, repository, number, labels) {
|
|
return {
|
|
...data,
|
|
issues: (data.issues || []).map(item =>
|
|
item.repository === repository && item.number === number ? { ...item, labels: [...labels] } : item
|
|
),
|
|
};
|
|
}
|
|
|
|
function replaceIssueContent(data, repository, number, content) {
|
|
return {
|
|
...data,
|
|
issues: (data.issues || []).map(item =>
|
|
item.repository === repository && item.number === number ? { ...item, ...content } : item
|
|
),
|
|
};
|
|
}
|
|
|
|
function replaceIssueDueDate(data, repository, number, dueDate) {
|
|
return {
|
|
...data,
|
|
issues: (data.issues || []).map(item =>
|
|
item.repository === repository && item.number === number ? { ...item, due_date: dueDate } : item
|
|
),
|
|
};
|
|
}
|
|
|
|
function replaceIssueMilestone(data, repository, number, milestone) {
|
|
return {
|
|
...data,
|
|
issues: (data.issues || []).map(item =>
|
|
item.repository === repository && item.number === number ? { ...item, milestone } : item
|
|
),
|
|
};
|
|
}
|
|
|
|
function removeIssue(data, repository, number) {
|
|
return {
|
|
...data,
|
|
issues: (data.issues || []).filter(item =>
|
|
item.repository !== repository || item.number !== number
|
|
),
|
|
};
|
|
}
|
|
|
|
function summarizeMyWork(items) {
|
|
const updates = items.filter((item) => item.has_update).length;
|
|
const reviews = items.filter((item) => item.is_review).length;
|
|
const assigned = items.filter((item) => item.is_assigned).length;
|
|
const updateLabel = updates + ' unread update' + (updates === 1 ? '' : 's');
|
|
const reviewLabel = reviews + ' review' + (reviews === 1 ? '' : 's');
|
|
const assignedLabel = assigned + ' assigned';
|
|
return (updates ? updateLabel + ' · ' : '') + reviewLabel + ' · ' + assignedLabel;
|
|
}
|
|
|
|
function countMyWork(items) {
|
|
return {
|
|
all: items.length,
|
|
attention: items.filter((item) => item.has_update || item.is_review).length,
|
|
issue: items.filter((item) => item.kind === 'issue').length,
|
|
pull: items.filter((item) => item.kind === 'pull' && !item.is_review).length,
|
|
review: items.filter((item) => item.is_review).length,
|
|
update: items.filter((item) => item.has_update).length,
|
|
};
|
|
}
|
|
|
|
if (typeof module !== 'undefined' && module.exports) {
|
|
buildMyWork.filterMyWork = filterMyWork;
|
|
buildMyWork.milestoneLanes = milestoneLanes;
|
|
buildMyWork.createWorkSession = createWorkSession;
|
|
buildMyWork.workIdentity = workIdentity;
|
|
buildMyWork.replaceIssueLabels = replaceIssueLabels;
|
|
buildMyWork.replaceIssueContent = replaceIssueContent;
|
|
buildMyWork.replaceIssueDueDate = replaceIssueDueDate;
|
|
buildMyWork.replaceIssueMilestone = replaceIssueMilestone;
|
|
buildMyWork.removeIssue = removeIssue;
|
|
buildMyWork.summarizeMyWork = summarizeMyWork;
|
|
buildMyWork.countMyWork = countMyWork;
|
|
buildMyWork.acknowledgeNotification = acknowledgeNotification;
|
|
buildMyWork.createNotificationAcknowledger = createNotificationAcknowledger;
|
|
buildMyWork.notificationIds = notificationIds;
|
|
buildMyWork.createBulkNotificationAcknowledger = createBulkNotificationAcknowledger;
|
|
buildMyWork.createNotificationPager = createNotificationPager;
|
|
buildMyWork.createWorkPager = createWorkPager;
|
|
buildMyWork.createNotificationReader = createNotificationReader;
|
|
buildMyWork.createNotificationReplier = createNotificationReplier;
|
|
module.exports = buildMyWork;
|
|
}
|