@gperezmz/bb-plugin-thread-glance 0.1.2

package/features/thread-list/model/drag.ts

@@ -0,0 +1,104 @@
+// Drag and drop outcomes. Pure: components report what was dropped
+// where, and this decides what it means.
+import type { OrganizationMode } from "@/shared/preferences";
+
+export interface DraggedThread {
+  threadId: string;
+  parentThreadId: string | null;
+  sectionId: string | null;
+  pinned: boolean;
+}
+
+export type DropTarget =
+  | { kind: "thread"; threadId: string; zone: "before" | "middle" | "after"; inPinned: boolean }
+  | { kind: "group"; groupId: string };
+
+export type DropAction =
+  | { type: "nest"; threadId: string; parentThreadId: string; unpinFirst: boolean }
+  | { type: "move"; threadId: string; sectionId: string | null; detach: boolean }
+  | { type: "detach"; threadId: string }
+  | { type: "pin"; threadId: string }
+  | { type: "unpin"; threadId: string }
+  | { type: "reorder-pinned"; threadId: string; previousThreadId: string | null; nextThreadId: string | null }
+  | { type: "blocked" }
+  | { type: "unchanged" };
+
+export interface DropContext {
+  mode: OrganizationMode;
+  /** Raw `parentThreadId` for every loaded thread. */
+  parentOf: (threadId: string) => string | null;
+  /** Pinned roots in Pinned's display order. */
+  pinnedOrder: readonly string[];
+}
+
+/** True when `candidate` is `ancestorId` or one of its descendants. */
+export function isInSubtree(
+  candidate: string,
+  ancestorId: string,
+  parentOf: (threadId: string) => string | null,
+): boolean {
+  const seen = new Set<string>();
+  let current: string | null = candidate;
+  while (current !== null && !seen.has(current)) {
+    if (current === ancestorId) return true;
+    seen.add(current);
+    current = parentOf(current);
+  }
+  return false;
+}
+
+function dropOnGroup(source: DraggedThread, groupId: string, context: DropContext): DropAction {
+  if (groupId === "pinned") {
+    return source.pinned ? { type: "unchanged" } : { type: "pin", threadId: source.threadId };
+  }
+  if (source.pinned) return { type: "unpin", threadId: source.threadId };
+  if (context.mode === "chronological" && (groupId === "threads" || groupId.startsWith("section:"))) {
+    const sectionId = groupId === "threads" ? null : groupId.slice("section:".length);
+    if (sectionId === source.sectionId && source.parentThreadId === null) return { type: "unchanged" };
+    return {
+      type: "move",
+      threadId: source.threadId,
+      sectionId,
+      detach: source.parentThreadId !== null,
+    };
+  }
+  if (source.parentThreadId !== null) return { type: "detach", threadId: source.threadId };
+  return { type: "unchanged" };
+}
+
+/** What dropping a thread on a target does, with bb's guards. */
+export function resolveDrop(
+  source: DraggedThread,
+  target: DropTarget,
+  context: DropContext & { groupOfThread: (threadId: string) => string },
+): DropAction {
+  if (target.kind === "group") return dropOnGroup(source, target.groupId, context);
+  if (target.threadId === source.threadId) return { type: "unchanged" };
+  if (target.zone === "middle") {
+    if (isInSubtree(target.threadId, source.threadId, context.parentOf)) return { type: "blocked" };
+    if (source.parentThreadId === target.threadId) return { type: "unchanged" };
+    return {
+      type: "nest",
+      threadId: source.threadId,
+      parentThreadId: target.threadId,
+      unpinFirst: source.pinned,
+    };
+  }
+  if (target.inPinned && context.pinnedOrder.includes(target.threadId)) {
+    if (!source.pinned) return { type: "pin", threadId: source.threadId };
+    const order = context.pinnedOrder.filter((id) => id !== source.threadId);
+    const index = order.indexOf(target.threadId);
+    const insertAt = target.zone === "before" ? index : index + 1;
+    const previousThreadId = order[insertAt - 1] ?? null;
+    const nextThreadId = order[insertAt] ?? null;
+    const current = context.pinnedOrder.indexOf(source.threadId);
+    if (
+      (context.pinnedOrder[current - 1] ?? null) === previousThreadId &&
+      (context.pinnedOrder[current + 1] ?? null) === nextThreadId
+    ) {
+      return { type: "unchanged" };
+    }
+    return { type: "reorder-pinned", threadId: source.threadId, previousThreadId, nextThreadId };
+  }
+  return dropOnGroup(source, context.groupOfThread(target.threadId), context);
+}

package/features/thread-list/model/expansion.ts

@@ -0,0 +1,71 @@
+// Auto-expansion: transitions found by diffing snapshots, and the
+// transient targets they leave behind. Pure.
+import { revealsOn } from "./attention";
+import type { Forest } from "./families";
+
+/**
+ * `reveal` targets open their group, their `N older` fold and the parent
+ * chips on their path. `open` targets (a thread that newly became unread)
+ * open the group and the fold only, so finished children don't expand
+ * their parent's chip.
+ */
+export type TargetKind = "reveal" | "open";
+export type Targets = ReadonlyMap<string, TargetKind>;
+
+export interface Snapshot {
+  activeThreadId: string | null;
+  unread: ReadonlySet<string>;
+  /** Threads that wait on you or failed, as Needs attention counts them. */
+  attention: ReadonlySet<string>;
+}
+
+export function snapshotOf(forest: Forest, activeThreadId: string | null): Snapshot {
+  const unread = new Set<string>();
+  const attention = new Set<string>();
+  for (const info of forest.infos.values()) {
+    if (info.thread.isArchived) continue;
+    // A finished child that Needs attention does not count never opens anything.
+    if (info.attention.has("unread") && !info.thread.isHidden) unread.add(info.thread.id);
+    if (revealsOn(info.attention, info.parentId === null)) attention.add(info.thread.id);
+  }
+  return { activeThreadId, unread, attention };
+}
+
+/**
+ * The targets a render adds. `previous` is null on the first
+ * render, which counts as a transition.
+ */
+export function detectTransitions(previous: Snapshot | null, next: Snapshot): Map<string, TargetKind> {
+  const found = new Map<string, TargetKind>();
+  if (next.activeThreadId !== null && next.activeThreadId !== previous?.activeThreadId) {
+    found.set(next.activeThreadId, "reveal");
+  }
+  for (const id of next.attention) {
+    if (!previous?.attention.has(id)) found.set(id, "reveal");
+  }
+  for (const id of next.unread) {
+    if (id === next.activeThreadId || found.has(id)) continue;
+    if (!previous?.unread.has(id)) found.set(id, "open");
+  }
+  return found;
+}
+
+export function mergeTargets(current: Targets, added: ReadonlyMap<string, TargetKind>): Targets {
+  if (added.size === 0) return current;
+  const next = new Map(current);
+  for (const [id, kind] of added) {
+    if (next.get(id) !== "reveal") next.set(id, kind);
+  }
+  return next;
+}
+
+/** Drops targets for which `drop` returns true (a user's collapse). */
+export function pruneTargets(current: Targets, drop: (id: string) => boolean): Targets {
+  let changed = false;
+  const next = new Map<string, TargetKind>();
+  for (const [id, kind] of current) {
+    if (drop(id)) changed = true;
+    else next.set(id, kind);
+  }
+  return changed ? next : current;
+}

package/features/thread-list/model/families.ts

@@ -0,0 +1,297 @@
+// Families: who attaches to whom, and what each family
+// carries. Pure.
+import type { PluginSidebarThread } from "@get-bb/plugin-sdk/app";
+import {
+  computeState,
+  hiddenThreadFlags,
+  isQuietThread,
+  isUnread,
+  threadFlags,
+  type Flag,
+  type ThreadContext,
+  type StateKind,
+  type ThreadState,
+} from "./state";
+import { attentionFlagsOf, isOrphanedFailure } from "./attention";
+import { compareCreationAscending } from "./sort";
+import { needsKindOf, rowNote, type RowNote } from "./notes";
+import type { ThreadNotes } from "@/shared/contract";
+import type { ChildAttention } from "@/shared/preferences";
+
+/** States that keep a child out of its family's fold with `childAttention` `blocked`: working, setting up, background work. */
+const RUNNING: ReadonlySet<StateKind> = new Set<StateKind>(["working", "background"]);
+
+/** Everything the list knows about one thread. */
+export interface ThreadInfo {
+  thread: PluginSidebarThread;
+  state: ThreadState;
+  unread: boolean;
+  /** Own flags; for hidden threads only needs-you and unread-failed. */
+  flags: ReadonlySet<Flag>;
+  /**
+   * The flags of this thread that count towards Needs attention, its
+   * counters and auto-reveal: a child counts less than a root.
+   */
+  attention: Set<Flag>;
+  /** Quiet test for the thread alone. */
+  quiet: boolean;
+  /**
+   * Nothing to see behind a family's fold. A root, or any child when
+   * `childAttention` is `everything`: the quiet test without the open
+   * thread's exemption. Otherwise a child is settled unless it runs or
+   * counts towards Needs attention, so finishing unread folds it; an
+   * archived child is always settled. The fold
+   * reads this, so opening a thread never changes which children stay shown.
+   */
+  settled: boolean;
+  isActive: boolean;
+  /** The visible ancestor it attaches to, or null for a root. */
+  parentId: string | null;
+  /** Why it needs you or failed, for the line under the row. */
+  note: RowNote | null;
+}
+
+/** What a thread's descendants add up to, for its chip and for folding. */
+export interface Subtree {
+  /** Descendants, depth-first in creation order, hidden ones included. */
+  descendants: ThreadInfo[];
+  /** Union of the descendants' attention flags and working, archived ones left out. */
+  flags: ReadonlySet<Flag>;
+  /** Visible descendants: the chip's number. */
+  visibleCount: number;
+  /** Every visible descendant is settled, so the subtree adds nothing to see when folded. */
+  settled: boolean;
+}
+
+export interface Family {
+  root: ThreadInfo;
+  /** Descendants, depth-first in creation order, hidden ones included. */
+  descendants: ThreadInfo[];
+  /** Union of the descendants' attention flags and working (the chip rollup). */
+  descendantFlags: ReadonlySet<Flag>;
+  /** The same over root and descendants (rollup, folder rows). */
+  flags: ReadonlySet<Flag>;
+  /** Attention flags over root and descendants: what the filter and the urgency order read. */
+  attentionFlags: ReadonlySet<Flag>;
+  /** Visible descendants: the chip's number. */
+  visibleDescendantCount: number;
+  /** Largest latestAttentionAt over the family. */
+  attention: number;
+  /** Every thread quiet and the active thread not in it. */
+  quiet: boolean;
+  /**
+   * The quiet test without the open thread's exemption. A group's fold reads
+   * this, so opening a thread never changes which roots stay shown.
+   */
+  settled: boolean;
+  containsActive: boolean;
+}
+
+export interface Forest {
+  infos: ReadonlyMap<string, ThreadInfo>;
+  /** Visible child ids per parent id, creation order; hidden children included. */
+  children: ReadonlyMap<string, readonly string[]>;
+  families: readonly Family[];
+  familyOf: ReadonlyMap<string, Family>;
+  /** The rollup under every thread with a row, by thread id. */
+  subtrees: ReadonlyMap<string, Subtree>;
+}
+
+export interface ForestInputs extends ThreadContext {
+  threads: readonly PluginSidebarThread[];
+  draftIds: ReadonlySet<string>;
+  scheduled: Readonly<Record<string, number>>;
+  now: number;
+  /** Server notes per thread id; absent until loaded. */
+  notes?: Readonly<Record<string, ThreadNotes>>;
+  /** Which children count towards Needs attention; `blocked` when absent. */
+  childAttention?: ChildAttention;
+}
+
+function isPinned(thread: PluginSidebarThread): boolean {
+  return thread.pinnedAt !== null || thread.isPinned;
+}
+
+/**
+ * The visible loaded ancestor a thread attaches to, or null when it is
+ * a root. A pinned thread with no pinned ancestor is a root. Cycles end
+ * the walk and make the thread a root.
+ */
+export function attachParent(
+  thread: PluginSidebarThread,
+  byId: ReadonlyMap<string, PluginSidebarThread>,
+): string | null {
+  const seen = new Set<string>([thread.id]);
+  let parentId = thread.parentThreadId;
+  let attach: string | null = null;
+  let pinnedAncestor = false;
+  while (parentId !== null) {
+    if (seen.has(parentId)) return null;
+    seen.add(parentId);
+    const parent = byId.get(parentId);
+    if (parent === undefined) break;
+    if (!parent.isHidden) {
+      attach ??= parent.id;
+      if (isPinned(parent)) pinnedAncestor = true;
+    }
+    parentId = parent.parentThreadId;
+  }
+  if (!thread.isHidden && isPinned(thread) && !pinnedAncestor) return null;
+  return attach;
+}
+
+export function buildForest(inputs: ForestInputs): Forest {
+  const byId = new Map(inputs.threads.map((thread) => [thread.id, thread]));
+  const infos = new Map<string, ThreadInfo>();
+  for (const thread of inputs.threads) {
+    const unread = isUnread(thread, inputs);
+    const state = computeState(thread, {
+      unread,
+      hasDraft: inputs.draftIds.has(thread.id),
+      scheduledAt: inputs.scheduled[thread.id] ?? null,
+      now: inputs.now,
+      needsKind: needsKindOf(inputs.notes?.[thread.id]),
+    });
+    const flags = threadFlags(thread, unread);
+    const isActive = thread.id === inputs.activeThreadId;
+    infos.set(thread.id, {
+      thread,
+      state,
+      unread,
+      flags: thread.isHidden ? hiddenThreadFlags(flags) : flags,
+      attention: new Set<Flag>(),
+      quiet: isQuietThread(state, unread, isActive),
+      settled: false,
+      isActive,
+      parentId: attachParent(thread, byId),
+      note: rowNote(thread, inputs.notes?.[thread.id]),
+    });
+  }
+
+  const mode = inputs.childAttention ?? "blocked";
+  for (const info of infos.values()) {
+    const manager = info.parentId === null ? undefined : infos.get(info.parentId);
+    info.attention = attentionFlagsOf(info.flags, {
+      isRoot: manager === undefined,
+      mode,
+      orphaned:
+        manager !== undefined &&
+        isOrphanedFailure(info.thread, info.flags, { ...manager, finishedAt: inputs.finishedAt[manager.thread.id] }),
+    });
+    info.settled =
+      manager === undefined || mode === "everything"
+        ? isQuietThread(info.state, info.unread, false)
+        : info.thread.isArchived || (!RUNNING.has(info.state.kind) && info.attention.size === 0);
+  }
+
+  const children = new Map<string, string[]>();
+  const roots: ThreadInfo[] = [];
+  for (const info of infos.values()) {
+    if (info.parentId === null) {
+      // A hidden thread with no visible ancestor has no row and no family.
+      if (!info.thread.isHidden) roots.push(info);
+      continue;
+    }
+    const list = children.get(info.parentId) ?? [];
+    list.push(info.thread.id);
+    children.set(info.parentId, list);
+  }
+  for (const list of children.values()) {
+    list.sort((a, b) => compareCreationAscending(byId.get(a)!, byId.get(b)!));
+  }
+
+  // Each thread's subtree, once: descendants depth-first, and what they add up to.
+  const subtrees = new Map<string, Subtree>();
+  const subtreeOf = (id: string, path: Set<string>): Subtree => {
+    const cached = subtrees.get(id);
+    if (cached !== undefined) return cached;
+    const descendants: ThreadInfo[] = [];
+    const flags = new Set<Flag>();
+    let visibleCount = 0;
+    let settled = true;
+    path.add(id);
+    for (const childId of children.get(id) ?? []) {
+      if (path.has(childId)) continue;
+      const child = infos.get(childId)!;
+      const below = subtreeOf(childId, path);
+      descendants.push(child, ...below.descendants);
+      if (!child.thread.isArchived) {
+        for (const flag of child.attention) flags.add(flag);
+        if (child.flags.has("working")) flags.add("working");
+      }
+      for (const flag of below.flags) flags.add(flag);
+      if (child.thread.isHidden ? child.attention.size > 0 : !child.settled) settled = false;
+      if (!child.thread.isHidden) visibleCount += 1;
+      visibleCount += below.visibleCount;
+      if (!below.settled) settled = false;
+    }
+    path.delete(id);
+    const subtree: Subtree = { descendants, flags, visibleCount, settled };
+    subtrees.set(id, subtree);
+    return subtree;
+  };
+  for (const id of infos.keys()) subtreeOf(id, new Set());
+
+  const families: Family[] = [];
+  const familyOf = new Map<string, Family>();
+  for (const root of roots) {
+    const { descendants, flags: descendantFlags, visibleCount: visibleDescendantCount } = subtrees.get(root.thread.id)!;
+    let attention = root.thread.latestAttentionAt;
+    let quiet = root.quiet;
+    let settled = isQuietThread(root.state, root.unread, false);
+    let containsActive = root.isActive;
+    const attentionFlags = new Set<Flag>();
+    for (const info of descendants) {
+      if (!info.thread.isArchived) for (const flag of info.attention) attentionFlags.add(flag);
+      attention = Math.max(attention, info.thread.latestAttentionAt);
+      if (info.isActive) containsActive = true;
+      if (info.thread.isHidden) {
+        if (info.attention.size > 0) quiet = settled = false;
+      } else {
+        if (!info.quiet) quiet = false;
+        if (!isQuietThread(info.state, info.unread, false)) settled = false;
+      }
+    }
+    const flags = new Set<Flag>(descendantFlags);
+    if (!root.thread.isArchived) {
+      for (const flag of root.attention) {
+        flags.add(flag);
+        attentionFlags.add(flag);
+      }
+      if (root.flags.has("working")) flags.add("working");
+    }
+    const family: Family = {
+      root,
+      descendants,
+      descendantFlags,
+      flags,
+      attentionFlags,
+      visibleDescendantCount,
+      attention,
+      quiet: quiet && !containsActive,
+      settled,
+      containsActive,
+    };
+    families.push(family);
+    familyOf.set(root.thread.id, family);
+    for (const info of descendants) familyOf.set(info.thread.id, family);
+  }
+  return { infos, children, families, familyOf, subtrees };
+}
+
+/** Ids from `id` up to (not including) `stopAt`, nearest first. */
+export function ancestorsOf(
+  id: string,
+  infos: ReadonlyMap<string, ThreadInfo>,
+  stopAt: string | null = null,
+): string[] {
+  const path: string[] = [];
+  const seen = new Set<string>([id]);
+  let current = infos.get(id)?.parentId ?? null;
+  while (current !== null && current !== stopAt && !seen.has(current)) {
+    path.push(current);
+    seen.add(current);
+    current = infos.get(current)?.parentId ?? null;
+  }
+  return path;
+}