jackherd 1.7.0 → 1.8.0

package/src/plans/layout-summary.ts

@@ -0,0 +1,140 @@
+import { phaseLabel, phaseLabels } from '../plan-format'
+import { fit, padVisible, paint, spread, visibleLength } from '../terminal/text'
+import { textWidth } from '../terminal/width'
+import { deeper, type Frame, joinFrames, nest, prefixed, rowFrame, textFrame } from './frame'
+import type { ActivePhase, LaneSummary } from './lane-summary'
+import {
+  ACTIVE_MARK,
+  COLUMN_SEPARATOR,
+  DEFERRED_MARK,
+  type LaneContext,
+  MIN_TITLE_WIDTH,
+  modelMark,
+  phaseChildren,
+  phaseCountCell,
+  plain,
+  taskFrame,
+} from './layout-phase'
+import { type PhaseModel, phaseModelKey } from './phase-models'
+import { itemKey, phaseKey } from './selection'
+import { PHASE_COUNT } from './symbols'
+import { type HerdTexts, TEXTS } from './texts'
+
+/** The context of a lane's sections: the lane's, with the herd's words. */
+type SummaryContext = LaneContext & { labels: HerdTexts }
+
+/** The label column of the summary's sections, as wide as the widest label and two cells. */
+const sectionWidth = ({ sections }: HerdTexts): number =>
+  Math.max(...Object.values(sections).map(textWidth)) + COLUMN_SEPARATOR.length
+
+/** A frame behind a section label on its first line, its other lines indented to where the content starts. */
+const labelled = (labelWidth: number, label: string, frame: Frame): Frame =>
+  prefixed(frame, { first: padVisible(label, labelWidth), rest: ' '.repeat(labelWidth), style: paint.dim })
+
+/** `· 6 min ago`, dim: when the running phase last moved. */
+const ageCell = ({ minutesAgo }: ActivePhase, labels: HerdTexts): string =>
+  `${paint.dim(labels.minutesAgo(minutesAgo))}${COLUMN_SEPARATOR}`
+
+/**
+ * `▶ P12 <title>   [model]  · 6 min ago   16/26`: title at the left, model, age and count at the right edge. In a pane
+ * too narrow to leave the title `MIN_TITLE_WIDTH` cells, the model gives way first, then the age.
+ */
+const activeRow = (active: ActivePhase, current: boolean, context: SummaryContext, model?: PhaseModel): string => {
+  const { width, labels } = context
+  const { phase } = active
+  const title = phase.title === null ? paint.dim(TEXTS.notInPlan) : plain(phase.title)
+  const head = `${paint.yellow(ACTIVE_MARK)} ${phaseLabel(phase.id)} ${title}`
+  const count = phaseCountCell(phase, current)
+  const withAge = `${ageCell(active, labels)}${count}`
+  const mark = modelMark(model)
+  const candidates = [...(mark ? [`${mark}${COLUMN_SEPARATOR}${withAge}`] : []), withAge]
+  const titleRoom = (right: string) => width - visibleLength(head) + visibleLength(title) - visibleLength(right) - 1
+  return spread(head, candidates.find((right) => titleRoom(right) >= MIN_TITLE_WIDTH) ?? count, width)
+}
+
+/**
+ * `→ <task>` under a closed running phase: the task it is on, dim, on one line whatever the task's fold, and a row a
+ * click opens like the task itself; `→ review gate` in place of a box of the review gate; nothing when no task is open.
+ */
+const taskLineFrame = (context: SummaryContext, phaseRowKey: string, { phase, taskIndex }: ActivePhase): Frame => {
+  const item = taskIndex === null ? undefined : phase.items[taskIndex]
+  if (!item || taskIndex === null) return textFrame([])
+  const text = item.gate ? context.labels.reviewGate : plain(item.text)
+  const underTitle = ' '.repeat(visibleLength(ACTIVE_MARK) + 1)
+  const line = fit(`${underTitle}${paint.dim(`${DEFERRED_MARK} ${text}`)}`, context.width)
+  return taskFrame(itemKey(phaseRowKey, taskIndex), [line], context)
+}
+
+/** A running phase as a row that opens to its tasks; closed, the task it is on below it. */
+const activeFrame = (context: SummaryContext, active: ActivePhase): Frame => {
+  const { progress, state } = context
+  const stepIndex = active.stepIndex ?? -1
+  const key = phaseKey(progress.lane.name, stepIndex, active.phase.id)
+  const current = progress.current?.stepIndex === stepIndex && progress.current.phaseId === active.phase.id
+  const item = active.taskIndex === null ? null : (active.phase.items[active.taskIndex] ?? null)
+  const model = context.models[phaseModelKey(stepIndex, active.phase.id)]
+  const row = rowFrame(key, [activeRow(active, current, context, model)], [], context)
+  if (!state.expanded.has(key)) return joinFrames([row, taskLineFrame(context, key, active)])
+  return joinFrames([row, nest(phaseChildren(deeper(context), key, active.phase, item))])
+}
+
+/** `wave 2: P5 · P10` or, without waves, `P7`. */
+const nextText = ({ next }: LaneSummary, labels: HerdTexts): string =>
+  next ? `${next.wave === null ? '' : `${labels.wave(next.wave)} `}${phaseLabels(next.phaseIds, ' · ')}` : ''
+
+/** `P8 ?` for a named phase the plan lacks, `P9 –` for one without a checkbox. */
+const unwrittenText = ({ id, missing }: LaneSummary['unwritten'][number]): string =>
+  `${phaseLabel(id)} ${paint.dim(missing ? PHASE_COUNT.missing : PHASE_COUNT.empty)}`
+
+/** `P6 P7 P8 ? · Second plan: P1`: the current plan's waiting phases, then the other plans' by their name. */
+const laterText = ({ later, unwritten }: LaneSummary): string => {
+  const own = [
+    ...(later[0]?.planTitle === null ? [phaseLabels(later[0].phaseIds, ' ')] : []),
+    ...unwritten.map(unwrittenText),
+  ]
+  const others = later
+    .filter(({ planTitle }) => planTitle !== null)
+    .map(({ planTitle, phaseIds }) => `${plain((planTitle ?? '').split(':')[0]).trim()}: ${phaseLabels(phaseIds, ' ')}`)
+  return [...(own.length > 0 ? [own.join(' ')] : []), ...others].join(' · ')
+}
+
+/** ` · not merged` once for the line when every finished phase waits for its merge, ` · P1 P2 not merged` when some do. */
+const unmergedNote = ({ finished }: LaneSummary, labels: HerdTexts): string => {
+  const unmerged = finished.filter(({ unmerged }) => unmerged).map(({ id }) => id)
+  if (unmerged.length === 0) return ''
+  const which = unmerged.length === finished.length ? '' : `${phaseLabels(unmerged, ' ')} `
+  return ` · ${paint.yellow(`${which}${labels.notMerged}`)}`
+}
+
+/** `✓ P1 ✓ P4 · not merged` on one line. */
+const finishedText = (summary: LaneSummary, labels: HerdTexts): string => {
+  const phases = summary.finished.map(({ id }) => `${paint.green(PHASE_COUNT.allTicked)} ${phaseLabel(id)}`).join(' ')
+  return phases ? `${phases}${unmergedNote(summary, labels)}` : ''
+}
+
+/** A section with one line of text, cut at the pane's edge; no frame when the text is empty. */
+const textSection = (labelWidth: number, label: string, text: string, width: number): Frame =>
+  text ? labelled(labelWidth, label, textFrame([fit(text, Math.max(width - labelWidth, 1))])) : textFrame([])
+
+/** What an open lane shows above its sections, each drawn at the width its label column leaves. */
+export type LaneHead = { session: (width: number) => string; chips: (width: number) => Frame }
+
+/**
+ * The children of an open lane, each on a branch with its label in one column: SESSION, the 📎 chips, then NOW, NEXT,
+ * LATER and DONE, each section only when it has phases.
+ */
+export const summaryChildren = (context: LaneContext, summary: LaneSummary, head: LaneHead): Frame[] => {
+  const labels = TEXTS.herd
+  const labelWidth = sectionWidth(labels)
+  const inner = { ...context, width: Math.max(context.width - labelWidth, 1), labels }
+  const { sections } = labels
+  const now = summary.active.map((active) => activeFrame(inner, active))
+  return [
+    labelled(labelWidth, sections.session, textFrame([head.session(inner.width)])),
+    labelled(labelWidth, sections.chips, head.chips(inner.width)),
+    ...(now.length > 0 ? [labelled(labelWidth, sections.now, joinFrames(now))] : []),
+    textSection(labelWidth, sections.next, nextText(summary, labels), context.width),
+    textSection(labelWidth, sections.later, laterText(summary), context.width),
+    textSection(labelWidth, sections.done, finishedText(summary, labels), context.width),
+  ]
+}