@adea-ai/ui 0.140.0 → 0.142.0

package/dist/components/composites/terminal/terminal-model.d.ts

@@ -0,0 +1,63 @@
+/**
+ * The terminal's pure decisions: what its status says, which lines are mounted,
+ * and whether the reader is at the end. They live apart from the component so
+ * the rules that are easy to get subtly wrong — an off-by-one in "N earlier
+ * lines", a tolerance that yanks the reader back to the bottom — have tests.
+ */
+/**
+ * What the host knows about the command. Absent means no statement: a terminal
+ * handed output with no status does not say whether the command is still running.
+ */
+export type TerminalStatus = {
+    state: 'running';
+} | {
+    state: 'exited';
+    code: number;
+} | {
+    state: 'cancelled';
+};
+/** The words for a status, which are also what a screen reader hears. */
+export declare function terminalStatusLabel(status: TerminalStatus): string;
+/** Whether a status is a non-zero exit — the one thing the header tones as a failure. */
+export declare function isFailedExit(status: TerminalStatus | undefined): boolean;
+export type TerminalWindow = Readonly<{
+    /** Index of the first mounted finished line. */
+    start: number;
+    /** Index after the last mounted finished line. */
+    end: number;
+    /** Retained lines before `start` that "show earlier" can reveal. */
+    revealable: number;
+    /** Every earlier line not on screen, including those the parser discarded. */
+    hidden: number;
+    /** Retained finished lines after `end`: output that arrived while the view was parked. */
+    later: number;
+    /** Lines of the parked view that retention discarded before the reader moved on. */
+    evicted: number;
+    /** The whole parked view was discarded, so the oldest retained lines are shown instead. */
+    lost: boolean;
+}>;
+/**
+ * The slice of the retained lines that is mounted. `limit` is how many finished
+ * lines to show; the rest are counted, not rendered, because a terminal that
+ * mounts every line of a long build is a frozen page.
+ *
+ * While the reader follows the tail the slice ends at the newest line. Once they
+ * have scrolled away it is *parked*: `anchorEnd` is the number of lines (counting
+ * the ones retention already discarded) that existed when they left, and the
+ * slice stays ending there while output keeps arriving, so what they are reading
+ * does not move under them. If retention discards the lines they were reading,
+ * `evicted` says how many, and when all of them are gone `lost` is set and the
+ * oldest retained lines are shown, because the nearest thing that still exists
+ * is better than a blank box.
+ */
+export declare function terminalWindow(retained: number, dropped: number, limit: number, anchorEnd?: number): TerminalWindow;
+/** The limit after one "show earlier" press: one more page, never past what exists. */
+export declare function revealEarlier(limit: number, page: number, retained: number): number;
+/** Subpixel scroll positions and zoom make "exactly at the bottom" unreliable. */
+export declare const BOTTOM_TOLERANCE_PX = 4;
+/**
+ * Whether a scroller is showing its end. This decides whether new output
+ * follows the reader: at the bottom it does, anywhere else the view is theirs.
+ */
+export declare function isAtBottom(scrollHeight: number, scrollTop: number, clientHeight: number): boolean;
+//# sourceMappingURL=terminal-model.d.ts.map

package/dist/components/composites/terminal/terminal-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terminal-model.d.ts","sourceRoot":"","sources":["../../../../src/components/composites/terminal/terminal-model.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;GAGG;AACH,MAAM,MAAM,cAAc,GACtB;IAAE,KAAK,EAAE,SAAS,CAAA;CAAE,GACpB;IAAE,KAAK,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACjC;IAAE,KAAK,EAAE,WAAW,CAAA;CAAE,CAAA;AAE1B,yEAAyE;AACzE,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,cAAc,GAAG,MAAM,CAIlE;AAED,yFAAyF;AACzF,wBAAgB,YAAY,CAAC,MAAM,EAAE,cAAc,GAAG,SAAS,GAAG,OAAO,CAExE;AAED,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC;IACpC,gDAAgD;IAChD,KAAK,EAAE,MAAM,CAAA;IACb,kDAAkD;IAClD,GAAG,EAAE,MAAM,CAAA;IACX,oEAAoE;IACpE,UAAU,EAAE,MAAM,CAAA;IAClB,8EAA8E;IAC9E,MAAM,EAAE,MAAM,CAAA;IACd,0FAA0F;IAC1F,KAAK,EAAE,MAAM,CAAA;IACb,oFAAoF;IACpF,OAAO,EAAE,MAAM,CAAA;IACf,2FAA2F;IAC3F,IAAI,EAAE,OAAO,CAAA;CACd,CAAC,CAAA;AAEF;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,SAAS,CAAC,EAAE,MAAM,GACjB,cAAc,CA8BhB;AAED,uFAAuF;AACvF,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEnF;AAED,kFAAkF;AAClF,eAAO,MAAM,mBAAmB,IAAI,CAAA;AAEpC;;;GAGG;AACH,wBAAgB,UAAU,CAAC,YAAY,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAEjG"}

package/dist/components/composites/terminal/terminal-model.js

@@ -0,0 +1,69 @@
+//#region src/components/composites/terminal/terminal-model.ts
+/** The words for a status, which are also what a screen reader hears. */
+function terminalStatusLabel(status) {
+	if (status.state === "running") return "Running";
+	if (status.state === "cancelled") return "Cancelled";
+	return Number.isInteger(status.code) ? `Exited with code ${status.code}` : "Exited";
+}
+/** Whether a status is a non-zero exit — the one thing the header tones as a failure. */
+function isFailedExit(status) {
+	return status?.state === "exited" && Number.isInteger(status.code) && status.code !== 0;
+}
+/**
+* The slice of the retained lines that is mounted. `limit` is how many finished
+* lines to show; the rest are counted, not rendered, because a terminal that
+* mounts every line of a long build is a frozen page.
+*
+* While the reader follows the tail the slice ends at the newest line. Once they
+* have scrolled away it is *parked*: `anchorEnd` is the number of lines (counting
+* the ones retention already discarded) that existed when they left, and the
+* slice stays ending there while output keeps arriving, so what they are reading
+* does not move under them. If retention discards the lines they were reading,
+* `evicted` says how many, and when all of them are gone `lost` is set and the
+* oldest retained lines are shown, because the nearest thing that still exists
+* is better than a blank box.
+*/
+function terminalWindow(retained, dropped, limit, anchorEnd) {
+	const size = Math.max(1, Math.floor(limit));
+	if (anchorEnd === void 0 || anchorEnd >= dropped + retained) {
+		const start = Math.max(0, retained - size);
+		return {
+			start,
+			end: retained,
+			revealable: start,
+			hidden: start + dropped,
+			later: 0,
+			evicted: 0,
+			lost: false
+		};
+	}
+	const wantedStart = Math.max(0, anchorEnd - size);
+	const lost = anchorEnd <= dropped;
+	const end = lost ? Math.min(retained, size) : anchorEnd - dropped;
+	const start = lost ? 0 : Math.max(0, end - size);
+	const evicted = lost ? anchorEnd - wantedStart : Math.max(0, Math.min(dropped, anchorEnd) - wantedStart);
+	return {
+		start,
+		end,
+		revealable: start,
+		hidden: start + dropped,
+		later: retained - end,
+		evicted,
+		lost
+	};
+}
+/** The limit after one "show earlier" press: one more page, never past what exists. */
+function revealEarlier(limit, page, retained) {
+	return Math.min(Math.max(retained, 1), limit + Math.max(1, Math.floor(page)));
+}
+/**
+* Whether a scroller is showing its end. This decides whether new output
+* follows the reader: at the bottom it does, anywhere else the view is theirs.
+*/
+function isAtBottom(scrollHeight, scrollTop, clientHeight) {
+	return scrollHeight - scrollTop - clientHeight <= 4;
+}
+//#endregion
+export { isAtBottom, isFailedExit, revealEarlier, terminalStatusLabel, terminalWindow };
+
+//# sourceMappingURL=terminal-model.js.map

package/dist/components/composites/terminal/terminal-model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"terminal-model.js","names":[],"sources":["../../../../src/components/composites/terminal/terminal-model.ts"],"sourcesContent":["/**\n * The terminal's pure decisions: what its status says, which lines are mounted,\n * and whether the reader is at the end. They live apart from the component so\n * the rules that are easy to get subtly wrong — an off-by-one in \"N earlier\n * lines\", a tolerance that yanks the reader back to the bottom — have tests.\n */\n\n/**\n * What the host knows about the command. Absent means no statement: a terminal\n * handed output with no status does not say whether the command is still running.\n */\nexport type TerminalStatus =\n  | { state: 'running' }\n  | { state: 'exited'; code: number }\n  | { state: 'cancelled' }\n\n/** The words for a status, which are also what a screen reader hears. */\nexport function terminalStatusLabel(status: TerminalStatus): string {\n  if (status.state === 'running') return 'Running'\n  if (status.state === 'cancelled') return 'Cancelled'\n  return Number.isInteger(status.code) ? `Exited with code ${status.code}` : 'Exited'\n}\n\n/** Whether a status is a non-zero exit — the one thing the header tones as a failure. */\nexport function isFailedExit(status: TerminalStatus | undefined): boolean {\n  return status?.state === 'exited' && Number.isInteger(status.code) && status.code !== 0\n}\n\nexport type TerminalWindow = Readonly<{\n  /** Index of the first mounted finished line. */\n  start: number\n  /** Index after the last mounted finished line. */\n  end: number\n  /** Retained lines before `start` that \"show earlier\" can reveal. */\n  revealable: number\n  /** Every earlier line not on screen, including those the parser discarded. */\n  hidden: number\n  /** Retained finished lines after `end`: output that arrived while the view was parked. */\n  later: number\n  /** Lines of the parked view that retention discarded before the reader moved on. */\n  evicted: number\n  /** The whole parked view was discarded, so the oldest retained lines are shown instead. */\n  lost: boolean\n}>\n\n/**\n * The slice of the retained lines that is mounted. `limit` is how many finished\n * lines to show; the rest are counted, not rendered, because a terminal that\n * mounts every line of a long build is a frozen page.\n *\n * While the reader follows the tail the slice ends at the newest line. Once they\n * have scrolled away it is *parked*: `anchorEnd` is the number of lines (counting\n * the ones retention already discarded) that existed when they left, and the\n * slice stays ending there while output keeps arriving, so what they are reading\n * does not move under them. If retention discards the lines they were reading,\n * `evicted` says how many, and when all of them are gone `lost` is set and the\n * oldest retained lines are shown, because the nearest thing that still exists\n * is better than a blank box.\n */\nexport function terminalWindow(\n  retained: number,\n  dropped: number,\n  limit: number,\n  anchorEnd?: number\n): TerminalWindow {\n  const size = Math.max(1, Math.floor(limit))\n  if (anchorEnd === undefined || anchorEnd >= dropped + retained) {\n    const start = Math.max(0, retained - size)\n    return {\n      start,\n      end: retained,\n      revealable: start,\n      hidden: start + dropped,\n      later: 0,\n      evicted: 0,\n      lost: false,\n    }\n  }\n  const wantedStart = Math.max(0, anchorEnd - size)\n  const lost = anchorEnd <= dropped\n  const end = lost ? Math.min(retained, size) : anchorEnd - dropped\n  const start = lost ? 0 : Math.max(0, end - size)\n  const evicted = lost\n    ? anchorEnd - wantedStart\n    : Math.max(0, Math.min(dropped, anchorEnd) - wantedStart)\n  return {\n    start,\n    end,\n    revealable: start,\n    hidden: start + dropped,\n    later: retained - end,\n    evicted,\n    lost,\n  }\n}\n\n/** The limit after one \"show earlier\" press: one more page, never past what exists. */\nexport function revealEarlier(limit: number, page: number, retained: number): number {\n  return Math.min(Math.max(retained, 1), limit + Math.max(1, Math.floor(page)))\n}\n\n/** Subpixel scroll positions and zoom make \"exactly at the bottom\" unreliable. */\nexport const BOTTOM_TOLERANCE_PX = 4\n\n/**\n * Whether a scroller is showing its end. This decides whether new output\n * follows the reader: at the bottom it does, anywhere else the view is theirs.\n */\nexport function isAtBottom(scrollHeight: number, scrollTop: number, clientHeight: number): boolean {\n  return scrollHeight - scrollTop - clientHeight <= BOTTOM_TOLERANCE_PX\n}\n"],"mappings":";;AAiBA,SAAgB,oBAAoB,QAAgC;CAClE,IAAI,OAAO,UAAU,WAAW,OAAO;CACvC,IAAI,OAAO,UAAU,aAAa,OAAO;CACzC,OAAO,OAAO,UAAU,OAAO,IAAI,IAAI,oBAAoB,OAAO,SAAS;AAC7E;;AAGA,SAAgB,aAAa,QAA6C;CACxE,OAAO,QAAQ,UAAU,YAAY,OAAO,UAAU,OAAO,IAAI,KAAK,OAAO,SAAS;AACxF;;;;;;;;;;;;;;;AAiCA,SAAgB,eACd,UACA,SACA,OACA,WACgB;CAChB,MAAM,OAAO,KAAK,IAAI,GAAG,KAAK,MAAM,KAAK,CAAC;CAC1C,IAAI,cAAc,KAAA,KAAa,aAAa,UAAU,UAAU;EAC9D,MAAM,QAAQ,KAAK,IAAI,GAAG,WAAW,IAAI;EACzC,OAAO;GACL;GACA,KAAK;GACL,YAAY;GACZ,QAAQ,QAAQ;GAChB,OAAO;GACP,SAAS;GACT,MAAM;EACR;CACF;CACA,MAAM,cAAc,KAAK,IAAI,GAAG,YAAY,IAAI;CAChD,MAAM,OAAO,aAAa;CAC1B,MAAM,MAAM,OAAO,KAAK,IAAI,UAAU,IAAI,IAAI,YAAY;CAC1D,MAAM,QAAQ,OAAO,IAAI,KAAK,IAAI,GAAG,MAAM,IAAI;CAC/C,MAAM,UAAU,OACZ,YAAY,cACZ,KAAK,IAAI,GAAG,KAAK,IAAI,SAAS,SAAS,IAAI,WAAW;CAC1D,OAAO;EACL;EACA;EACA,YAAY;EACZ,QAAQ,QAAQ;EAChB,OAAO,WAAW;EAClB;EACA;CACF;AACF;;AAGA,SAAgB,cAAc,OAAe,MAAc,UAA0B;CACnF,OAAO,KAAK,IAAI,KAAK,IAAI,UAAU,CAAC,GAAG,QAAQ,KAAK,IAAI,GAAG,KAAK,MAAM,IAAI,CAAC,CAAC;AAC9E;;;;;AASA,SAAgB,WAAW,cAAsB,WAAmB,cAA+B;CACjG,OAAO,eAAe,YAAY,gBAAA;AACpC"}

package/dist/components/composites/terminal/terminal.d.ts

@@ -0,0 +1,88 @@
+import { type ComponentProps } from 'solid-js';
+import { type TerminalStatus } from './terminal-model';
+/**
+ * Terminal.
+ *
+ * A command and its output, as it arrives. It is the thing to put inside an
+ * agent's "ran a command" line (a `TraceLine`, with `size="sm"`) when the output
+ * is the evidence; reach for `CodeBlock` instead when the text is source or a
+ * finished log that needs no live behaviour, and for `TestResults` when the
+ * output is a test run the host can structure.
+ *
+ * It does not wrap `CodeBlock`. A block's `highlight` seam re-renders the whole
+ * body whenever the code changes, which is exactly wrong for output that grows a
+ * line at a time, and a terminal has to own its scroller to follow the tail. It
+ * keeps the block's header and surface vocabulary so the two read as one family.
+ *
+ * ## What the output is allowed to do
+ *
+ * Output is untrusted bytes. It is parsed by `createAnsiParser` into plain text
+ * and a fixed set of styles — sixteen theme colours, bold, dim, italic,
+ * underline, strike-through, reverse — and everything else (cursor movement,
+ * title and clipboard sequences, anything malformed) is dropped, never echoed.
+ * Colours come from the theme's `--terminal-ansi-*` tokens, painted on the
+ * theme's own terminal background, so a program's colours keep the contrast the
+ * theme measured for them. Nothing is rendered as markup.
+ *
+ * ## Streaming
+ *
+ * `output` is the whole string so far. When the new value begins with the old
+ * one, only the appended text is parsed, so a chunk costs the size of the chunk
+ * and not of the transcript. Finished lines are keyed by identity and are never
+ * re-rendered; only the line still being written changes, which is what makes a
+ * `\r` progress bar redraw in place. Batch appends per frame — the host sees a
+ * prefix check proportional to the output on every change.
+ *
+ * Only the last `maxLines` finished lines are mounted. The rest are counted in
+ * an explicit note with a control to show them a page at a time, because tens of
+ * thousands of row elements are a frozen page, not a transcript. Copy still
+ * writes `output` exactly as given — not the rendered lines, not the visible tail.
+ *
+ * ## Following the tail
+ *
+ * The terminal scrolls inside its own bounded box and follows new output only
+ * while the reader is at the bottom of that box. Scrolling up *parks* the view:
+ * the lines mounted are the ones that were there when they left, however much
+ * output arrives, and "Jump to latest" is the only way back to the tail (reaching
+ * the bottom of a parked view with nothing newer resumes it, because nothing was
+ * missed). If retention discards the lines they were reading the note says how
+ * many, and when none are left the oldest retained lines are shown. The page
+ * itself is never scrolled. Scrolling is instant, so there is no animation to
+ * reduce.
+ *
+ * ## Status is a claim
+ *
+ * `status` is drawn only when the host passes it, in words as well as an icon,
+ * and only a non-zero exit is toned as a failure: this component does not decide
+ * that a command "passed". Without a status the header says nothing about whether
+ * the command is still running. `onClear` adds a clear button; without it the
+ * output is the host's record and nothing here offers to erase it.
+ */
+export type TerminalProps = Omit<ComponentProps<'div'>, 'children'> & {
+    /** Everything the command has printed so far, exactly as received. */
+    output: string;
+    /** The command line. Shown as text; the prompt glyph is decoration. */
+    command?: string;
+    status?: TerminalStatus;
+    /** Finished lines mounted at once; earlier ones are counted and revealed a page at a time. */
+    maxLines?: number;
+    /** Finished lines kept at all; older ones are discarded and counted. Default 200 000. */
+    retainLines?: number;
+    /** Height of the output box, which scrolls past it. A number is pixels. Default `20rem`. */
+    maxHeight?: number | string;
+    /** Soft-wrap long lines instead of scrolling sideways. Off: terminal columns keep their alignment. */
+    wrap?: boolean;
+    /** `sm` is the compact chrome for output nested inside a Trace line. */
+    size?: 'default' | 'sm';
+    /** Show a clear button. The host empties `output`; the terminal erases nothing itself. */
+    onClear?: () => void;
+    copyLabel?: string;
+    copiedLabel?: string;
+    clearLabel?: string;
+    /** Called after each copy attempt with whether the clipboard accepted it. */
+    onCopy?: (ok: boolean) => void;
+};
+/** Finished lines mounted by default. */
+export declare const TERMINAL_MAX_LINES = 1000;
+export declare function Terminal(props: TerminalProps): import("solid-js").JSX.Element;
+//# sourceMappingURL=terminal.d.ts.map

package/dist/components/composites/terminal/terminal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terminal.d.ts","sourceRoot":"","sources":["../../../../src/components/composites/terminal/terminal.tsx"],"names":[],"mappings":"AASA,OAAO,EAQL,KAAK,cAAc,EACpB,MAAM,UAAU,CAAA;AAWjB,OAAO,EAML,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AAEzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,MAAM,MAAM,aAAa,GAAG,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,EAAE,UAAU,CAAC,GAAG;IACpE,sEAAsE;IACtE,MAAM,EAAE,MAAM,CAAA;IACd,uEAAuE;IACvE,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,MAAM,CAAC,EAAE,cAAc,CAAA;IACvB,8FAA8F;IAC9F,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,yFAAyF;IACzF,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,4FAA4F;IAC5F,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IAC3B,sGAAsG;IACtG,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,wEAAwE;IACxE,IAAI,CAAC,EAAE,SAAS,GAAG,IAAI,CAAA;IACvB,0FAA0F;IAC1F,OAAO,CAAC,EAAE,MAAM,IAAI,CAAA;IACpB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,6EAA6E;IAC7E,MAAM,CAAC,EAAE,CAAC,EAAE,EAAE,OAAO,KAAK,IAAI,CAAA;CAC/B,CAAA;AAED,yCAAyC;AACzC,eAAO,MAAM,kBAAkB,OAAO,CAAA;AAwItC,wBAAgB,QAAQ,CAAC,KAAK,EAAE,aAAa,kCA2T5C"}