@herbertgao/pi-extensions 2026.9.6 → 2026.9.8

package/node_modules/grok-mermaid/src/source-box.ts

@@ -0,0 +1,89 @@
+/**
+ * The raw source in a framed box.
+ *
+ * What to show when `render` returns `null`, or returns art too wide for the
+ * space at hand. Both are the caller's call, so this is theirs to invoke — and
+ * theirs to caption, since only they know whether some other view of the
+ * diagram exists to point the reader at.
+ */
+
+import { srcLines, stripControls } from './labels.ts'
+import type { MermaidArt, Span } from './types.ts'
+import { measured, stringWidth } from './width.ts'
+
+const sat = (a: number, b: number): number => Math.max(0, a - b)
+
+/**
+ * Frame `src` in a titled box, hard-wrapping its lines to `maxWidth` columns.
+ *
+ * The result can still exceed `maxWidth`: the body wraps to
+ * `max(8, maxWidth - 4)` and the ` mermaid: <kind> ` title is never truncated,
+ * so a long first token sets a floor. Check `width` if it matters.
+ */
+export function sourceBox(src: string, maxWidth?: number): MermaidArt {
+  src = stripControls(src)
+  const header = src.split(/\s+/).filter((w) => w !== '')[0] ?? 'diagram'
+  const title = ` mermaid: ${header} `
+  const limit = maxWidth === undefined ? undefined : Math.max(8, sat(maxWidth, 4))
+
+  const body = srcLines(src)
+    .map((l) => l.replace(/\s+$/, ''))
+    .reduce<{ started: boolean; lines: string[] }>(
+      (acc, l) => {
+        if (!acc.started && l === '') return acc
+        acc.started = true
+        acc.lines.push(...chunkLine(l, limit))
+        return acc
+      },
+      { started: false, lines: [] },
+    ).lines
+
+  const contentW = Math.max(stringWidth(title), ...body.map(stringWidth), 0)
+  const inner = contentW + 2
+
+  const plain: string[] = []
+  const styled: Span[][] = []
+
+  const rule = '─'.repeat(sat(inner, stringWidth(title)))
+  plain.push(`╭${title}${rule}╮`)
+  styled.push([
+    { text: '╭', cls: 'border' },
+    { text: title, cls: 'title' },
+    { text: `${rule}╮`, cls: 'border' },
+  ])
+
+  for (const line of body) {
+    const pad = ' '.repeat(sat(contentW, stringWidth(line)))
+    plain.push(`│ ${line}${pad} │`)
+    styled.push([
+      { text: '│ ', cls: 'border' },
+      { text: line, cls: 'text' },
+      { text: `${pad} │`, cls: 'border' },
+    ])
+  }
+
+  const bottom = `╰${'─'.repeat(inner)}╯`
+  plain.push(bottom)
+  styled.push([{ text: bottom, cls: 'border' }])
+
+  return { plain, styled, width: inner + 2, warnings: [] }
+}
+
+/** Hard-break a line at `limit` columns, never splitting a wide glyph. */
+function chunkLine(line: string, limit: number | undefined): string[] {
+  if (limit === undefined || stringWidth(line) <= limit) return [line]
+  const out: string[] = []
+  let cur = ''
+  let curW = 0
+  for (const [c, cw] of measured(line)) {
+    if (curW + cw > limit && cur !== '') {
+      out.push(cur)
+      cur = ''
+      curW = 0
+    }
+    cur += c
+    curW += cw
+  }
+  if (cur !== '') out.push(cur)
+  return out
+}

package/node_modules/grok-mermaid/src/types.ts

@@ -0,0 +1,43 @@
+/**
+ * Semantic class of a run of cells. The renderer never knows about colour;
+ * consumers map these to their own theme (see `toAnsi` for the common case).
+ *
+ * - `border`     box outlines, subgraph frames, compartment rules
+ * - `text`       node / participant / compartment labels
+ * - `edge`       connector lines and arrowheads
+ * - `edgeLabel`  text sitting on an edge
+ * - `title`      the `mermaid: <kind>` header of a source box
+ * - `none`       blank filler
+ */
+export type Cls = 'border' | 'text' | 'edge' | 'edgeLabel' | 'title' | 'none'
+
+/** A run of adjacent cells sharing one semantic class. */
+export interface Span {
+  text: string
+  cls: Cls
+}
+
+/**
+ * A rendered diagram. `plain[i]` and `styled[i]` describe the same row:
+ * `plain` is right-trimmed for display width and copy/paste, `styled` keeps
+ * the run structure needed to colour it.
+ *
+ * `width` is the display columns the widest row needs — the number to compare
+ * against the space you have. It cannot be recovered from `plain`, whose rows
+ * are strings of code points, not columns.
+ *
+ * `warnings` lists source the flowchart grammar could not read and dropped.
+ * Non-empty means the art is real but incomplete — some of what was written is
+ * not in it. Only flowcharts warn; the other grammars refuse the whole diagram
+ * instead, and `render` returns `null`.
+ *
+ * They are advisory. Do not gate rendering on them: the art is the best drawing
+ * of the source either way, and a diagram being typed or streamed warns at
+ * nearly every intermediate state. Show them alongside, or once it settles.
+ */
+export interface MermaidArt {
+  plain: string[]
+  styled: Span[][]
+  width: number
+  warnings: string[]
+}