@gperezmz/bb-plugin-thread-glance 0.2.4 → 0.4.0

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

@@ -271,27 +271,28 @@ export function hiddenThreadFlags(flags: ReadonlySet<Flag>): Set<Flag> {
   return kept;
 }
 
+/** Flags a hidden thread adds to the children chip above it: what asks for you or failed, and offline. */
+const HIDDEN_CHIP_FLAGS: ReadonlySet<Flag> = new Set<Flag>(["waits-on-you", "unread-failed", "queue-failed", "offline"]);
+
+/**
+ * The flags a thread adds to the children chip of the threads above it. A
+ * hidden thread adds only waits-on-you, failed, queued message failed and
+ * offline; which trees need attention reads `hiddenThreadFlags` instead,
+ * so this leaves it unchanged.
+ */
+export function chipFlagsOf(flags: ReadonlySet<Flag>, isHidden: boolean): Set<Flag> {
+  return isHidden ? new Set([...flags].filter((flag) => HIDDEN_CHIP_FLAGS.has(flag))) : new Set(flags);
+}
+
 /** The most urgent flag, or null. */
 export function mostUrgent(flags: ReadonlySet<Flag>): Flag | null {
   return FLAG_ORDER.find((flag) => flags.has(flag)) ?? null;
 }
 
-/** The colour a child chip takes: only what asks for you, fails, or works. */
-export type ChipTone = "attention" | "destructive" | "working" | "neutral";
-
-/** The tone of a chip whose most urgent rolled-up flag is `flag`. */
-export function chipTone(flag: Flag | null): ChipTone {
-  switch (flag) {
-    case "waits-on-you":
-      return "attention";
-    case "unread-failed":
-    case "queue-failed":
-      return "destructive";
-    case "working":
-      return "working";
-    default:
-      return "neutral";
-  }
+/** The tone a children chip takes for a state: its glyph's, and the unread dot's accent for unread. */
+export function chipTone(flag: Flag): Tone {
+  const tone = FLAG_GLYPHS[flag].tone;
+  return tone === "none" ? "working" : tone;
 }
 
 export const FLAG_GLYPHS: Readonly<Record<Flag, Glyph & { label: string }>> = {

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

@@ -105,3 +105,10 @@ export function stateSince(
   if (at === undefined) return null;
   return formatDuration(now - at);
 }
+
+/**
+ * The widest texts `trailingTime` gives up to 99 weeks, one per unit. The
+ * trailing slot is as wide as the widest of them, so times line up down the
+ * list; an older row widens its own.
+ */
+export const TRAILING_SLOT_SIZERS = ["now", "<1m", "59m", "23h", "6d", "99w"] as const;

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

@@ -1,10 +1,10 @@
 // What a user's click on a chip, fold or header changes.
 // Pure: returns the preference patch and which auto-expand targets to drop.
 import type { Preferences } from "@/shared/preferences";
-import { ancestorsOf, type Family, type Forest } from "./families";
+import { ancestorsOf, type ThreadTree, type Forest } from "./trees";
 import { isGroupCollapsed, toggleGroupCollapse } from "./groups";
 import { isDoneUnseen } from "./state";
-import type { GroupView, OlderRow, ThreadRow } from "./view";
+import type { GroupView, OlderRow, SettledRow, ThreadRow } from "./view";
 
 export interface ToggleOutcome {
   patch: Partial<Preferences>;
@@ -29,36 +29,31 @@ export function toggleChip(row: ThreadRow, prefs: Preferences, forest: Forest):
     : openChildren(id, prefs);
 }
 
-/** Opens a parent's children, as its chip does: "+N more" in Needs attention and an auto-reveal's fold. */
+/** Opens a parent's children, as its chip does, from an auto-reveal's fold. */
 export function openChildren(parentId: string, prefs: Preferences): ToggleOutcome {
   return { patch: { expandedChildren: [...without(prefs.expandedChildren, parentId), parentId] }, drop: null };
 }
 
-export function toggleOlder(row: OlderRow, prefs: Preferences, group: GroupView | null, forest: Forest): ToggleOutcome {
+/** Opens or closes an open tree's "N more child threads" fold. */
+export function toggleOlder(row: OlderRow, prefs: Preferences, forest: Forest): ToggleOutcome {
   if (row.scope === "reveal") return openChildren(row.scopeId, prefs);
   if (!row.expanded) {
     return { patch: { expandedOlder: [...without(prefs.expandedOlder, row.scopeId), row.scopeId] }, drop: null };
   }
-  const patch = { expandedOlder: without(prefs.expandedOlder, row.scopeId) };
-  if (row.scope === "family") return { patch, drop: under(forest, row.scopeId) };
-  // Folding a group's older roots drops the targets that held it open.
-  const quietRoots = new Set<string>();
-  for (const family of forest.families) if (family.quietIgnoringOpen) quietRoots.add(family.root.thread.id);
-  const inGroup = new Set(group?.rootIds ?? []);
-  return {
-    patch,
-    drop: (id) => {
-      const family = forest.familyOf.get(id);
-      return family !== undefined && quietRoots.has(family.root.thread.id) && inGroup.has(family.root.thread.id);
-    },
-  };
+  return { patch: { expandedOlder: without(prefs.expandedOlder, row.scopeId) }, drop: under(forest, row.scopeId) };
+}
+
+/** Opens or closes a group's settled fold. */
+export function toggleSettled(row: SettledRow, prefs: Preferences): ToggleOutcome {
+  const rest = without(prefs.openSettledFolds, row.groupId);
+  return { patch: { openSettledFolds: row.expanded ? rest : [...rest, row.groupId] }, drop: null };
 }
 
 export function toggleGroup(group: GroupView, prefs: Preferences, forest: Forest): ToggleOutcome {
   const inGroup = new Set(group.rootIds);
   const dropGroup = (id: string) => {
-    const family = forest.familyOf.get(id);
-    return family !== undefined && inGroup.has(family.root.thread.id);
+    const tree = forest.treeOf.get(id);
+    return tree !== undefined && inGroup.has(tree.root.thread.id);
   };
   if (group.collapsed) {
     return {
@@ -78,19 +73,35 @@ export interface MarkAllRead {
   seen: string[];
 }
 
-/** Every unread thread in the families, descendants included. */
+/** Every unread thread in the trees, descendants included: Mark all read, and a root's Mark read for its tree. */
 export function markAllReadPlan(
-  families: readonly Family[],
+  trees: readonly ThreadTree[],
   context: { activeThreadId: string | null; finishedAt: Readonly<Record<string, number>>; seenAt: Readonly<Record<string, number>> },
 ): MarkAllRead {
   const read: string[] = [];
   const seen: string[] = [];
-  for (const family of families) {
-    for (const info of [family.root, ...family.descendants]) {
-      if (!info.unread || info.thread.isArchived) continue;
+  for (const tree of trees) {
+    for (const info of [tree.root, ...tree.descendants]) {
+      if (!info.unread) continue;
       read.push(info.thread.id);
       if (isDoneUnseen(info.thread, context)) seen.push(info.thread.id);
     }
   }
   return { read, seen };
 }
+
+/**
+ * What one row's Mark read marks: on a tree's root, every unread thread in
+ * the tree; on any other row, the thread alone.
+ */
+export function markReadPlanFor(
+  threadId: string,
+  forest: Pick<Forest, "infos" | "treeOf">,
+  context: { activeThreadId: string | null; finishedAt: Readonly<Record<string, number>>; seenAt: Readonly<Record<string, number>> },
+): MarkAllRead {
+  const tree = forest.treeOf.get(threadId);
+  if (tree !== undefined && tree.root.thread.id === threadId) return markAllReadPlan([tree], context);
+  const thread = forest.infos.get(threadId)?.thread;
+  if (thread === undefined) return { read: [threadId], seen: [] };
+  return { read: [threadId], seen: isDoneUnseen(thread, context) ? [threadId] : [] };
+}

package/features/thread-list/model/{families.ts → trees.ts}

@@ -1,8 +1,9 @@
-// Families: who attaches to whom, and what each family
+// Thread trees: who attaches to whom, and what each tree
 // carries. Pure.
 import type { PluginSidebarThread } from "@get-bb/plugin-sdk/app";
 import {
   computeState,
+  chipFlagsOf,
   hiddenThreadFlags,
   isQuietThread,
   isUnread,
@@ -14,11 +15,11 @@ import {
 } from "./state";
 import { attentionFlagsOf, isOrphanedFailure } from "./attention";
 import { compareCreationAscending } from "./sort";
-import { attentionNote, needsKindOf, rowNote, type RowNote } from "./notes";
+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 older fold with `childAttention` `blocked`: working, setting up, background work. */
+/** States that keep a child out of an open tree's "N more child threads" 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. */
@@ -28,16 +29,19 @@ export interface ThreadInfo {
   unread: boolean;
   /** Own flags; for hidden threads only waits-on-you and unread-failed. */
   flags: ReadonlySet<Flag>;
+  /** What it adds to the children chip of the threads above it (see `chipFlagsOf`). */
+  chipFlags: ReadonlySet<Flag>;
   /**
-   * The flags of this thread that make it need attention, for Needs attention, the
-   * counters and auto-reveal: a child counts less than a root.
+   * The flags of this thread that make it need attention, for collapsed
+   * groups, the counters, the need-you filter and auto-reveal: a child counts
+   * less than a root.
    */
   attentionFlags: Set<Flag>;
   /** Quiet test for the thread alone. */
   quiet: boolean;
   /**
    * A quiet thread, as if no thread were open: nothing to see behind a
-   * family's fold. A root, or any child when `childAttention` is
+   * tree's fold. A root, or any child when `childAttention` is
    * `everything`, takes the quiet test without the open thread's exemption.
    * Otherwise a child is quiet unless it runs or needs attention, so finishing
    * unread folds it; an archived child is always quiet. The fold reads this,
@@ -49,23 +53,25 @@ export interface ThreadInfo {
   parentId: string | null;
   /** Why it waits on you or failed, for the line under the row. */
   note: RowNote | null;
-  /** Why it needs attention, for the line under its row in Needs attention. */
-  attentionNote: RowNote | null;
 }
 
-/** What a thread's descendants add up to, for its chip and for folding. */
+/** What a thread's descendants add up to, for its chip and folding. */
 export interface Subtree {
   /** Descendants, depth-first in creation order, hidden ones included. */
   descendants: ThreadInfo[];
   /** Union of the descendants' Needs attention flags and working, archived ones left out. */
   flags: ReadonlySet<Flag>;
-  /** Visible descendants: the chip's number. */
+  /** Union of the descendants' `chipFlags`, archived ones left out: the chip's state. */
+  chipFlags: ReadonlySet<Flag>;
+  /** Visible descendants at any depth. */
   visibleCount: number;
+  /** Visible direct children: the chip's number. */
+  childCount: number;
   /** Every visible descendant is quiet, as if no thread were open, so the subtree adds nothing to see when folded. */
   quietIgnoringOpen: boolean;
 }
 
-export interface Family {
+export interface ThreadTree {
   root: ThreadInfo;
   /** Descendants, depth-first in creation order, hidden ones included. */
   descendants: ThreadInfo[];
@@ -73,11 +79,11 @@ export interface Family {
   descendantFlags: ReadonlySet<Flag>;
   /** The same over root and descendants (rollup, folder rows). */
   flags: ReadonlySet<Flag>;
-  /** Needs attention flags over root and descendants: what the section and its order read. */
+  /** Needs attention flags over root and descendants: the tree needs attention when any is set. */
   attentionFlags: ReadonlySet<Flag>;
   /** Visible descendants: the chip's number. */
   visibleDescendantCount: number;
-  /** Largest latestAttentionAt over the family. */
+  /** Largest latestAttentionAt over the tree. */
   latestAttentionAt: number;
   /** Every thread quiet and the active thread not in it. */
   quiet: boolean;
@@ -93,8 +99,8 @@ 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>;
+  trees: readonly ThreadTree[];
+  treeOf: ReadonlyMap<string, ThreadTree>;
   /** The rollup under every thread with a row, by thread id. */
   subtrees: ReadonlyMap<string, Subtree>;
 }
@@ -161,13 +167,13 @@ export function buildForest(inputs: ForestInputs): Forest {
       state,
       unread,
       flags: thread.isHidden ? hiddenThreadFlags(flags) : flags,
+      chipFlags: chipFlagsOf(flags, thread.isHidden),
       attentionFlags: new Set<Flag>(),
       quiet: isQuietThread(state, unread, isActive),
       quietIgnoringOpen: false,
       isActive,
       parentId: attachParent(thread, byId),
       note: rowNote(thread, inputs.notes?.[thread.id]),
-      attentionNote: null,
     });
   }
 
@@ -181,7 +187,6 @@ export function buildForest(inputs: ForestInputs): Forest {
         parent !== undefined &&
         isOrphanedFailure(info.thread, info.flags, { ...parent, finishedAt: inputs.finishedAt[parent.thread.id] }),
     });
-    info.attentionNote = attentionNote(info.thread, inputs.notes?.[info.thread.id], info.attentionFlags);
     info.quietIgnoringOpen =
       parent === undefined || mode === "everything"
         ? isQuietThread(info.state, info.unread, false)
@@ -192,7 +197,7 @@ export function buildForest(inputs: ForestInputs): Forest {
   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.
+      // A hidden thread with no visible ancestor has no row and no tree.
       if (!info.thread.isHidden) roots.push(info);
       continue;
     }
@@ -211,7 +216,9 @@ export function buildForest(inputs: ForestInputs): Forest {
     if (cached !== undefined) return cached;
     const descendants: ThreadInfo[] = [];
     const flags = new Set<Flag>();
+    const chipFlags = new Set<Flag>();
     let visibleCount = 0;
+    let childCount = 0;
     let quietIgnoringOpen = true;
     path.add(id);
     for (const childId of children.get(id) ?? []) {
@@ -222,22 +229,27 @@ export function buildForest(inputs: ForestInputs): Forest {
       if (!child.thread.isArchived) {
         for (const flag of child.attentionFlags) flags.add(flag);
         if (child.flags.has("working")) flags.add("working");
+        for (const flag of child.chipFlags) chipFlags.add(flag);
       }
       for (const flag of below.flags) flags.add(flag);
+      for (const flag of below.chipFlags) chipFlags.add(flag);
       if (child.thread.isHidden ? child.attentionFlags.size > 0 : !child.quietIgnoringOpen) quietIgnoringOpen = false;
-      if (!child.thread.isHidden) visibleCount += 1;
+      if (!child.thread.isHidden) {
+        visibleCount += 1;
+        childCount += 1;
+      }
       visibleCount += below.visibleCount;
       if (!below.quietIgnoringOpen) quietIgnoringOpen = false;
     }
     path.delete(id);
-    const subtree: Subtree = { descendants, flags, visibleCount, quietIgnoringOpen };
+    const subtree: Subtree = { descendants, flags, chipFlags, visibleCount, childCount, quietIgnoringOpen };
     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>();
+  const trees: ThreadTree[] = [];
+  const treeOf = new Map<string, ThreadTree>();
   for (const root of roots) {
     const { descendants, flags: descendantFlags, visibleCount: visibleDescendantCount } = subtrees.get(root.thread.id)!;
     let latestAttentionAt = root.thread.latestAttentionAt;
@@ -254,7 +266,7 @@ export function buildForest(inputs: ForestInputs): Forest {
       } else {
         if (!info.quiet) quiet = false;
         // A child reads as its own fold does, so with `blocked` an unread child
-        // does not keep an old family out of the group's fold.
+        // does not keep an old tree out of the group's fold.
         if (!info.quietIgnoringOpen) quietIgnoringOpen = false;
       }
     }
@@ -266,7 +278,7 @@ export function buildForest(inputs: ForestInputs): Forest {
       }
       if (root.flags.has("working")) flags.add("working");
     }
-    const family: Family = {
+    const tree: ThreadTree = {
       root,
       descendants,
       descendantFlags,
@@ -278,11 +290,11 @@ export function buildForest(inputs: ForestInputs): Forest {
       quietIgnoringOpen,
       containsActive,
     };
-    families.push(family);
-    familyOf.set(root.thread.id, family);
-    for (const info of descendants) familyOf.set(info.thread.id, family);
+    trees.push(tree);
+    treeOf.set(root.thread.id, tree);
+    for (const info of descendants) treeOf.set(info.thread.id, tree);
   }
-  return { infos, children, families, familyOf, subtrees };
+  return { infos, children, trees, treeOf, subtrees };
 }
 
 /** Ids from `id` up to (not including) `stopAt`, nearest first. */