@heyramzi/ui 2.1.0 → 2.2.0

package/src/inbox/logic.ts

@@ -1,166 +1,169 @@
 import { isOpen, isTyping } from "../tasks/inbox/inbox-logic.js";
 import {
-	ALL,
-	DEFAULT_INBOX_LABELS,
-	type InboxEntry,
-	type InboxFilter,
-	type InboxKey,
-	type InboxLabels,
-	type InboxSubject,
-	type InboxThread,
+  ALL,
+  DEFAULT_INBOX_LABELS,
+  type InboxEntry,
+  type InboxFilter,
+  type InboxKey,
+  type InboxLabels,
+  type InboxSubject,
+  type InboxThread,
 } from "./types.js";
 
 /** A timestamp as a number, with NaN for one that doesn't parse. */
 function ms(at: string): number {
-	return Date.parse(at);
+  return Date.parse(at);
 }
 
 function latestOf(thread: InboxThread): number {
-	const time = ms(thread.latestAt);
-	return Number.isNaN(time) ? Number.NEGATIVE_INFINITY : time;
+  const time = ms(thread.latestAt);
+  return Number.isNaN(time) ? Number.NEGATIVE_INFINITY : time;
 }
 
 export type ThreadsOptions = {
-	/** Threads with unread entries come before read ones. */
-	unreadFirst?: boolean;
+  /** Threads with unread entries come before read ones. */
+  unreadFirst?: boolean;
 };
 
 /** True while a proposal entry still waits for a verdict. */
 export function isPending(entry: InboxEntry): boolean {
-	return entry.kind === "proposal" && !!entry.proposal && isOpen(entry.proposal);
+  return entry.kind === "proposal" && !!entry.proposal && isOpen(entry.proposal);
 }
 
 /**
- * Group entries into one thread per subject and sort by the newest entry. An entry with no subject id
- * is dropped. A malformed timestamp sorts last, among threads and inside one.
+ * One thread per subject, newest first. An entry with no subject id is dropped, and a malformed
+ * timestamp sorts last.
  */
 export function threadsOf(entries: InboxEntry[], options: ThreadsOptions = {}): InboxThread[] {
-	type Row = { entry: InboxEntry; subject: InboxSubject; index: number; time: number };
-	const groups = new Map<string, Row[]>();
-	entries.forEach((entry, index) => {
-		const subject = entry.subject;
-		if (!subject?.id) return;
-		const key = `${subject.type}:${subject.id}`;
-		groups.set(key, [...(groups.get(key) ?? []), { entry, subject, index, time: ms(entry.at) }]);
-	});
-
-	const threads: InboxThread[] = [];
-	for (const [key, rows] of groups) {
-		const ordered = rows.toSorted((a, b) => {
-			const aBad = Number.isNaN(a.time);
-			const bBad = Number.isNaN(b.time);
-			if (aBad !== bBad) return aBad ? 1 : -1;
-			return (aBad ? 0 : a.time - b.time) || a.index - b.index;
-		});
-		const newest = ordered.findLast((row) => !Number.isNaN(row.time)) ?? ordered[0];
-		const list = ordered.map((row) => row.entry);
-		threads.push({
-			key,
-			// The newest entry carries the freshest title and status.
-			subject: newest.subject,
-			entries: list,
-			unread: list.filter((entry) => !entry.read).length,
-			latestAt: newest.entry.at,
-			pending: list.filter(isPending).toReversed(),
-		});
-	}
-
-	return threads
-		.map((thread, index) => ({ thread, index }))
-		.toSorted((a, b) => {
-			if (options.unreadFirst) {
-				const unread = Number(b.thread.unread > 0) - Number(a.thread.unread > 0);
-				if (unread) return unread;
-			}
-			const aTime = latestOf(a.thread);
-			const bTime = latestOf(b.thread);
-			if (aTime === bTime) return a.index - b.index;
-			return bTime - aTime;
-		})
-		.map((row) => row.thread);
+  type Row = { entry: InboxEntry; subject: InboxSubject; index: number; time: number };
+  const groups = new Map<string, Row[]>();
+  entries.forEach((entry, index) => {
+    const subject = entry.subject;
+    if (!subject?.id) return;
+    const key = `${subject.type}:${subject.id}`;
+    groups.set(key, [...(groups.get(key) ?? []), { entry, subject, index, time: ms(entry.at) }]);
+  });
+
+  const threads: InboxThread[] = [];
+  for (const [key, rows] of groups) {
+    const ordered = rows.toSorted((a, b) => {
+      const aBad = Number.isNaN(a.time);
+      const bBad = Number.isNaN(b.time);
+      if (aBad !== bBad) return aBad ? 1 : -1;
+      return (aBad ? 0 : a.time - b.time) || a.index - b.index;
+    });
+    const newest = ordered.findLast((row) => !Number.isNaN(row.time)) ?? ordered[0];
+    const list = ordered.map((row) => row.entry);
+    threads.push({
+      key,
+      // The newest entry carries the freshest title and status.
+      subject: newest.subject,
+      entries: list,
+      unread: list.filter((entry) => !entry.read).length,
+      latestAt: newest.entry.at,
+      pending: list.filter(isPending).toReversed(),
+    });
+  }
+
+  return threads
+    .map((thread, index) => ({ thread, index }))
+    .toSorted((a, b) => {
+      if (options.unreadFirst) {
+        const unread = Number(b.thread.unread > 0) - Number(a.thread.unread > 0);
+        if (unread) return unread;
+      }
+      const aTime = latestOf(a.thread);
+      const bTime = latestOf(b.thread);
+      if (aTime === bTime) return a.index - b.index;
+      return bTime - aTime;
+    })
+    .map((row) => row.thread);
 }
 
 export const NO_FILTER: InboxFilter = { type: ALL, who: ALL, needsYou: false };
 
 /** Keep a thread when it matches the type, holds an entry from the person or agent, and has a pending proposal if asked. */
 export function filterThreads(threads: InboxThread[], filter: InboxFilter): InboxThread[] {
-	return threads.filter(
-		(thread) =>
-			(filter.type === ALL || thread.subject.type === filter.type) &&
-			(filter.who === ALL || thread.entries.some((entry) => entry.actor.name === filter.who)) &&
-			(!filter.needsYou || thread.pending.length > 0),
-	);
+  return threads.filter(
+    (thread) =>
+      (filter.type === ALL || thread.subject.type === filter.type) &&
+      (filter.who === ALL || thread.entries.some((entry) => entry.actor.name === filter.who)) &&
+      (!filter.needsYou || thread.pending.length > 0),
+  );
 }
 
 export function subjectTypes(threads: InboxThread[]): string[] {
-	return [...new Set(threads.map((thread) => thread.subject.type))];
+  return [...new Set(threads.map((thread) => thread.subject.type))];
 }
 
 export function actorNames(threads: InboxThread[]): string[] {
-	return [...new Set(threads.flatMap((thread) => thread.entries.map((entry) => entry.actor.name)))];
+  return [...new Set(threads.flatMap((thread) => thread.entries.map((entry) => entry.actor.name)))];
 }
 
-type KeyEventLike = Pick<KeyboardEvent, "key" | "metaKey" | "ctrlKey" | "altKey" | "defaultPrevented" | "target">;
+type KeyEventLike = Pick<
+  KeyboardEvent,
+  "key" | "metaKey" | "ctrlKey" | "altKey" | "defaultPrevented" | "target"
+>;
 
 const KEYS: Record<string, InboxKey> = {
-	j: "next",
-	k: "previous",
-	u: "toggleRead",
-	h: "snooze",
-	a: "approve",
-	d: "decline",
-	s: "steer",
-	e: "edit",
+  j: "next",
+  k: "previous",
+  u: "toggleRead",
+  h: "snooze",
+  a: "approve",
+  d: "decline",
+  s: "steer",
+  e: "edit",
 };
 
 /** What a key press asks for, or null when it isn't ours: a modifier is held, or focus is in a text field. */
 export function inboxKeyOf(event: KeyEventLike): InboxKey | null {
-	if (event.defaultPrevented || event.metaKey || event.ctrlKey || event.altKey) return null;
-	if (isTyping(event.target)) return null;
-	return KEYS[event.key] ?? null;
+  if (event.defaultPrevented || event.metaKey || event.ctrlKey || event.altKey) return null;
+  if (isTyping(event.target)) return null;
+  return KEYS[event.key] ?? null;
 }
 
 export type SnoozeChoice = { id: "later" | "tomorrow" | "nextWeek"; until: Date };
 
 /** The three times a snooze offers: 3 hours on, tomorrow at 9, next Monday at 9. */
 export function snoozeChoices(now: Date): SnoozeChoice[] {
-	const later = new Date(now.getTime() + 3 * 60 * 60 * 1000);
-	const tomorrow = new Date(now);
-	tomorrow.setDate(tomorrow.getDate() + 1);
-	tomorrow.setHours(9, 0, 0, 0);
-	const nextWeek = new Date(now);
-	nextWeek.setDate(nextWeek.getDate() + (((8 - nextWeek.getDay()) % 7) || 7));
-	nextWeek.setHours(9, 0, 0, 0);
-	return [
-		{ id: "later", until: later },
-		{ id: "tomorrow", until: tomorrow },
-		{ id: "nextWeek", until: nextWeek },
-	];
+  const later = new Date(now.getTime() + 3 * 60 * 60 * 1000);
+  const tomorrow = new Date(now);
+  tomorrow.setDate(tomorrow.getDate() + 1);
+  tomorrow.setHours(9, 0, 0, 0);
+  const nextWeek = new Date(now);
+  nextWeek.setDate(nextWeek.getDate() + ((8 - nextWeek.getDay()) % 7 || 7));
+  nextWeek.setHours(9, 0, 0, 0);
+  return [
+    { id: "later", until: later },
+    { id: "tomorrow", until: tomorrow },
+    { id: "nextWeek", until: nextWeek },
+  ];
 }
 
 export function resolveInboxLabels(overrides?: Partial<InboxLabels>): InboxLabels {
-	return { ...DEFAULT_INBOX_LABELS, ...overrides };
+  return { ...DEFAULT_INBOX_LABELS, ...overrides };
 }
 
 /** One line for an entry, in the host's words. `{from}`, `{to}` and `{assignee}` are filled. */
 export function entryLine(entry: InboxEntry, labels: InboxLabels): string {
-	const fill = (text: string) =>
-		text
-			.replaceAll("{from}", entry.status?.from ?? "")
-			.replaceAll("{to}", entry.status?.to ?? "")
-			.replaceAll("{assignee}", entry.assignee ?? "");
-	switch (entry.kind) {
-		case "status":
-			return fill(entry.status?.from ? labels.statusMoved : labels.statusSet);
-		case "assigned":
-			return fill(labels.assigned);
-		case "mention":
-			return labels.mentioned;
-		case "agent_response":
-			return labels.responded;
-		case "proposal":
-			return labels.proposed;
-		default:
-			return labels.commented;
-	}
+  const fill = (text: string) =>
+    text
+      .replaceAll("{from}", entry.status?.from ?? "")
+      .replaceAll("{to}", entry.status?.to ?? "")
+      .replaceAll("{assignee}", entry.assignee ?? "");
+  switch (entry.kind) {
+    case "status":
+      return fill(entry.status?.from ? labels.statusMoved : labels.statusSet);
+    case "assigned":
+      return fill(labels.assigned);
+    case "mention":
+      return labels.mentioned;
+    case "agent_response":
+      return labels.responded;
+    case "proposal":
+      return labels.proposed;
+    default:
+      return labels.commented;
+  }
 }