@kud/jira-ink 0.8.0 → 0.9.0

package/dist/index.d.ts

@@ -2,110 +2,7 @@ import * as react from 'react';
 import { ReactNode } from 'react';
 import { MarkdownTheme } from '@kud/ink-markdown';
 import { Hint } from '@kud/ink-ui';
-import { LocatedAttachment, JiraClient, BoardTab as BoardTab$1, JiraBoardConfiguration, JiraIssue, SearchMode } from '@kud/jira';
-
-/**
- * One issue, as the detail screen reads it: every field already a string, ADF
- * already Markdown, attachments already located. The view never touches a raw
- * `JiraIssue`, so a host that fakes a `JiraClient` for a test or a screenshot
- * gets a screen it can predict, and one that fetched the issue by some other
- * route can build this shape by hand.
- */
-type IssueDetail = {
-    key: string;
-    summary: string;
-    status: string;
-    type: string;
-    assignee: string;
-    reporter: string;
-    labels: string[];
-    /** Jira's priority name, verbatim; absent when the field is off. */
-    priority?: string;
-    parent?: {
-        key: string;
-        summary: string;
-    };
-    url: string;
-    description: string;
-    comments: {
-        id: string;
-        author: string;
-        created: string;
-        body: string;
-    }[];
-    attachments: LocatedAttachment[];
-};
-type Transition = {
-    id: string;
-    name: string;
-    to: string;
-};
-declare const issueDetailOf: (client: JiraClient, baseUrl: string, key: string) => Promise<IssueDetail>;
-declare const transitionsOf: (client: JiraClient, key: string) => Promise<Transition[]>;
-
-type IssueDetailViewProps = {
-    issue: IssueDetail;
-    height: number;
-    width: number;
-    onBack: () => void;
-    /**
-     * The write actions are optional, and a key whose handler is absent is
-     * neither bound nor hinted. A host that only READS — cockpit's ticket drill —
-     * mounts the same screen jira-cli's TUI does, minus the verbs it has no way
-     * to honour, rather than a hint row promising `t` and `c` that do nothing.
-     */
-    onTransition?: () => void;
-    onComment?: () => void;
-    onAssign?: () => void;
-    onOpenBrowser?: () => void;
-    /**
-     * A host that draws its own chrome — a bordered drill frame with the title
-     * on top and the hints pinned at the foot — takes the screen in parts and
-     * places them. The view then draws neither its title line nor its footer,
-     * so nothing appears twice. `height` is still the whole area the host has
-     * given the body, frame excluded.
-     */
-    frame?: (parts: {
-        title: string;
-        subtitle: string;
-        hints: Hint[];
-        body: ReactNode;
-    }) => ReactNode;
-    /** Colours for the Markdown body; a host passes its own tokens so links, code and headings sit in its palette. */
-    theme?: MarkdownTheme;
-};
-declare const IssueDetailView: ({ issue, height, width, onBack, onTransition, onComment, onAssign, onOpenBrowser, frame, theme, }: IssueDetailViewProps) => string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | react.ReactPortal | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | react.JSX.Element | null | undefined;
-
-type IssueBodyProps = {
-    client: JiraClient;
-    /** Instance URL, as `loadConfig` resolves it; only used to build the browser link. */
-    baseUrl: string;
-    issueKey: string;
-    /**
-     * The summary as the host already knows it — from the list row that was
-     * opened — so the frame carries the title from the first frame rather than
-     * only once the fetch answers. The fetched summary wins once it is here.
-     */
-    summary?: string;
-    onExit: () => void;
-    /** Override the terminal-derived size when the host draws inside a frame. */
-    width?: number;
-    height?: number;
-    /** The host's chrome around the screen — see `IssueDetailView`. */
-    frame?: IssueDetailViewProps["frame"];
-    theme?: IssueDetailViewProps["theme"];
-};
-/**
- * The issue screen as a host mounts it: hand it a client and a key, and it
- * fetches, draws and reads its own keys until `onExit`. `JenkinsBody`'s shape,
- * for the same reason — a cockpit mounting a ticket over its list should not
- * have to know how an issue is fetched or what the loading states look like.
- *
- * Read-only by construction. The write verbs (`t`, `c`, `a`) exist on
- * `IssueDetailView` for jira-cli's own TUI, which owns the prompts they need;
- * here they are simply not wired, so the hint row does not offer them.
- */
-declare const IssueBody: ({ client, baseUrl, issueKey, summary, onExit, width, height, frame, theme, }: IssueBodyProps) => string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | react.ReactPortal | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | react.JSX.Element | null | undefined;
+import { BoardTab as BoardTab$1, JiraClient, JiraBoardConfiguration, JiraIssue, LocatedAttachment, SearchMode } from '@kud/jira';
 
 /** Jira's own three, plus `unknown` for a status that arrives without one. */
 type StatusCategory = "new" | "indeterminate" | "done" | "unknown";
@@ -132,6 +29,22 @@ type BoardRow = {
     assignee: string;
     /** ISO timestamp, kept whole so the view can draw a relative age. */
     updated: string;
+    /**
+     * Set when the row's own status lags the evidence — an epic Off board with
+     * a child already started, a task whose PR is ahead of it. The board draws
+     * the word `behind` bright, then this string dim as the reason; pass `""`
+     * when the head's own note already says why. **Presence is the flag, so
+     * test `behind !== undefined`, never `if (row.behind)`.**
+     *
+     * Host-filled, because only the host knows the evidence outside Jira.
+     * `withBehind` fills the two cases the board can see for itself.
+     */
+    behind?: string;
+    /**
+     * A transition in flight: the label of the tab it is moving to, drawn as
+     * `⋯ → QA` until `transitionRow` or `settleRow` clears it.
+     */
+    pending?: string;
 };
 declare const toBoardRow: (issue: JiraIssue) => BoardRow;
 /**
@@ -165,7 +78,44 @@ declare const tabsFromBoard: (configuration: JiraBoardConfiguration) => BoardTab
 declare const tabsFromCategories: () => BoardTabs;
 /** The tab a row belongs to. Nothing ever falls out: unclaimed rows go Off board, or In progress on a category board. */
 declare const tabOf: (row: BoardRow, { tabs }: BoardTabs) => string;
-declare const countsFor: (rows: BoardRow[], tabs: BoardTabs) => Record<string, number>;
+type Placement = {
+    /** The tabs a row is drawn in, in tab order. A container can be in several. */
+    tabsOf: (key: string) => string[];
+    /** The rows the board holds that call this one parent. */
+    childrenOf: (key: string) => BoardRow[];
+};
+/**
+ * Where every row goes, read BOTTOM-UP. A task sits in the tab of its own
+ * status; a container is placed by its CHILDREN, heading a group in each tab
+ * that holds one — so an epic In Development whose tasks are all in Backlog
+ * is absent from In progress and heads them Off board. Its own status never
+ * picks a tab; the board says it in a note instead.
+ *
+ * A container with no children on the board has nothing to be placed under,
+ * and sits Off board rather than claiming a stage tab it is not working in.
+ */
+declare const placementOf: (rows: BoardRow[], tabs: BoardTabs) => Placement;
+/**
+ * The rows one tab draws: the tasks whose own status is here, and the
+ * container heading each of them. One filter does both halves, because a
+ * container's placement already names every tab it has a child in.
+ */
+declare const rowsInTab: (rows: BoardRow[], tabs: BoardTabs, tab: string, placement?: Placement) => BoardRow[];
+/**
+ * The dim segments after a head's summary: its own status when it differs
+ * from this tab, then where the rest of its children are, with counts. Only
+ * rows the board holds are counted — never the epic-children query.
+ */
+declare const headNote: (row: BoardRow, tabs: BoardTabs, tab: string, placement: Placement) => string | undefined;
+/**
+ * Fills `behind` for the two cases the board can see without leaving Jira:
+ * an epic parked Off board while a child has already started, and an epic
+ * still open when every child is Done. Both reasons are left empty — the
+ * head's own note already names the status that lags. A `behind` the host
+ * has already set is never overwritten.
+ */
+declare const withBehind: (rows: BoardRow[], tabs: BoardTabs) => BoardRow[];
+declare const countsFor: (rows: BoardRow[], tabs: BoardTabs, placement?: Placement) => Record<string, number>;
 /** Tabs worth drawing: every configured one, plus Off board only when it holds something. */
 declare const visibleTabs: (tabs: BoardTabs, counts: Record<string, number>) => BoardTab[];
 /**
@@ -176,21 +126,85 @@ declare const visibleTabs: (tabs: BoardTabs, counts: Record<string, number>) =>
  * with no parent — and each group after the first is preceded by a blank
  * line. A tab where nothing has a parent and nothing is a container degrades
  * to a plain list, never to a lone fence.
+ *
+ * A LEAF is something the host hangs under a row that is not a Jira issue —
+ * cockpit hangs a task's pull requests there. The board never looks inside
+ * one: `L` is opaque, the host renders it and opens it. A leaf sits one
+ * level under its row, directly beneath it and before any children, so a
+ * row's subtree is always one contiguous run. Leaves are cursor stops like
+ * issues; fences and gaps never are.
  */
-type Block = {
+type Block<L = never> = {
     kind: "gap";
 } | {
     kind: "fence";
     key: string | null;
     summary: string;
+    parent?: BoardRow;
 } | {
     kind: "issue";
     row: BoardRow;
     depth: 0 | 1;
+} | {
+    kind: "leaf";
+    parent: BoardRow;
+    depth: 1 | 2;
+    data: L;
 };
-declare const blocksFor: (rows: BoardRow[]) => Block[];
-/** Index into `blocks` of the n-th issue, so a cursor over issues maps to a line. */
-declare const blockIndexOfIssue: (blocks: Block[], issueIndex: number) => number;
+type Stop<L = never> = Extract<Block<L>, {
+    kind: "issue" | "leaf";
+}>;
+declare const isStop: <L>(block: Block<L>) => block is Stop<L>;
+/** The rows and leaves in cursor order — what ↑↓ walks and ↵ opens. */
+declare const stopsOf: <L>(blocks: Block<L>[]) => Stop<L>[];
+declare const blocksFor: <L = never>(rows: BoardRow[], under?: (row: BoardRow) => L[], 
+/**
+ * Parents the board holds no row for, looked up by the host — jira with one
+ * extra `key in (…)` search, cockpit with the foreign-epics pass it already
+ * runs. They are never drawn as rows; they tell a fence where its parent is.
+ */
+parents?: BoardRow[]) => Block<L>[];
+/**
+ * What a fence says after the parent's name, and whether it carries `behind`.
+ *
+ * Where the parent IS says it best: a tab label when the reader can press
+ * through and find it, the OWNER when they cannot — `@` being the house glyph
+ * for scope, as in the title bar's `@you`. On a `mine` board those two are
+ * the same question asked twice, so a tab name means yours and `@name` means
+ * not yours, and no fence ever says both. A board showing several assignees
+ * has no such shorthand and always names the owner, as its rows do.
+ *
+ * `behind` is a judgement on someone's own work, so it goes on a fence only
+ * when that someone is the viewer.
+ *
+ * Empty until the lookup lands: a fence that guessed would be wrong for a
+ * frame and then silently correct itself, which is worse than a blank.
+ */
+declare const fenceNote: (parent: BoardRow | undefined, tabs: BoardTabs, { viewer, mine }: {
+    viewer: string;
+    mine: boolean;
+}) => {
+    segment: string;
+    behind: boolean;
+};
+/** Index into `blocks` of the n-th stop, so a cursor over stops maps to a line. */
+declare const blockIndexOfStop: <L>(blocks: Block<L>[], stopIndex: number) => number;
+/**
+ * The tree glyphs to the left of the stop at `i`, three columns per level:
+ * `├─ ` while a sibling still follows, `└─ ` for the last, and ahead of a
+ * depth-2 connector a `│  ` stem while its parent is not last. A `└─` on
+ * every child was tried in gh-ink and rejected — three closing corners in a
+ * column draw no tree at all — which is why last-ness is tracked here
+ * rather than left to the renderer.
+ */
+declare const treePrefix: <L>(blocks: Block<L>[], i: number) => string;
+/**
+ * The block at `i` and everything hanging under it: a row's own leaves, its
+ * children and theirs. Pure, so a host can walk a subtree for every URL in
+ * it (`C` / `O`) without knowing how the tree was laid out. A leaf, a fence
+ * or a gap has no subtree beyond itself.
+ */
+declare const subtreeOf: <L>(blocks: Block<L>[], i: number) => Block<L>[];
 type PriorityGlyph = "⇈" | "↑" | "=" | "↓" | "⇊" | " ";
 /**
  * Rank against the scheme's default rung, in Jira's own arrow grammar: two
@@ -216,6 +230,26 @@ type BoardModel = {
     rows: BoardRow[];
     tabs: BoardTabs;
 };
+/** A transition's target, as Jira gives it: id, name and category together. */
+type TransitionTarget = {
+    id?: string;
+    name: string;
+    category?: StatusCategory;
+};
+/** The label of the tab a status lands in — what `⋯ → QA` names. */
+declare const tabLabelOf: (to: TransitionTarget, tabs: BoardTabs) => string;
+/**
+ * The hybrid move, in three pure steps. The row stays where it is under a
+ * `⋯ → QA` marker while the request is out; on the 204 its status is
+ * rewritten here and the tab follows within the same second, long before the
+ * board refetches — the refetch stays as reconciliation, never as the thing
+ * that makes the move visible. Nothing is optimistic: the row moves because
+ * Jira said it moved.
+ */
+declare const pendingRow: (model: BoardModel, key: string, to: TransitionTarget) => BoardModel;
+declare const transitionRow: (model: BoardModel, key: string, to: TransitionTarget) => BoardModel;
+/** Clears the marker without moving anything — what a rejected move leaves. */
+declare const settleRow: (model: BoardModel, key: string) => BoardModel;
 type BoardOptions = {
     /** Hand-written tabs from the config file — wins over everything. */
     tabs?: BoardTab$1[];
@@ -223,6 +257,16 @@ type BoardOptions = {
     board?: number;
     limit?: number;
 };
+/**
+ * The parents the board holds no row for, in ONE `key in (…)` search — an
+ * epic assigned to someone else, or one that fell outside the window while
+ * its child stayed open. They are never drawn as rows; they are what lets a
+ * fence say whose epic it is, which is the whole of their job here.
+ *
+ * Empty in, empty out, and no call made: a board of unparented rows must not
+ * pay for a search that can only return nothing.
+ */
+declare const parentsOf: (client: JiraClient, rows: BoardRow[]) => Promise<BoardRow[]>;
 /**
  * One assignee-scoped query, bucketed client-side. The board supplies the
  * VOCABULARY, never the population — `getBoardIssues` would drop your
@@ -231,6 +275,119 @@ type BoardOptions = {
  */
 declare const boardOf: (client: JiraClient, jql: string, { tabs, board, limit }?: BoardOptions) => Promise<BoardModel>;
 
+/**
+ * One issue, as the detail screen reads it: every field already a string, ADF
+ * already Markdown, attachments already located. The view never touches a raw
+ * `JiraIssue`, so a host that fakes a `JiraClient` for a test or a screenshot
+ * gets a screen it can predict, and one that fetched the issue by some other
+ * route can build this shape by hand.
+ */
+type IssueDetail = {
+    key: string;
+    summary: string;
+    status: string;
+    type: string;
+    assignee: string;
+    reporter: string;
+    labels: string[];
+    /** Jira's priority name, verbatim; absent when the field is off. */
+    priority?: string;
+    parent?: {
+        key: string;
+        summary: string;
+    };
+    url: string;
+    description: string;
+    comments: {
+        id: string;
+        author: string;
+        created: string;
+        body: string;
+    }[];
+    attachments: LocatedAttachment[];
+};
+/**
+ * A transition and where it lands. `to` carries the whole status — id, name
+ * and category — because a host that must decide which TAB the move ends in
+ * cannot do it from a name: names are per-instance, and matching on one is
+ * how a transition table once silently stopped matching anything.
+ */
+type Transition = {
+    id: string;
+    name: string;
+    to: {
+        id?: string;
+        name: string;
+        category?: StatusCategory;
+    };
+};
+declare const issueDetailOf: (client: JiraClient, baseUrl: string, key: string) => Promise<IssueDetail>;
+declare const transitionsOf: (client: JiraClient, key: string) => Promise<Transition[]>;
+
+type IssueDetailViewProps = {
+    issue: IssueDetail;
+    height: number;
+    width: number;
+    onBack: () => void;
+    /**
+     * The write actions are optional, and a key whose handler is absent is
+     * neither bound nor hinted. A host that only READS — cockpit's ticket drill —
+     * mounts the same screen jira-cli's TUI does, minus the verbs it has no way
+     * to honour, rather than a hint row promising `t` and `c` that do nothing.
+     */
+    onTransition?: () => void;
+    onComment?: () => void;
+    onAssign?: () => void;
+    onOpenBrowser?: () => void;
+    /**
+     * A host that draws its own chrome — a bordered drill frame with the title
+     * on top and the hints pinned at the foot — takes the screen in parts and
+     * places them. The view then draws neither its title line nor its footer,
+     * so nothing appears twice. `height` is still the whole area the host has
+     * given the body, frame excluded.
+     */
+    frame?: (parts: {
+        title: string;
+        subtitle: string;
+        hints: Hint[];
+        body: ReactNode;
+    }) => ReactNode;
+    /** Colours for the Markdown body; a host passes its own tokens so links, code and headings sit in its palette. */
+    theme?: MarkdownTheme;
+};
+declare const IssueDetailView: ({ issue, height, width, onBack, onTransition, onComment, onAssign, onOpenBrowser, frame, theme, }: IssueDetailViewProps) => string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | react.ReactPortal | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | react.JSX.Element | null | undefined;
+
+type IssueBodyProps = {
+    client: JiraClient;
+    /** Instance URL, as `loadConfig` resolves it; only used to build the browser link. */
+    baseUrl: string;
+    issueKey: string;
+    /**
+     * The summary as the host already knows it — from the list row that was
+     * opened — so the frame carries the title from the first frame rather than
+     * only once the fetch answers. The fetched summary wins once it is here.
+     */
+    summary?: string;
+    onExit: () => void;
+    /** Override the terminal-derived size when the host draws inside a frame. */
+    width?: number;
+    height?: number;
+    /** The host's chrome around the screen — see `IssueDetailView`. */
+    frame?: IssueDetailViewProps["frame"];
+    theme?: IssueDetailViewProps["theme"];
+};
+/**
+ * The issue screen as a host mounts it: hand it a client and a key, and it
+ * fetches, draws and reads its own keys until `onExit`. `JenkinsBody`'s shape,
+ * for the same reason — a cockpit mounting a ticket over its list should not
+ * have to know how an issue is fetched or what the loading states look like.
+ *
+ * Read-only by construction. The write verbs (`t`, `c`, `a`) exist on
+ * `IssueDetailView` for jira-cli's own TUI, which owns the prompts they need;
+ * here they are simply not wired, so the hint row does not offer them.
+ */
+declare const IssueBody: ({ client, baseUrl, issueKey, summary, onExit, width, height, frame, theme, }: IssueBodyProps) => string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | react.ReactPortal | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | react.JSX.Element | null | undefined;
+
 /** What the board is showing, named in the title row. */
 type BoardScope = {
     kind: "mine";
@@ -239,8 +396,31 @@ type BoardScope = {
     query: string;
     mode: "jql" | "text";
 };
-type IssueBoardProps = {
+/**
+ * What a host hangs under rows that is not a Jira issue — cockpit hangs a
+ * task's pull requests. The board draws the cursor marker and the tree cell
+ * and hands the rest of the line to `render`; `width` is the columns left
+ * after those, so the renderer can truncate honestly. `L` never reaches
+ * the board's own logic: this package stays Jira-only.
+ */
+type BoardLeaves<L> = {
+    under: (row: BoardRow) => L[];
+    keyOf: (leaf: L) => string;
+    render: (leaf: L, ctx: {
+        active: boolean;
+        width: number;
+    }) => ReactNode;
+    onOpen: (leaf: L) => void;
+};
+type IssueBoardProps<L = never> = {
     model: BoardModel;
+    leaves?: BoardLeaves<L>;
+    /**
+     * Parents the board holds no row for, so a fence can say where its parent
+     * is. Absent until the lookup lands, which leaves the fence bare rather
+     * than guessing.
+     */
+    parents?: BoardRow[];
     /** Who the `mine` scope belongs to, for the title row. */
     viewer: string;
     loadedAt: number;
@@ -297,7 +477,7 @@ type IssueBoardProps = {
  * host — only the keys that open and close the layers it pushes itself: the
  * search input and the legend.
  */
-declare const IssueBoard: ({ model, viewer, loadedAt, scope, showingAll, searchError, width, height, onOpen, onToggleAll, onRefresh, onSearch, onClearSearch, frame, onInputFocus, }: IssueBoardProps) => string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | react.ReactPortal | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | react.JSX.Element | null | undefined;
+declare const IssueBoard: <L = never>({ model, leaves, parents, viewer, loadedAt, scope, showingAll, searchError, width, height, onOpen, onToggleAll, onRefresh, onSearch, onClearSearch, frame, onInputFocus, }: IssueBoardProps<L>) => string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | react.ReactPortal | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | react.JSX.Element | null | undefined;
 
 type PriorityMarker = {
     /** Always one column wide, so a list filling every row keeps its grid. */
@@ -322,4 +502,4 @@ declare const priorityMarker: (name: string | null) => PriorityMarker;
 declare const MOCK_BOARD_ROWS: BoardRow[];
 declare const mockBoard: () => BoardModel;
 
-export { type Block, type BoardModel, type BoardOptions, type BoardRow, type BoardScope, type BoardTab, type BoardTabs, IssueBoard, type IssueBoardProps, IssueBody, type IssueBodyProps, type IssueDetail, IssueDetailView, type IssueDetailViewProps, MOCK_BOARD_ROWS, OFF_BOARD, type PriorityGlyph, type PriorityMarker, type StatusCategory, type TabSource, type Transition, blockIndexOfIssue, blocksFor, boardOf, countsFor, issueDetailOf, mockBoard, pillVariantFor, priorityGlyph, priorityMarker, relativeAge, tabOf, tabsFromBoard, tabsFromCategories, tabsFromConfig, toBoardRow, transitionsOf, visibleTabs };
+export { type Block, type BoardLeaves, type BoardModel, type BoardOptions, type BoardRow, type BoardScope, type BoardTab, type BoardTabs, IssueBoard, type IssueBoardProps, IssueBody, type IssueBodyProps, type IssueDetail, IssueDetailView, type IssueDetailViewProps, MOCK_BOARD_ROWS, OFF_BOARD, type Placement, type PriorityGlyph, type PriorityMarker, type StatusCategory, type Stop, type TabSource, type Transition, type TransitionTarget, blockIndexOfStop, blocksFor, boardOf, countsFor, fenceNote, headNote, isStop, issueDetailOf, mockBoard, parentsOf, pendingRow, pillVariantFor, placementOf, priorityGlyph, priorityMarker, relativeAge, rowsInTab, settleRow, stopsOf, subtreeOf, tabLabelOf, tabOf, tabsFromBoard, tabsFromCategories, tabsFromConfig, toBoardRow, transitionRow, transitionsOf, treePrefix, visibleTabs, withBehind };

package/dist/index.js

@@ -2,7 +2,7 @@ import { MarkdownViewport } from '@kud/ink-markdown';
 import { colors, KeyValue, Badge, FooterHints, StatusMessage, useTabs, useListCursor, pillWidth, TextInput, Tabs, SelectableRow, Pill, LoadingScreen } from '@kud/ink-ui';
 import { useInput, Box, Text, useStdout } from 'ink';
 import { useState, useEffect, useMemo } from 'react';
-import { isContainerType, locateAttachments, adfToMarkdown, looksLikeJql } from '@kud/jira';
+import { isContainerType, jqlEscape, locateAttachments, adfToMarkdown, looksLikeJql } from '@kud/jira';
 import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
 import { exec } from 'child_process';
 
@@ -74,19 +74,89 @@ var tabOf = (row, { tabs }) => {
   if (byCategory) return byCategory.value;
   return tabs.find((t) => t.offBoard)?.value ?? "doing";
 };
-var countsFor = (rows, tabs) => {
+var offBoardValue = (tabs) => tabs.tabs.find((t) => t.offBoard)?.value;
+var placementOf = (rows, tabs) => {
+  const children = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    if (row.container) continue;
+    const key = row.parent?.key;
+    if (key) children.set(key, [...children.get(key) ?? [], row]);
+  }
+  const order = new Map(tabs.tabs.map((t, i) => [t.value, i]));
+  const placed = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    if (!row.container) {
+      placed.set(row.key, [tabOf(row, tabs)]);
+      continue;
+    }
+    const where = [
+      ...new Set((children.get(row.key) ?? []).map((k) => tabOf(k, tabs)))
+    ].sort((a, b) => (order.get(a) ?? 0) - (order.get(b) ?? 0));
+    placed.set(
+      row.key,
+      where.length ? where : [offBoardValue(tabs) ?? tabOf(row, tabs)]
+    );
+  }
+  return {
+    tabsOf: (key) => placed.get(key) ?? [],
+    childrenOf: (key) => children.get(key) ?? []
+  };
+};
+var rowsInTab = (rows, tabs, tab, placement = placementOf(rows, tabs)) => rows.filter((r) => placement.tabsOf(r.key).includes(tab));
+var headNote = (row, tabs, tab, placement) => {
+  if (!row.container) return void 0;
+  const labelOf = (value) => tabs.tabs.find((t) => t.value === value)?.label ?? "";
+  const own = tabOf(row, tabs);
+  const segments = own === tab ? [] : [`own ${labelOf(own)}`];
+  const elsewhere = /* @__PURE__ */ new Map();
+  for (const kid of placement.childrenOf(row.key)) {
+    const where = tabOf(kid, tabs);
+    if (where !== tab) elsewhere.set(where, (elsewhere.get(where) ?? 0) + 1);
+  }
+  for (const t of tabs.tabs) {
+    const n = elsewhere.get(t.value);
+    if (n) segments.push(`${n} ${t.label}`);
+  }
+  return segments.length ? segments.join(" \xB7 ") : void 0;
+};
+var withBehind = (rows, tabs) => {
+  const placement = placementOf(rows, tabs);
+  const off = offBoardValue(tabs);
+  return rows.map((row) => {
+    if (!row.container || row.behind !== void 0) return row;
+    const kids = placement.childrenOf(row.key);
+    if (kids.length === 0) return row;
+    const started = kids.some((k) => k.category !== "new");
+    const allDone = kids.every((k) => k.category === "done");
+    const lags = off !== void 0 && tabOf(row, tabs) === off && started || row.category !== "done" && allDone;
+    return lags ? { ...row, behind: "" } : row;
+  });
+};
+var countsFor = (rows, tabs, placement = placementOf(rows, tabs)) => {
   const counts = Object.fromEntries(
     tabs.tabs.map((t) => [t.value, 0])
   );
   for (const row of rows)
-    counts[tabOf(row, tabs)] = (counts[tabOf(row, tabs)] ?? 0) + 1;
+    for (const tab of placement.tabsOf(row.key))
+      counts[tab] = (counts[tab] ?? 0) + 1;
   return counts;
 };
 var visibleTabs = (tabs, counts) => tabs.tabs.filter((t) => !t.offBoard || (counts[t.value] ?? 0) > 0);
-var blocksFor = (rows) => {
+var isStop = (block) => block.kind === "issue" || block.kind === "leaf";
+var stopsOf = (blocks) => blocks.filter(isStop);
+var blocksFor = (rows, under, parents) => {
+  const known = new Map((parents ?? []).map((p) => [p.key, p]));
+  const withLeaves = (row, depth) => [
+    { kind: "issue", row, depth },
+    ...(under?.(row) ?? []).map((data) => ({
+      kind: "leaf",
+      parent: row,
+      depth: depth === 0 ? 1 : 2,
+      data
+    }))
+  ];
   const hasStructure = rows.some((r) => r.parent || r.container);
-  if (!hasStructure)
-    return rows.map((row) => ({ kind: "issue", row, depth: 0 }));
+  if (!hasStructure) return rows.flatMap((row) => withLeaves(row, 0));
   const heads = new Map(rows.filter((r) => r.container).map((r) => [r.key, r]));
   const children = /* @__PURE__ */ new Map();
   const orphans = [];
@@ -102,36 +172,80 @@ var blocksFor = (rows) => {
   const groups = [];
   for (const [key, head] of heads)
     groups.push([
-      { kind: "issue", row: head, depth: 0 },
-      ...(children.get(key) ?? []).map((row) => ({
-        kind: "issue",
-        row,
-        depth: 1
-      }))
+      ...withLeaves(head, 0),
+      ...(children.get(key) ?? []).flatMap((row) => withLeaves(row, 1))
     ]);
   for (const [key, kids] of children) {
     if (heads.has(key)) continue;
+    const parent = known.get(key);
     groups.push([
-      { kind: "fence", key, summary: kids[0].parent?.summary ?? "" },
-      ...kids.map((row) => ({ kind: "issue", row, depth: 1 }))
+      {
+        kind: "fence",
+        key,
+        summary: kids[0].parent?.summary ?? "",
+        ...parent ? { parent } : {}
+      },
+      ...kids.flatMap((row) => withLeaves(row, 1))
     ]);
   }
   if (orphans.length)
     groups.push([
       ...groups.length ? [{ kind: "fence", key: null, summary: "No epic" }] : [],
-      ...orphans.map((row) => ({ kind: "issue", row, depth: 0 }))
+      ...orphans.flatMap((row) => withLeaves(row, 0))
     ]);
   return groups.flatMap(
     (group, i) => i === 0 ? group : [{ kind: "gap" }, ...group]
   );
 };
-var blockIndexOfIssue = (blocks, issueIndex) => {
+var firstName = (assignee) => assignee === "unassigned" ? "unassigned" : `@${assignee.split(" ")[0]}`;
+var fenceNote = (parent, tabs, { viewer, mine }) => {
+  if (!parent) return { segment: "", behind: false };
+  const theirs = parent.assignee !== viewer;
+  if (!mine || theirs)
+    return { segment: firstName(parent.assignee), behind: false };
+  const own = tabOf(parent, tabs);
+  return {
+    segment: tabs.tabs.find((t) => t.value === own)?.label ?? "",
+    behind: parent.behind !== void 0
+  };
+};
+var blockIndexOfStop = (blocks, stopIndex) => {
   let seen = -1;
   for (let i = 0; i < blocks.length; i++) {
-    if (blocks[i].kind === "issue" && ++seen === issueIndex) return i;
+    if (isStop(blocks[i]) && ++seen === stopIndex) return i;
   }
   return 0;
 };
+var isLastAtDepth = (blocks, i) => {
+  const depth = blocks[i].depth;
+  for (let j = i + 1; j < blocks.length; j++) {
+    const b = blocks[j];
+    if (!isStop(b) || b.depth < depth) return true;
+    if (b.depth === depth) return false;
+  }
+  return true;
+};
+var treePrefix = (blocks, i) => {
+  const block = blocks[i];
+  if (!block || !isStop(block) || block.depth === 0) return "";
+  const own = isLastAtDepth(blocks, i) ? "\u2514\u2500 " : "\u251C\u2500 ";
+  if (block.depth === 1) return own;
+  let parent = i - 1;
+  while (parent >= 0 && blocks[parent].depth !== 1) parent -= 1;
+  const stem = parent >= 0 && !isLastAtDepth(blocks, parent) ? "\u2502  " : "   ";
+  return stem + own;
+};
+var subtreeOf = (blocks, i) => {
+  const head = blocks[i];
+  if (!head || head.kind !== "issue") return head ? [head] : [];
+  const out = [head];
+  for (let j = i + 1; j < blocks.length; j++) {
+    const b = blocks[j];
+    if (!isStop(b) || b.depth <= head.depth) break;
+    out.push(b);
+  }
+  return out;
+};
 var priorityGlyph = (name) => {
   const n = (name ?? "").trim().toLowerCase();
   if (/^(highest|blocker|critical|p[01])$/.test(n)) return "\u21C8";
@@ -166,6 +280,46 @@ var pillVariantFor = (row) => {
   if (t === "story") return "info";
   return "muted";
 };
+var tabLabelOf = (to, tabs) => {
+  const value = tabOf(
+    {
+      status: to.name,
+      statusId: to.id ?? "",
+      category: to.category ?? "unknown"
+    },
+    tabs
+  );
+  return tabs.tabs.find((t) => t.value === value)?.label ?? to.name;
+};
+var mapRow = (model, key, f) => ({
+  ...model,
+  rows: model.rows.map((row) => row.key === key ? f(row) : row)
+});
+var pendingRow = (model, key, to) => mapRow(model, key, (row) => ({
+  ...row,
+  pending: tabLabelOf(to, model.tabs)
+}));
+var transitionRow = (model, key, to) => mapRow(model, key, ({ pending: _, ...row }) => ({
+  ...row,
+  status: to.name,
+  statusId: to.id ?? "",
+  category: to.category ?? "unknown"
+}));
+var settleRow = (model, key) => mapRow(model, key, ({ pending: _, ...row }) => row);
+var parentsOf = async (client, rows) => {
+  const held = new Set(rows.map((r) => r.key));
+  const missing = [
+    ...new Set(
+      rows.map((r) => r.parent?.key).filter((key) => key !== void 0 && !held.has(key))
+    )
+  ];
+  if (missing.length === 0) return [];
+  const issues = await client.searchIssues(
+    `key in (${missing.map(jqlEscape).join(", ")})`,
+    { limit: missing.length }
+  );
+  return issues.map(toBoardRow);
+};
 var boardOf = async (client, jql, { tabs, board, limit = 200 } = {}) => {
   const [issues, derived] = await Promise.all([
     client.searchIssues(jql, { limit }),
@@ -358,7 +512,11 @@ var issueDetailOf = async (client, baseUrl, key) => {
 var transitionsOf = async (client, key) => (await client.getTransitions(key)).transitions.map((t) => ({
   id: t.id,
   name: t.name,
-  to: t.to?.name ?? t.name
+  to: {
+    ...t.to?.id ? { id: t.to.id } : {},
+    name: t.to?.name ?? t.name,
+    ...t.to?.statusCategory?.key ? { category: categoryOf(t.to.statusCategory.key) } : {}
+  }
 }));
 var useTermSize = () => {
   const { stdout } = useStdout();
@@ -435,12 +593,13 @@ var IssueBody = ({
   );
 };
 var CHROME = 6;
+var ROW_CHROME = 7;
 var LEGEND = [
   ["\u21C8 \u2191", "priority above the default"],
   ["=", "default priority"],
   ["\u2193 \u21CA", "priority below the default"],
   ["\u2500\u2500 epic \u2500\u2500", "a parent not in this tab; its rows hang beneath"],
-  ["\u2514\u2500", "a row under the container above it"],
+  ["\u251C\u2500 \u2514\u2500", "a row under the container above it; \u2514\u2500 is the last"],
   ["story \xB7 bug \xB7 task", "issue type"],
   ["2d", "time since last update"]
 ];
@@ -460,8 +619,21 @@ var tabLegendLine = (model) => model.tabs.source === "categories" ? [
   "To do \xB7 In progress \xB7 Done",
   "status category \u2014 not any one board's column"
 ] : model.tabs.source === "board" ? ["tabs", "this board's own columns, matched by status id"] : ["tabs", "your config file's tabs"];
+var RowNote = ({ row, note }) => {
+  if (row.pending)
+    return /* @__PURE__ */ jsx(Box, { flexShrink: 0, paddingLeft: 1, children: /* @__PURE__ */ jsx(Text, { color: colors.accent, children: `\u22EF \u2192 ${row.pending}` }) });
+  const behind = row.behind !== void 0;
+  const dim = [row.behind || "", note ?? ""].filter(Boolean).join(" \xB7 ");
+  if (!behind && !dim) return null;
+  return /* @__PURE__ */ jsxs(Box, { flexShrink: 0, paddingLeft: 1, children: [
+    behind ? /* @__PURE__ */ jsx(Text, { color: colors.warning, bold: true, children: "behind" }) : null,
+    dim ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: (behind ? " \xB7 " : "") + dim }) : null
+  ] });
+};
 var IssueBoard = ({
   model,
+  leaves,
+  parents,
   viewer,
   loadedAt,
   scope,
@@ -499,7 +671,11 @@ var IssueBoard = ({
       (r) => `${r.key} ${r.summary}`.toLowerCase().includes(words)
     );
   }, [model.rows, search]);
-  const counts = countsFor(narrowed, model.tabs);
+  const placement = useMemo(
+    () => placementOf(narrowed, model.tabs),
+    [narrowed, model.tabs]
+  );
+  const counts = countsFor(narrowed, model.tabs, placement);
   const shown = visibleTabs(model.tabs, counts);
   const tabItems = shown.map((t) => ({
     value: t.value,
@@ -513,18 +689,26 @@ var IssueBoard = ({
     isActive: listFocused
   });
   const tab = active ?? initial ?? "";
+  const under = leaves?.under;
   const blocks = useMemo(
-    () => blocksFor(narrowed.filter((r) => tabOf(r, model.tabs) === tab)),
-    [narrowed, model.tabs, tab]
-  );
-  const issues = blocks.filter(
-    (b) => b.kind === "issue"
+    () => blocksFor(
+      rowsInTab(narrowed, model.tabs, tab, placement),
+      under,
+      parents
+    ),
+    [narrowed, model.tabs, tab, placement, under, parents]
   );
-  const { cursor, setCursor } = useListCursor(issues.length, {
+  const stops = stopsOf(blocks);
+  const { cursor, setCursor } = useListCursor(stops.length, {
     vimKeys: true,
     isActive: listFocused
   });
   useEffect(() => setCursor(0), [tab, setCursor]);
+  const openStop = (stop) => {
+    if (!stop) return;
+    if (stop.kind === "issue") onOpen(stop.row.key);
+    else leaves?.onOpen(stop.data);
+  };
   useInput((input, key) => {
     if (search.open) {
       if (key.escape) setSearch((s) => ({ ...s, open: false }));
@@ -539,7 +723,7 @@ var IssueBoard = ({
       if (input === "?" || key.escape) setLegend(false);
       return;
     }
-    if (key.return && issues[cursor]) onOpen(issues[cursor].row.key);
+    if (key.return) openStop(stops[cursor]);
     if (input === "/")
       setSearch((s) => ({
         ...s,
@@ -554,7 +738,7 @@ var IssueBoard = ({
   const searching = search.open || scope.kind === "search";
   const chrome = CHROME + (searching ? 1 : 0) + (searchError ? 1 : 0);
   const size = Math.max(3, height - chrome);
-  const focus = blockIndexOfIssue(blocks, cursor);
+  const focus = blockIndexOfStop(blocks, cursor);
   const { start, end } = windowFor(focus, blocks.length, size);
   const keyWidth = Math.max(8, ...narrowed.map((r) => r.key.length));
   const typeWidth = Math.max(
@@ -625,20 +809,61 @@ var IssueBoard = ({
     /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginTop: 1, height: size, paddingRight: 1, children: legend ? [...LEGEND, tabLegendLine(model)].map(([glyph, meaning]) => /* @__PURE__ */ jsxs(Box, { paddingLeft: 4, children: [
       /* @__PURE__ */ jsx(Box, { width: 28, flexShrink: 0, children: /* @__PURE__ */ jsx(Text, { color: colors.accent, children: glyph }) }),
       /* @__PURE__ */ jsx(Text, { dimColor: true, children: meaning })
-    ] }, glyph)) : issues.length === 0 ? /* @__PURE__ */ jsx(Box, { paddingLeft: 4, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: emptyHint() }) }) : blocks.slice(start, end).map(
-      (block, i) => block.kind === "gap" ? /* @__PURE__ */ jsx(Text, { children: " " }, `gap:${start + i}`) : block.kind === "fence" ? /* @__PURE__ */ jsx(Box, { paddingLeft: 4, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: rule(
-        block.key ? `${block.summary} \xB7 ${block.key}` : block.summary,
-        width - 7
-      ) }) }, `f:${block.key ?? "none"}`) : /* @__PURE__ */ jsxs(SelectableRow, { active: start + i === focus, children: [
-        block.depth === 1 ? /* @__PURE__ */ jsx(Box, { flexShrink: 0, width: 3, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2514\u2500 " }) }) : null,
+    ] }, glyph)) : stops.length === 0 ? /* @__PURE__ */ jsx(Box, { paddingLeft: 4, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: emptyHint() }) }) : blocks.slice(start, end).map((block, i) => {
+      const at = start + i;
+      const focused = at === focus;
+      const prefix = treePrefix(blocks, at);
+      return block.kind === "gap" ? /* @__PURE__ */ jsx(Text, { children: " " }, `gap:${at}`) : block.kind === "fence" ? (() => {
+        const { segment, behind } = fenceNote(
+          block.parent,
+          model.tabs,
+          {
+            viewer,
+            mine: scope.kind === "mine"
+          }
+        );
+        const tail = [behind ? "behind" : "", segment].filter(Boolean).join(" \xB7 ");
+        const label = block.key ? `${block.summary} \xB7 ${block.key}` : block.summary;
+        return /* @__PURE__ */ jsxs(Box, { paddingLeft: 4, children: [
+          /* @__PURE__ */ jsx(Text, { dimColor: true, children: rule(
+            label,
+            width - ROW_CHROME - (tail ? tail.length + 1 : 0)
+          ) }),
+          tail ? /* @__PURE__ */ jsxs(Box, { flexShrink: 0, paddingLeft: 1, children: [
+            behind ? /* @__PURE__ */ jsx(Text, { color: colors.warning, bold: true, children: "behind" }) : null,
+            /* @__PURE__ */ jsx(Text, { dimColor: true, children: (behind ? " \xB7 " : "") + segment })
+          ] }) : null
+        ] }, `f:${block.key ?? "none"}`);
+      })() : block.kind === "leaf" ? /* @__PURE__ */ jsxs(
+        SelectableRow,
+        {
+          active: focused,
+          children: [
+            /* @__PURE__ */ jsx(Box, { flexShrink: 0, width: prefix.length, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: prefix }) }),
+            leaves?.render(block.data, {
+              active: focused,
+              width: width - ROW_CHROME - prefix.length
+            })
+          ]
+        },
+        `leaf:${block.parent.key}:${leaves?.keyOf(block.data)}`
+      ) : /* @__PURE__ */ jsxs(SelectableRow, { active: focused, children: [
+        prefix ? /* @__PURE__ */ jsx(Box, { flexShrink: 0, width: prefix.length, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: prefix }) }) : null,
         /* @__PURE__ */ jsx(Box, { flexShrink: 0, width: 2, children: /* @__PURE__ */ jsx(Text, { color: priorityMarker(block.row.priority).color, children: priorityMarker(block.row.priority).marker }) }),
-        /* @__PURE__ */ jsx(Box, { flexShrink: 0, width: keyWidth + 2, children: /* @__PURE__ */ jsx(Text, { color: colors.accent, bold: start + i === focus, children: block.row.key }) }),
+        /* @__PURE__ */ jsx(Box, { flexShrink: 0, width: keyWidth + 2, children: /* @__PURE__ */ jsx(Text, { color: colors.accent, bold: focused, children: block.row.key }) }),
         /* @__PURE__ */ jsx(Box, { flexShrink: 0, width: typeWidth + 2, children: /* @__PURE__ */ jsx(Pill, { tone: "soft", variant: pillVariantFor(block.row), children: block.row.type.toLowerCase() }) }),
-        /* @__PURE__ */ jsx(Box, { flexGrow: 1, children: /* @__PURE__ */ jsx(Text, { wrap: "truncate-end", bold: start + i === focus, children: block.row.summary }) }),
+        /* @__PURE__ */ jsx(Box, { flexGrow: 1, children: /* @__PURE__ */ jsx(Text, { wrap: "truncate-end", bold: focused, children: block.row.summary }) }),
+        /* @__PURE__ */ jsx(
+          RowNote,
+          {
+            row: block.row,
+            note: headNote(block.row, model.tabs, tab, placement)
+          }
+        ),
         /* @__PURE__ */ jsx(Box, { flexShrink: 0, width: 5, justifyContent: "flex-end", children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: relativeAge(block.row.updated, now) }) })
-      ] }, block.row.key)
-    ) }),
-    /* @__PURE__ */ jsx(Box, { marginTop: 1, paddingLeft: 2, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: issues.length ? `${cursor + 1}/${issues.length}` : " " }) })
+      ] }, block.row.key);
+    }) }),
+    /* @__PURE__ */ jsx(Box, { marginTop: 1, paddingLeft: 2, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: stops.length ? `${cursor + 1}/${stops.length}` : " " }) })
   ] });
   if (frame) return frame({ facts, title, hints, body });
   return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
@@ -747,4 +972,4 @@ var mockBoard = () => ({
   tabs: tabsFromCategories()
 });
 
-export { IssueBoard, IssueBody, IssueDetailView, MOCK_BOARD_ROWS, OFF_BOARD, blockIndexOfIssue, blocksFor, boardOf, countsFor, issueDetailOf, mockBoard, pillVariantFor, priorityGlyph, priorityMarker, relativeAge, tabOf, tabsFromBoard, tabsFromCategories, tabsFromConfig, toBoardRow, transitionsOf, visibleTabs };
+export { IssueBoard, IssueBody, IssueDetailView, MOCK_BOARD_ROWS, OFF_BOARD, blockIndexOfStop, blocksFor, boardOf, countsFor, fenceNote, headNote, isStop, issueDetailOf, mockBoard, parentsOf, pendingRow, pillVariantFor, placementOf, priorityGlyph, priorityMarker, relativeAge, rowsInTab, settleRow, stopsOf, subtreeOf, tabLabelOf, tabOf, tabsFromBoard, tabsFromCategories, tabsFromConfig, toBoardRow, transitionRow, transitionsOf, treePrefix, visibleTabs, withBehind };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kud/jira-ink",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Ink components for viewing Jira issues: the board and the issue detail screen, shared by jira-cli's TUI and cockpit",
   "type": "module",
   "main": "dist/index.js",