@adea-ai/ui 0.140.0 → 0.142.0

package/dist/components/composites/test-results/test-results-model.d.ts

@@ -0,0 +1,154 @@
+/**
+ * The test run's pure rules: what the listed tests add up to, how that compares
+ * with the counts the host reported, and how a duration is said.
+ *
+ * The one rule that shapes everything here is that a count is a claim. There are
+ * two honest sources for one — the host's own tally (`summary`), and the tests it
+ * chose to list — and they are allowed to disagree: a host may list only the
+ * failures, a runner may count tests it did not stream, a suite may have been cut
+ * short. So nothing is silently recomputed. A supplied count is shown as given; if
+ * the tests listed do not add up to it, the listed number is shown beside it; and
+ * when no summary was supplied, the counts that are shown are labelled as coming
+ * from the tests listed, not presented as the run's totals.
+ */
+export type TestOutcome = 'passed' | 'failed' | 'skipped';
+/** `running` and `pending` are states of a test that has no outcome yet; they are not counted. */
+export type TestCaseStatus = TestOutcome | 'running' | 'pending';
+export type TestCase = Readonly<{
+    /** Stable identity for keyed rendering. Defaults to the position. */
+    id?: string;
+    name: string;
+    /** Absent means the host did not say; the test is listed and nothing is claimed. */
+    status?: TestCaseStatus;
+    durationMs?: number;
+    /** The failure message, as text. */
+    message?: string;
+    /** A stack trace for `StackTrace` to read. */
+    stack?: string;
+    /** A unified diff of expected against actual for `DiffBlock`. */
+    diff?: string;
+}>;
+export type TestSuite = Readonly<{
+    id?: string;
+    name: string;
+    /** The file the suite lives in, shown as text. */
+    file?: string;
+    durationMs?: number;
+    tests?: readonly TestCase[];
+    suites?: readonly TestSuite[];
+}>;
+/** The host's own tally. Every field is optional; only supplied ones are shown. */
+export type TestSummary = Readonly<{
+    passed?: number;
+    failed?: number;
+    skipped?: number;
+    total?: number;
+    durationMs?: number;
+}>;
+export type ListedCounts = Readonly<{
+    passed: number;
+    failed: number;
+    skipped: number;
+    running: number;
+    pending: number;
+    /** Tests listed with no status. */
+    unknown: number;
+    /** Every test listed, whatever its status. */
+    total: number;
+}>;
+/** Count the tests in a list of suites, at any depth. Iterative: suites come from a host. */
+export declare function listedCounts(suites: readonly TestSuite[]): ListedCounts;
+export type CountLine = Readonly<{
+    outcome: TestOutcome;
+    /** The number to show: the host's if it gave one, otherwise the listed one. */
+    count: number;
+    /** How many tests of this outcome are listed. */
+    listed: number;
+    /** The host gave a count and the list does not agree with it. */
+    differs: boolean;
+}>;
+export type RunCounts = Readonly<{
+    /** Whose numbers these are. `listed` must be labelled as such. */
+    basis: 'reported' | 'listed';
+    lines: readonly CountLine[];
+    /** The host's total, when supplied. */
+    reportedTotal?: number;
+    /** The reported total, when the host gave one and the list disagrees. */
+    totalNote?: Readonly<{
+        reported: number;
+        listed: number;
+    }>;
+}>;
+/**
+ * Decide which numbers to show.
+ *
+ * With a summary: exactly the counts it supplied, as given. `differs` is set
+ * when tests are listed at all and the listed number for that outcome is not the
+ * supplied one — a host that lists only failures will see "40 passed (0 listed)",
+ * which is true and tells the reader the list is partial. Without a summary: the
+ * outcomes that occur among the listed tests, with `basis: 'listed'`.
+ */
+export declare function reconcileCounts(summary: TestSummary | undefined, listed: ListedCounts): RunCounts;
+/** The words for one count: "38 passed", or "40 passed (38 listed)" when the list disagrees. */
+export declare function describeCount(line: CountLine): string;
+/**
+ * A duration. `short` is for a meta column ("120 ms", "3.4 s"); `long` is for a
+ * sentence ("120 milliseconds", "3.4 seconds", "2 minutes 5 seconds"). Anything
+ * that is not a finite non-negative number has no duration, so none is drawn.
+ */
+export declare function formatDuration(ms: unknown, style?: 'short' | 'long'): string | undefined;
+export type SuiteState = 'failed' | 'passed' | 'running' | undefined;
+/**
+ * What a suite can say about itself from the tests listed in it. Any listed
+ * failure makes it `failed`; a listed test still running makes it `running`;
+ * `passed` needs at least one passed test and every listed test to be passed or
+ * skipped. Anything else — no tests, a test with no status — is silence.
+ */
+export declare function suiteState(counts: ListedCounts): SuiteState;
+/** A suite's key among its siblings: its id if it has one, otherwise its position. */
+export declare function suiteKey(parent: string, suite: TestSuite, index: number): string;
+export declare function testKey(parent: string, test: TestCase, index: number): string;
+/** Distinguish repeated ids without tying a row to the object instance it renders. */
+export declare function repeatedKey(key: string, occurrence: number): string;
+/**
+ * A row's identity among its siblings only: the host id verbatim, or its
+ * position when it has none. The leading letter keeps the two apart, so an id
+ * that looks like a position never collides with one. A row's place in the tree
+ * is the list of these keys from the root, never one string that nests its
+ * parent's, so a key stays as long as its own id however deep the row sits.
+ */
+export declare function siblingKey(item: Readonly<{
+    id?: string;
+}>, index: number): string;
+export type BoundedEntry<T> = Readonly<{
+    key: string;
+    item: T;
+    index: number;
+}>;
+/** Build keyed rows only for the currently visible prefix of a bounded list. */
+export declare function boundedEntries<T>(items: readonly T[], visibleCount: number, itemKey: (item: T, index: number) => string): Readonly<{
+    entries: readonly BoundedEntry<T>[];
+    byKey: ReadonlyMap<string, BoundedEntry<T>>;
+}>;
+/** The key of the first failing test in reading order. */
+export declare function firstFailureKey(suites: readonly TestSuite[]): string | undefined;
+export type FirstFailureRenderPath = Readonly<{
+    /**
+     * The rendering key of each suite from the root through the suite containing
+     * the failure, one entry per level. A key is unique among its siblings, so
+     * a suite is on the path when its entry at its own depth is its key and its
+     * parent was on the path.
+     */
+    suites: readonly string[];
+    /** The failed test's rendering key among the tests of the last suite on the path. */
+    test: string;
+}>;
+/** True when both describe the same failure at the same place in the tree. */
+export declare function sameFailure(left: FirstFailureRenderPath | undefined, right: FirstFailureRenderPath | undefined): boolean;
+/**
+ * The first failure's unique rendering keys, including its ancestor suites. The
+ * work is linear in the suites visited and the path it returns is linear in the
+ * depth, so a long chain of nested suites costs no more than a wide list.
+ */
+export declare function firstFailureRenderPath(suites: readonly TestSuite[]): FirstFailureRenderPath | undefined;
+//# sourceMappingURL=test-results-model.d.ts.map

package/dist/components/composites/test-results/test-results-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-results-model.d.ts","sourceRoot":"","sources":["../../../../src/components/composites/test-results/test-results-model.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAA;AACzD,kGAAkG;AAClG,MAAM,MAAM,cAAc,GAAG,WAAW,GAAG,SAAS,GAAG,SAAS,CAAA;AAEhE,MAAM,MAAM,QAAQ,GAAG,QAAQ,CAAC;IAC9B,qEAAqE;IACrE,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;IACZ,oFAAoF;IACpF,MAAM,CAAC,EAAE,cAAc,CAAA;IACvB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,oCAAoC;IACpC,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,8CAA8C;IAC9C,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,iEAAiE;IACjE,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAC,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG,QAAQ,CAAC;IAC/B,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;IACZ,kDAAkD;IAClD,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,KAAK,CAAC,EAAE,SAAS,QAAQ,EAAE,CAAA;IAC3B,MAAM,CAAC,EAAE,SAAS,SAAS,EAAE,CAAA;CAC9B,CAAC,CAAA;AAEF,mFAAmF;AACnF,MAAM,MAAM,WAAW,GAAG,QAAQ,CAAC;IACjC,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB,CAAC,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,QAAQ,CAAC;IAClC,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;IACf,mCAAmC;IACnC,OAAO,EAAE,MAAM,CAAA;IACf,8CAA8C;IAC9C,KAAK,EAAE,MAAM,CAAA;CACd,CAAC,CAAA;AAoBF,6FAA6F;AAC7F,wBAAgB,YAAY,CAAC,MAAM,EAAE,SAAS,SAAS,EAAE,GAAG,YAAY,CAcvE;AAED,MAAM,MAAM,SAAS,GAAG,QAAQ,CAAC;IAC/B,OAAO,EAAE,WAAW,CAAA;IACpB,+EAA+E;IAC/E,KAAK,EAAE,MAAM,CAAA;IACb,iDAAiD;IACjD,MAAM,EAAE,MAAM,CAAA;IACd,iEAAiE;IACjE,OAAO,EAAE,OAAO,CAAA;CACjB,CAAC,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG,QAAQ,CAAC;IAC/B,kEAAkE;IAClE,KAAK,EAAE,UAAU,GAAG,QAAQ,CAAA;IAC5B,KAAK,EAAE,SAAS,SAAS,EAAE,CAAA;IAC3B,uCAAuC;IACvC,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,yEAAyE;IACzE,SAAS,CAAC,EAAE,QAAQ,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAC3D,CAAC,CAAA;AAQF;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,WAAW,GAAG,SAAS,EAAE,MAAM,EAAE,YAAY,GAAG,SAAS,CAiCjG;AAED,gGAAgG;AAChG,wBAAgB,aAAa,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,CAGrD;AAID;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,OAAO,EAAE,KAAK,GAAE,OAAO,GAAG,MAAgB,GAAG,MAAM,GAAG,SAAS,CAkBjG;AAED,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,SAAS,CAAA;AAEpE;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,YAAY,GAAG,UAAU,CAK3D;AAED,sFAAsF;AACtF,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAEhF;AAED,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAE7E;AAED,sFAAsF;AACtF,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAEnE;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAE,EAAE,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAEjF;AAED,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,QAAQ,CAAC;IACrC,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,CAAC,CAAA;IACP,KAAK,EAAE,MAAM,CAAA;CACd,CAAC,CAAA;AAEF,gFAAgF;AAChF,wBAAgB,cAAc,CAAC,CAAC,EAC9B,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,GAC1C,QAAQ,CAAC;IACV,OAAO,EAAE,SAAS,YAAY,CAAC,CAAC,CAAC,EAAE,CAAA;IACnC,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC,CAAA;CAC5C,CAAC,CAiBD;AAED,0DAA0D;AAC1D,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,SAAS,EAAE,GAAG,MAAM,GAAG,SAAS,CAkBhF;AAED,MAAM,MAAM,sBAAsB,GAAG,QAAQ,CAAC;IAC5C;;;;;OAKG;IACH,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;IACzB,qFAAqF;IACrF,IAAI,EAAE,MAAM,CAAA;CACb,CAAC,CAAA;AAEF,8EAA8E;AAC9E,wBAAgB,WAAW,CACzB,IAAI,EAAE,sBAAsB,GAAG,SAAS,EACxC,KAAK,EAAE,sBAAsB,GAAG,SAAS,GACxC,OAAO,CAOT;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,SAAS,SAAS,EAAE,GAC3B,sBAAsB,GAAG,SAAS,CAuCpC"}

package/dist/components/composites/test-results/test-results-model.js

@@ -0,0 +1,252 @@
+//#region src/components/composites/test-results/test-results-model.ts
+var empty = {
+	passed: 0,
+	failed: 0,
+	skipped: 0,
+	running: 0,
+	pending: 0,
+	unknown: 0,
+	total: 0
+};
+var KNOWN_STATUSES = /* @__PURE__ */ new Set([
+	"passed",
+	"failed",
+	"skipped",
+	"running",
+	"pending"
+]);
+/** Count the tests in a list of suites, at any depth. Iterative: suites come from a host. */
+function listedCounts(suites) {
+	const counts = { ...empty };
+	const stack = [...suites];
+	while (stack.length > 0) {
+		const suite = stack.pop();
+		for (const test of suite.tests ?? []) {
+			counts.total += 1;
+			if (test.status !== void 0 && KNOWN_STATUSES.has(test.status)) counts[test.status] += 1;
+			else counts.unknown += 1;
+		}
+		for (const child of suite.suites ?? []) stack.push(child);
+	}
+	return counts;
+}
+function validCount(value) {
+	return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+var OUTCOMES = [
+	"failed",
+	"passed",
+	"skipped"
+];
+/**
+* Decide which numbers to show.
+*
+* With a summary: exactly the counts it supplied, as given. `differs` is set
+* when tests are listed at all and the listed number for that outcome is not the
+* supplied one — a host that lists only failures will see "40 passed (0 listed)",
+* which is true and tells the reader the list is partial. Without a summary: the
+* outcomes that occur among the listed tests, with `basis: 'listed'`.
+*/
+function reconcileCounts(summary, listed) {
+	const supplied = OUTCOMES.filter((outcome) => validCount(summary?.[outcome]));
+	const hasTotal = validCount(summary?.total);
+	if (summary && (supplied.length > 0 || hasTotal)) {
+		const lines = supplied.map((outcome) => {
+			const count = summary[outcome];
+			return {
+				outcome,
+				count,
+				listed: listed[outcome],
+				differs: listed.total > 0 && listed[outcome] !== count
+			};
+		});
+		const totalNote = hasTotal && listed.total > 0 && summary.total !== listed.total ? {
+			reported: summary.total,
+			listed: listed.total
+		} : void 0;
+		return {
+			basis: "reported",
+			lines,
+			...hasTotal && { reportedTotal: summary.total },
+			...totalNote && { totalNote }
+		};
+	}
+	return {
+		basis: "listed",
+		lines: OUTCOMES.filter((outcome) => listed[outcome] > 0).map((outcome) => ({
+			outcome,
+			count: listed[outcome],
+			listed: listed[outcome],
+			differs: false
+		}))
+	};
+}
+/** The words for one count: "38 passed", or "40 passed (38 listed)" when the list disagrees. */
+function describeCount(line) {
+	const base = `${line.count.toLocaleString()} ${line.outcome}`;
+	return line.differs ? `${base} (${line.listed.toLocaleString()} listed)` : base;
+}
+var plural = (n, one) => n === 1 ? one : `${one}s`;
+/**
+* A duration. `short` is for a meta column ("120 ms", "3.4 s"); `long` is for a
+* sentence ("120 milliseconds", "3.4 seconds", "2 minutes 5 seconds"). Anything
+* that is not a finite non-negative number has no duration, so none is drawn.
+*/
+function formatDuration(ms, style = "short") {
+	if (typeof ms !== "number" || !Number.isFinite(ms) || ms < 0) return void 0;
+	if (ms > 0 && ms < 1) return style === "short" ? "<1 ms" : "less than 1 millisecond";
+	if (ms < 1e3) {
+		const whole = Math.round(ms);
+		return style === "short" ? `${whole} ms` : `${whole} ${plural(whole, "millisecond")}`;
+	}
+	if (ms < 6e4) {
+		const seconds = ms < 1e4 ? Math.round(ms / 100) / 10 : Math.round(ms / 1e3);
+		const text = Number.isInteger(seconds) ? String(seconds) : seconds.toFixed(1);
+		return style === "short" ? `${text} s` : `${text} ${seconds === 1 ? "second" : "seconds"}`;
+	}
+	const totalSeconds = Math.round(ms / 1e3);
+	const minutes = Math.floor(totalSeconds / 60);
+	const seconds = totalSeconds % 60;
+	if (style === "short") return seconds === 0 ? `${minutes} min` : `${minutes} min ${seconds} s`;
+	const m = `${minutes.toLocaleString()} ${plural(minutes, "minute")}`;
+	return seconds === 0 ? m : `${m} ${seconds} ${plural(seconds, "second")}`;
+}
+/**
+* What a suite can say about itself from the tests listed in it. Any listed
+* failure makes it `failed`; a listed test still running makes it `running`;
+* `passed` needs at least one passed test and every listed test to be passed or
+* skipped. Anything else — no tests, a test with no status — is silence.
+*/
+function suiteState(counts) {
+	if (counts.failed > 0) return "failed";
+	if (counts.running > 0) return "running";
+	if (counts.passed > 0 && counts.pending === 0 && counts.unknown === 0) return "passed";
+}
+/** A suite's key among its siblings: its id if it has one, otherwise its position. */
+function suiteKey(parent, suite, index) {
+	return `${parent}/${suite.id ?? `s${index}`}`;
+}
+function testKey(parent, test, index) {
+	return `${parent}:${test.id ?? `t${index}`}`;
+}
+/** Distinguish repeated ids without tying a row to the object instance it renders. */
+function repeatedKey(key, occurrence) {
+	return JSON.stringify([key, occurrence]);
+}
+/**
+* A row's identity among its siblings only: the host id verbatim, or its
+* position when it has none. The leading letter keeps the two apart, so an id
+* that looks like a position never collides with one. A row's place in the tree
+* is the list of these keys from the root, never one string that nests its
+* parent's, so a key stays as long as its own id however deep the row sits.
+*/
+function siblingKey(item, index) {
+	return item.id === void 0 ? `p${index}` : `i${item.id}`;
+}
+/** Build keyed rows only for the currently visible prefix of a bounded list. */
+function boundedEntries(items, visibleCount, itemKey) {
+	const entries = [];
+	const byKey = /* @__PURE__ */ new Map();
+	const occurrences = /* @__PURE__ */ new Map();
+	const count = Math.max(0, Math.min(items.length, Math.floor(visibleCount)));
+	for (let index = 0; index < count; index += 1) {
+		const item = items[index];
+		const base = itemKey(item, index);
+		const occurrence = occurrences.get(base) ?? 0;
+		occurrences.set(base, occurrence + 1);
+		const entry = {
+			key: repeatedKey(base, occurrence),
+			item,
+			index
+		};
+		entries.push(entry);
+		byKey.set(entry.key, entry);
+	}
+	return {
+		entries,
+		byKey
+	};
+}
+/** The key of the first failing test in reading order. */
+function firstFailureKey(suites) {
+	const stack = [{
+		suites,
+		parent: "",
+		index: 0
+	}];
+	while (stack.length > 0) {
+		const frame = stack[stack.length - 1];
+		const suite = frame.suites[frame.index];
+		if (!suite) {
+			stack.pop();
+			continue;
+		}
+		frame.index += 1;
+		const key = suiteKey(frame.parent, suite, frame.index - 1);
+		for (let i = 0; i < (suite.tests?.length ?? 0); i += 1) if (suite.tests[i].status === "failed") return testKey(key, suite.tests[i], i);
+		if (suite.suites?.length) stack.push({
+			suites: suite.suites,
+			parent: key,
+			index: 0
+		});
+	}
+}
+/** True when both describe the same failure at the same place in the tree. */
+function sameFailure(left, right) {
+	if (left === right) return true;
+	if (!left || !right) return false;
+	if (left.test !== right.test || left.suites.length !== right.suites.length) return false;
+	for (let index = 0; index < left.suites.length; index += 1) if (left.suites[index] !== right.suites[index]) return false;
+	return true;
+}
+/**
+* The first failure's unique rendering keys, including its ancestor suites. The
+* work is linear in the suites visited and the path it returns is linear in the
+* depth, so a long chain of nested suites costs no more than a wide list.
+*/
+function firstFailureRenderPath(suites) {
+	const stack = [{
+		suites,
+		index: 0,
+		occurrences: /* @__PURE__ */ new Map()
+	}];
+	while (stack.length > 0) {
+		const frame = stack[stack.length - 1];
+		const suite = frame.suites[frame.index];
+		if (!suite) {
+			stack.pop();
+			continue;
+		}
+		frame.index += 1;
+		const base = siblingKey(suite, frame.index - 1);
+		const occurrence = frame.occurrences.get(base) ?? 0;
+		frame.occurrences.set(base, occurrence + 1);
+		const key = repeatedKey(base, occurrence);
+		const tests = suite.tests ?? [];
+		const testOccurrences = /* @__PURE__ */ new Map();
+		for (let i = 0; i < tests.length; i += 1) {
+			const testBase = siblingKey(tests[i], i);
+			const testOccurrence = testOccurrences.get(testBase) ?? 0;
+			testOccurrences.set(testBase, testOccurrence + 1);
+			if (tests[i].status === "failed") {
+				const path = [];
+				for (let depth = 1; depth < stack.length; depth += 1) path.push(stack[depth].key);
+				path.push(key);
+				return {
+					suites: path,
+					test: repeatedKey(testBase, testOccurrence)
+				};
+			}
+		}
+		if (suite.suites?.length) stack.push({
+			suites: suite.suites,
+			index: 0,
+			occurrences: /* @__PURE__ */ new Map(),
+			key
+		});
+	}
+}
+//#endregion
+export { boundedEntries, describeCount, firstFailureKey, firstFailureRenderPath, formatDuration, listedCounts, reconcileCounts, repeatedKey, sameFailure, siblingKey, suiteKey, suiteState, testKey };
+
+//# sourceMappingURL=test-results-model.js.map

package/dist/components/composites/test-results/test-results-model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-results-model.js","names":[],"sources":["../../../../src/components/composites/test-results/test-results-model.ts"],"sourcesContent":["/**\n * The test run's pure rules: what the listed tests add up to, how that compares\n * with the counts the host reported, and how a duration is said.\n *\n * The one rule that shapes everything here is that a count is a claim. There are\n * two honest sources for one — the host's own tally (`summary`), and the tests it\n * chose to list — and they are allowed to disagree: a host may list only the\n * failures, a runner may count tests it did not stream, a suite may have been cut\n * short. So nothing is silently recomputed. A supplied count is shown as given; if\n * the tests listed do not add up to it, the listed number is shown beside it; and\n * when no summary was supplied, the counts that are shown are labelled as coming\n * from the tests listed, not presented as the run's totals.\n */\n\nexport type TestOutcome = 'passed' | 'failed' | 'skipped'\n/** `running` and `pending` are states of a test that has no outcome yet; they are not counted. */\nexport type TestCaseStatus = TestOutcome | 'running' | 'pending'\n\nexport type TestCase = Readonly<{\n  /** Stable identity for keyed rendering. Defaults to the position. */\n  id?: string\n  name: string\n  /** Absent means the host did not say; the test is listed and nothing is claimed. */\n  status?: TestCaseStatus\n  durationMs?: number\n  /** The failure message, as text. */\n  message?: string\n  /** A stack trace for `StackTrace` to read. */\n  stack?: string\n  /** A unified diff of expected against actual for `DiffBlock`. */\n  diff?: string\n}>\n\nexport type TestSuite = Readonly<{\n  id?: string\n  name: string\n  /** The file the suite lives in, shown as text. */\n  file?: string\n  durationMs?: number\n  tests?: readonly TestCase[]\n  suites?: readonly TestSuite[]\n}>\n\n/** The host's own tally. Every field is optional; only supplied ones are shown. */\nexport type TestSummary = Readonly<{\n  passed?: number\n  failed?: number\n  skipped?: number\n  total?: number\n  durationMs?: number\n}>\n\nexport type ListedCounts = Readonly<{\n  passed: number\n  failed: number\n  skipped: number\n  running: number\n  pending: number\n  /** Tests listed with no status. */\n  unknown: number\n  /** Every test listed, whatever its status. */\n  total: number\n}>\n\nconst empty: ListedCounts = {\n  passed: 0,\n  failed: 0,\n  skipped: 0,\n  running: 0,\n  pending: 0,\n  unknown: 0,\n  total: 0,\n}\n\nconst KNOWN_STATUSES: ReadonlySet<string> = new Set([\n  'passed',\n  'failed',\n  'skipped',\n  'running',\n  'pending',\n])\n\n/** Count the tests in a list of suites, at any depth. Iterative: suites come from a host. */\nexport function listedCounts(suites: readonly TestSuite[]): ListedCounts {\n  const counts = { ...empty }\n  const stack = [...suites]\n  while (stack.length > 0) {\n    const suite = stack.pop()!\n    for (const test of suite.tests ?? []) {\n      counts.total += 1\n      // A status the host invented is as good as none.\n      if (test.status !== undefined && KNOWN_STATUSES.has(test.status)) counts[test.status] += 1\n      else counts.unknown += 1\n    }\n    for (const child of suite.suites ?? []) stack.push(child)\n  }\n  return counts\n}\n\nexport type CountLine = Readonly<{\n  outcome: TestOutcome\n  /** The number to show: the host's if it gave one, otherwise the listed one. */\n  count: number\n  /** How many tests of this outcome are listed. */\n  listed: number\n  /** The host gave a count and the list does not agree with it. */\n  differs: boolean\n}>\n\nexport type RunCounts = Readonly<{\n  /** Whose numbers these are. `listed` must be labelled as such. */\n  basis: 'reported' | 'listed'\n  lines: readonly CountLine[]\n  /** The host's total, when supplied. */\n  reportedTotal?: number\n  /** The reported total, when the host gave one and the list disagrees. */\n  totalNote?: Readonly<{ reported: number; listed: number }>\n}>\n\nfunction validCount(value: unknown): value is number {\n  return typeof value === 'number' && Number.isInteger(value) && value >= 0\n}\n\nconst OUTCOMES: readonly TestOutcome[] = ['failed', 'passed', 'skipped']\n\n/**\n * Decide which numbers to show.\n *\n * With a summary: exactly the counts it supplied, as given. `differs` is set\n * when tests are listed at all and the listed number for that outcome is not the\n * supplied one — a host that lists only failures will see \"40 passed (0 listed)\",\n * which is true and tells the reader the list is partial. Without a summary: the\n * outcomes that occur among the listed tests, with `basis: 'listed'`.\n */\nexport function reconcileCounts(summary: TestSummary | undefined, listed: ListedCounts): RunCounts {\n  const supplied = OUTCOMES.filter((outcome) => validCount(summary?.[outcome]))\n  const hasTotal = validCount(summary?.total)\n\n  if (summary && (supplied.length > 0 || hasTotal)) {\n    const lines: CountLine[] = supplied.map((outcome) => {\n      const count = summary[outcome] as number\n      return {\n        outcome,\n        count,\n        listed: listed[outcome],\n        differs: listed.total > 0 && listed[outcome] !== count,\n      }\n    })\n    const totalNote =\n      hasTotal && listed.total > 0 && summary.total !== listed.total\n        ? { reported: summary.total as number, listed: listed.total }\n        : undefined\n    return {\n      basis: 'reported',\n      lines,\n      ...(hasTotal && { reportedTotal: summary.total as number }),\n      ...(totalNote && { totalNote }),\n    }\n  }\n\n  const lines: CountLine[] = OUTCOMES.filter((outcome) => listed[outcome] > 0).map((outcome) => ({\n    outcome,\n    count: listed[outcome],\n    listed: listed[outcome],\n    differs: false,\n  }))\n  return { basis: 'listed', lines }\n}\n\n/** The words for one count: \"38 passed\", or \"40 passed (38 listed)\" when the list disagrees. */\nexport function describeCount(line: CountLine): string {\n  const base = `${line.count.toLocaleString()} ${line.outcome}`\n  return line.differs ? `${base} (${line.listed.toLocaleString()} listed)` : base\n}\n\nconst plural = (n: number, one: string) => (n === 1 ? one : `${one}s`)\n\n/**\n * A duration. `short` is for a meta column (\"120 ms\", \"3.4 s\"); `long` is for a\n * sentence (\"120 milliseconds\", \"3.4 seconds\", \"2 minutes 5 seconds\"). Anything\n * that is not a finite non-negative number has no duration, so none is drawn.\n */\nexport function formatDuration(ms: unknown, style: 'short' | 'long' = 'short'): string | undefined {\n  if (typeof ms !== 'number' || !Number.isFinite(ms) || ms < 0) return undefined\n  if (ms > 0 && ms < 1) return style === 'short' ? '<1 ms' : 'less than 1 millisecond'\n  if (ms < 1000) {\n    const whole = Math.round(ms)\n    return style === 'short' ? `${whole} ms` : `${whole} ${plural(whole, 'millisecond')}`\n  }\n  if (ms < 60_000) {\n    const seconds = ms < 10_000 ? Math.round(ms / 100) / 10 : Math.round(ms / 1000)\n    const text = Number.isInteger(seconds) ? String(seconds) : seconds.toFixed(1)\n    return style === 'short' ? `${text} s` : `${text} ${seconds === 1 ? 'second' : 'seconds'}`\n  }\n  const totalSeconds = Math.round(ms / 1000)\n  const minutes = Math.floor(totalSeconds / 60)\n  const seconds = totalSeconds % 60\n  if (style === 'short') return seconds === 0 ? `${minutes} min` : `${minutes} min ${seconds} s`\n  const m = `${minutes.toLocaleString()} ${plural(minutes, 'minute')}`\n  return seconds === 0 ? m : `${m} ${seconds} ${plural(seconds, 'second')}`\n}\n\nexport type SuiteState = 'failed' | 'passed' | 'running' | undefined\n\n/**\n * What a suite can say about itself from the tests listed in it. Any listed\n * failure makes it `failed`; a listed test still running makes it `running`;\n * `passed` needs at least one passed test and every listed test to be passed or\n * skipped. Anything else — no tests, a test with no status — is silence.\n */\nexport function suiteState(counts: ListedCounts): SuiteState {\n  if (counts.failed > 0) return 'failed'\n  if (counts.running > 0) return 'running'\n  if (counts.passed > 0 && counts.pending === 0 && counts.unknown === 0) return 'passed'\n  return undefined\n}\n\n/** A suite's key among its siblings: its id if it has one, otherwise its position. */\nexport function suiteKey(parent: string, suite: TestSuite, index: number): string {\n  return `${parent}/${suite.id ?? `s${index}`}`\n}\n\nexport function testKey(parent: string, test: TestCase, index: number): string {\n  return `${parent}:${test.id ?? `t${index}`}`\n}\n\n/** Distinguish repeated ids without tying a row to the object instance it renders. */\nexport function repeatedKey(key: string, occurrence: number): string {\n  return JSON.stringify([key, occurrence])\n}\n\n/**\n * A row's identity among its siblings only: the host id verbatim, or its\n * position when it has none. The leading letter keeps the two apart, so an id\n * that looks like a position never collides with one. A row's place in the tree\n * is the list of these keys from the root, never one string that nests its\n * parent's, so a key stays as long as its own id however deep the row sits.\n */\nexport function siblingKey(item: Readonly<{ id?: string }>, index: number): string {\n  return item.id === undefined ? `p${index}` : `i${item.id}`\n}\n\nexport type BoundedEntry<T> = Readonly<{\n  key: string\n  item: T\n  index: number\n}>\n\n/** Build keyed rows only for the currently visible prefix of a bounded list. */\nexport function boundedEntries<T>(\n  items: readonly T[],\n  visibleCount: number,\n  itemKey: (item: T, index: number) => string\n): Readonly<{\n  entries: readonly BoundedEntry<T>[]\n  byKey: ReadonlyMap<string, BoundedEntry<T>>\n}> {\n  const entries: BoundedEntry<T>[] = []\n  const byKey = new Map<string, BoundedEntry<T>>()\n  const occurrences = new Map<string, number>()\n  const count = Math.max(0, Math.min(items.length, Math.floor(visibleCount)))\n\n  for (let index = 0; index < count; index += 1) {\n    const item = items[index]!\n    const base = itemKey(item, index)\n    const occurrence = occurrences.get(base) ?? 0\n    occurrences.set(base, occurrence + 1)\n    const entry = { key: repeatedKey(base, occurrence), item, index }\n    entries.push(entry)\n    byKey.set(entry.key, entry)\n  }\n\n  return { entries, byKey }\n}\n\n/** The key of the first failing test in reading order. */\nexport function firstFailureKey(suites: readonly TestSuite[]): string | undefined {\n  type Frame = { suites: readonly TestSuite[]; parent: string; index: number }\n  const stack: Frame[] = [{ suites, parent: '', index: 0 }]\n  while (stack.length > 0) {\n    const frame = stack[stack.length - 1]!\n    const suite = frame.suites[frame.index]\n    if (!suite) {\n      stack.pop()\n      continue\n    }\n    frame.index += 1\n    const key = suiteKey(frame.parent, suite, frame.index - 1)\n    for (let i = 0; i < (suite.tests?.length ?? 0); i += 1) {\n      if (suite.tests![i]!.status === 'failed') return testKey(key, suite.tests![i]!, i)\n    }\n    if (suite.suites?.length) stack.push({ suites: suite.suites, parent: key, index: 0 })\n  }\n  return undefined\n}\n\nexport type FirstFailureRenderPath = Readonly<{\n  /**\n   * The rendering key of each suite from the root through the suite containing\n   * the failure, one entry per level. A key is unique among its siblings, so\n   * a suite is on the path when its entry at its own depth is its key and its\n   * parent was on the path.\n   */\n  suites: readonly string[]\n  /** The failed test's rendering key among the tests of the last suite on the path. */\n  test: string\n}>\n\n/** True when both describe the same failure at the same place in the tree. */\nexport function sameFailure(\n  left: FirstFailureRenderPath | undefined,\n  right: FirstFailureRenderPath | undefined\n): boolean {\n  if (left === right) return true\n  if (!left || !right) return false\n  if (left.test !== right.test || left.suites.length !== right.suites.length) return false\n  for (let index = 0; index < left.suites.length; index += 1)\n    if (left.suites[index] !== right.suites[index]) return false\n  return true\n}\n\n/**\n * The first failure's unique rendering keys, including its ancestor suites. The\n * work is linear in the suites visited and the path it returns is linear in the\n * depth, so a long chain of nested suites costs no more than a wide list.\n */\nexport function firstFailureRenderPath(\n  suites: readonly TestSuite[]\n): FirstFailureRenderPath | undefined {\n  type Frame = {\n    suites: readonly TestSuite[]\n    index: number\n    occurrences: Map<string, number>\n    /** The rendering key of the suite these are the children of; absent at the root. */\n    key?: string\n  }\n  const stack: Frame[] = [{ suites, index: 0, occurrences: new Map() }]\n  while (stack.length > 0) {\n    const frame = stack[stack.length - 1]!\n    const suite = frame.suites[frame.index]\n    if (!suite) {\n      stack.pop()\n      continue\n    }\n    frame.index += 1\n    const base = siblingKey(suite, frame.index - 1)\n    const occurrence = frame.occurrences.get(base) ?? 0\n    frame.occurrences.set(base, occurrence + 1)\n    const key = repeatedKey(base, occurrence)\n    const tests = suite.tests ?? []\n    const testOccurrences = new Map<string, number>()\n    for (let i = 0; i < tests.length; i += 1) {\n      const testBase = siblingKey(tests[i]!, i)\n      const testOccurrence = testOccurrences.get(testBase) ?? 0\n      testOccurrences.set(testBase, testOccurrence + 1)\n      if (tests[i]!.status === 'failed') {\n        const path: string[] = []\n        for (let depth = 1; depth < stack.length; depth += 1) path.push(stack[depth]!.key!)\n        path.push(key)\n        return { suites: path, test: repeatedKey(testBase, testOccurrence) }\n      }\n    }\n    if (suite.suites?.length) {\n      stack.push({ suites: suite.suites, index: 0, occurrences: new Map(), key })\n    }\n  }\n  return undefined\n}\n"],"mappings":"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"}

package/dist/components/composites/test-results/test-results.d.ts

@@ -0,0 +1,60 @@
+import { type ComponentProps, type JSX } from 'solid-js';
+import { type StackTraceProps } from '../stack-trace';
+import { type TestSuite, type TestSummary } from './test-results-model';
+/**
+ * TestResults.
+ *
+ * A test run: how it went in words and in a segmented bar, then the suites it
+ * ran as `Trace` lines, each opening onto its tests, and a failing test opening
+ * onto its message, diff and stack. It is for a run the host can structure; reach
+ * for `Terminal` when all there is to show is the command's output, and for
+ * `StackTrace` alone when one call failed outside a test.
+ *
+ * ## Counts are claims
+ *
+ * Nothing is computed that the host did not supply data for, and nothing the host
+ * supplied is quietly recomputed. `summary` is the host's own tally and is shown
+ * as given. If tests are listed and their number for an outcome does not match, the
+ * listed number is shown beside it — "40 passed (2 listed)" — which is also how a
+ * host that lists only its failures reads. Without a `summary` the counts shown are
+ * those of the tests listed, and the component says so; it does not present them as
+ * the run's totals. A suite is marked failed or passed only from the tests listed in
+ * it, and its spoken label says "listed" so it claims no more than that.
+ *
+ * ## Not colour-only
+ *
+ * The bar is decoration: every segment has a counterpart in the words beside it,
+ * each with its own shape (a cross, a tick, a dash). Segments are separated by a
+ * gap and never narrower than a visible sliver, so one failure in five thousand
+ * tests is still on the bar.
+ *
+ * ## Bounded
+ *
+ * Suites and tests are listed `listLimit` at a time with "show more", and a suite's
+ * tests are not rendered until it is open. The first failure in reading order opens
+ * when its row is visible; a failure beyond a "show more" boundary stays unmounted
+ * until its page is revealed. When a running result first reports a failure, its
+ * suite and test open once. Later updates preserve the user's disclosure choices.
+ *
+ * Failure details are text: the message is a `pre`, the diff goes to `DiffBlock`
+ * and the stack to `StackTrace`. If a stack already begins with the message, pass
+ * only the stack; nothing here de-duplicates what the host sends.
+ */
+export type TestResultsProps = Omit<ComponentProps<'section'>, 'children'> & {
+    suites: readonly TestSuite[];
+    /** The host's own counts. Shown as given; see the component comment. */
+    summary?: TestSummary;
+    /** The run is still going. */
+    running?: boolean;
+    /** Suites, or tests within a suite, listed before "show more". Default 50. */
+    listLimit?: number;
+    /** Passed to each failure's `StackTrace`. */
+    onOpenFrame?: StackTraceProps['onOpenFrame'];
+    /** The section's accessible name. Default "Test results". */
+    label?: string;
+};
+export declare const TEST_RESULTS_LIST_LIMIT = 50;
+/** Characters of a failure message drawn before the rest is offered. */
+export declare const TEST_RESULTS_MESSAGE_LIMIT = 4000;
+export declare function TestResults(props: TestResultsProps): JSX.Element;
+//# sourceMappingURL=test-results.d.ts.map

package/dist/components/composites/test-results/test-results.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-results.d.ts","sourceRoot":"","sources":["../../../../src/components/composites/test-results/test-results.tsx"],"names":[],"mappings":"AASA,OAAO,EASL,KAAK,cAAc,EACnB,KAAK,GAAG,EACT,MAAM,UAAU,CAAA;AAMjB,OAAO,EAAc,KAAK,eAAe,EAAE,MAAM,gBAAgB,CAAA;AACjE,OAAO,EAcL,KAAK,SAAS,EACd,KAAK,WAAW,EAEjB,MAAM,sBAAsB,CAAA;AAE7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,MAAM,MAAM,gBAAgB,GAAG,IAAI,CAAC,cAAc,CAAC,SAAS,CAAC,EAAE,UAAU,CAAC,GAAG;IAC3E,MAAM,EAAE,SAAS,SAAS,EAAE,CAAA;IAC5B,wEAAwE;IACxE,OAAO,CAAC,EAAE,WAAW,CAAA;IACrB,8BAA8B;IAC9B,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,8EAA8E;IAC9E,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,6CAA6C;IAC7C,WAAW,CAAC,EAAE,eAAe,CAAC,aAAa,CAAC,CAAA;IAC5C,6DAA6D;IAC7D,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAED,eAAO,MAAM,uBAAuB,KAAK,CAAA;AAyHzC,wEAAwE;AACxE,eAAO,MAAM,0BAA0B,OAAQ,CAAA;AAgR/C,wBAAgB,WAAW,CAAC,KAAK,EAAE,gBAAgB,eA4FlD"}