@gperezmz/bb-plugin-thread-glance 0.2.3 → 0.3.0

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,
+  dotFlagsOf,
   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 child dot of the threads above it (see `dotFlagsOf`). */
+  dotFlags: 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, its child dot 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' `dotFlags`, archived ones left out: the child dot. */
+  dotFlags: 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,
+      dotFlags: dotFlagsOf(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 dotFlags = 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.dotFlags) dotFlags.add(flag);
       }
       for (const flag of below.flags) flags.add(flag);
+      for (const flag of below.dotFlags) dotFlags.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, dotFlags, 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. */