testeranto 0.177.0 → 0.189.0

package/dist/module/src/components/pure/TestPageView.js

@@ -1,9 +1,61 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import React from 'react';
-import { Tab, Container, Alert, Button } from 'react-bootstrap';
-import { NavBar } from '../../NavBar';
+import { Container, Row, Col, Nav, Alert, Button } from 'react-bootstrap';
+import { NavBar } from './NavBar';
 import { TestStatusBadge } from '../TestStatusBadge';
-export const TestPageView = ({ route, setRoute, navigate, projectName, testName, decodedTestPath, runtime, testData, logs, typeErrors, lintErrors, testsExist, errorCounts, }) => {
-    return (React.createElement(Container, { fluid: true },
+export const TestPageView = ({ projectName, testName, decodedTestPath, runtime, testsExist, errorCounts, logs, }) => {
+    const [activeTab, setActiveTab] = React.useState('tests.json');
+    const renderTestResults = (testData) => {
+        return (React.createElement("div", { className: "test-results" }, testData.givens.map((given, i) => (React.createElement("div", { key: i, className: "mb-4 card" },
+            React.createElement("div", { className: "card-header bg-primary text-white" },
+                React.createElement("div", { className: "d-flex justify-content-between align-items-center" },
+                    React.createElement("div", null,
+                        React.createElement("h4", null,
+                            "Given: ",
+                            given.name),
+                        given.features && given.features.length > 0 && (React.createElement("div", { className: "mt-1" },
+                            React.createElement("small", null, "Features:"),
+                            React.createElement("ul", { className: "list-unstyled" }, given.features.map((feature, fi) => (React.createElement("li", { key: fi }, feature.startsWith('http') ? (React.createElement("a", { href: feature, target: "_blank", rel: "noopener noreferrer", className: "text-white" }, new URL(feature).hostname)) : (React.createElement("span", { className: "text-white" }, feature))))))))),
+                    given.artifacts && given.artifacts.length > 0 && (React.createElement("div", { className: "dropdown" },
+                        React.createElement("button", { className: "btn btn-sm btn-light dropdown-toggle", type: "button", "data-bs-toggle": "dropdown" },
+                            "Artifacts (",
+                            given.artifacts.length,
+                            ")"),
+                        React.createElement("ul", { className: "dropdown-menu dropdown-menu-end" }, given.artifacts.map((artifact, ai) => (React.createElement("li", { key: ai },
+                            React.createElement("a", { className: "dropdown-item", href: `reports/${projectName}/${testName.split('.').slice(0, -1).join('.')}/${runtime}/${artifact}`, target: "_blank", rel: "noopener noreferrer" }, artifact.split('/').pop()))))))))),
+            React.createElement("div", { className: "card-body" },
+                given.whens.map((when, j) => (React.createElement("div", { key: `w-${j}`, className: `p-3 mb-2 ${when.error ? 'bg-danger text-white' : 'bg-success text-white'}` },
+                    React.createElement("div", { className: "d-flex justify-content-between align-items-start" },
+                        React.createElement("div", null,
+                            React.createElement("div", null,
+                                React.createElement("strong", null, "When:"),
+                                " ",
+                                when.name,
+                                when.features && when.features.length > 0 && (React.createElement("div", { className: "mt-2" },
+                                    React.createElement("small", null, "Features:"),
+                                    React.createElement("ul", { className: "list-unstyled" }, when.features.map((feature, fi) => (React.createElement("li", { key: fi }, feature.startsWith('http') ? (React.createElement("a", { href: feature, target: "_blank", rel: "noopener noreferrer" }, new URL(feature).hostname)) : (feature))))))),
+                                when.error && React.createElement("pre", { className: "mt-2" }, when.error))),
+                        when.artifacts && when.artifacts.length > 0 && (React.createElement("div", { className: "ms-3" },
+                            React.createElement("strong", null, "Artifacts:"),
+                            React.createElement("ul", { className: "list-unstyled" }, when.artifacts.map((artifact, ai) => (React.createElement("li", { key: ai },
+                                React.createElement("a", { href: `reports/${projectName}/${testName.split('.').slice(0, -1).join('.')}/${runtime}/${artifact}`, target: "_blank", className: "text-white", rel: "noopener noreferrer" }, artifact.split('/').pop()))))))))))),
+                given.thens.map((then, k) => (React.createElement("div", { key: `t-${k}`, className: `p-3 mb-2 ${then.error ? 'bg-danger text-white' : 'bg-success text-white'}` },
+                    React.createElement("div", { className: "d-flex justify-content-between align-items-start" },
+                        React.createElement("div", null,
+                            React.createElement("div", null,
+                                React.createElement("strong", null, "Then:"),
+                                " ",
+                                then.name,
+                                then.features && then.features.length > 0 && (React.createElement("div", { className: "mt-2" },
+                                    React.createElement("small", null, "Features:"),
+                                    React.createElement("ul", { className: "list-unstyled" }, then.features.map((feature, fi) => (React.createElement("li", { key: fi }, feature.startsWith('http') ? (React.createElement("a", { href: feature, target: "_blank", rel: "noopener noreferrer" }, new URL(feature).hostname)) : (feature))))))),
+                                then.error && React.createElement("pre", { className: "mt-2" }, then.error))),
+                        then.artifacts && then.artifacts.length > 0 && (React.createElement("div", { className: "ms-3" },
+                            React.createElement("strong", null, "Artifacts:"),
+                            React.createElement("ul", { className: "list-unstyled" }, then.artifacts.map((artifact, ai) => (React.createElement("li", { key: ai },
+                                React.createElement("a", { href: `reports/${projectName}/${testName.split('.').slice(0, -1).join('.')}/${runtime}/${artifact}`, target: "_blank", className: "text-white", rel: "noopener noreferrer" }, artifact.split('/').pop())))))))))))))))));
+    };
+    return (React.createElement(Container, { fluid: true, className: "px-0" },
         React.createElement(NavBar, { title: decodedTestPath, backLink: `/projects/${projectName}`, navItems: [
                 {
                     label: '',
@@ -14,34 +66,7 @@ export const TestPageView = ({ route, setRoute, navigate, projectName, testName,
                         text: runtime
                     },
                     className: 'pe-none d-flex align-items-center gap-2'
-                },
-                {
-                    to: `#results`,
-                    label: (React.createElement(TestStatusBadge, { testName: decodedTestPath, testsExist: testsExist, runTimeErrors: errorCounts.runTimeErrors, variant: "compact" })),
-                    className: !testsExist || errorCounts.runTimeErrors > 0
-                        ? 'text-danger fw-bold'
-                        : '',
-                    active: route === 'results'
-                },
-                {
-                    to: `#logs`,
-                    label: `Runtime logs`,
-                    active: route === 'logs'
-                },
-                {
-                    to: `#types`,
-                    label: errorCounts.typeErrors > 0
-                        ? `tsc (❌ * ${errorCounts.typeErrors})`
-                        : 'tsc ✅ ',
-                    active: route === 'types'
-                },
-                {
-                    to: `#lint`,
-                    label: errorCounts.staticErrors > 0
-                        ? `eslint (❌ *${errorCounts.staticErrors}) `
-                        : 'eslint ✅',
-                    active: route === 'lint'
-                },
+                }
             ], rightContent: React.createElement(Button, { variant: "info", onClick: async () => {
                     try {
                         const promptPath = `testeranto/reports/${projectName}/${testName.split('.').slice(0, -1).join('.')}/${runtime}/prompt.txt`;
@@ -55,94 +80,48 @@ export const TestPageView = ({ route, setRoute, navigate, projectName, testName,
                         console.error("Copy failed:", err);
                     }
                 }, className: "ms-2" }, "\uD83E\uDD16") }),
-        React.createElement(Tab.Container, { activeKey: route, onSelect: (k) => {
-                if (k) {
-                    setRoute(k);
-                    navigate(`#${k}`, { replace: true });
-                }
-            } },
-            React.createElement(Tab.Content, { className: "mt-3" },
-                React.createElement(Tab.Pane, { eventKey: "results" }, !testsExist ? (React.createElement(Alert, { variant: "danger", className: "mt-3" },
+        React.createElement(Row, { className: "g-0" },
+            React.createElement(Col, { sm: 3, className: "border-end" },
+                React.createElement(Nav, { variant: "pills", className: "flex-column" }, Object.keys(logs).map((logName) => {
+                    var _a;
+                    const displayName = logName.replace('.json', '').replace(/_/g, ' ');
+                    let statusIndicator = null;
+                    // Add error indicators for specific log types
+                    if (logName === 'type_errors.txt' && errorCounts.typeErrors > 0) {
+                        statusIndicator = React.createElement("span", { className: "ms-1" },
+                            "\u274C ",
+                            errorCounts.typeErrors);
+                    }
+                    else if (logName === 'lint_errors.txt' && errorCounts.staticErrors > 0) {
+                        statusIndicator = React.createElement("span", { className: "ms-1" },
+                            "\u274C ",
+                            errorCounts.staticErrors);
+                    }
+                    else if (logName === 'stderr.log' && errorCounts.runTimeErrors > 0) {
+                        statusIndicator = React.createElement("span", { className: "ms-1" },
+                            "\u274C ",
+                            errorCounts.runTimeErrors);
+                    }
+                    else if (logName === 'exit.log' && ((_a = logs['exit.log']) === null || _a === void 0 ? void 0 : _a.trim()) !== '0') {
+                        statusIndicator = React.createElement("span", { className: "ms-1" }, "\u26A0\uFE0F");
+                    }
+                    else if (logName === 'tests.json' && logs['tests.json']) {
+                        statusIndicator = React.createElement("div", { className: "ms-1" },
+                            React.createElement(TestStatusBadge, { testName: decodedTestPath, testsExist: testsExist, runTimeErrors: errorCounts.runTimeErrors, typeErrors: errorCounts.typeErrors, staticErrors: errorCounts.staticErrors, variant: "compact", className: "mt-1" }));
+                    }
+                    return (React.createElement(Nav.Item, { key: logName },
+                        React.createElement(Nav.Link, { eventKey: logName, active: activeTab === logName, onClick: () => setActiveTab(logName), className: "d-flex flex-column align-items-start" },
+                            React.createElement("div", { className: "d-flex justify-content-between w-100" },
+                                React.createElement("span", { className: "text-capitalize" }, displayName),
+                                statusIndicator))));
+                }))),
+            React.createElement(Col, { sm: 9 },
+                React.createElement("div", { className: "p-3" }, !testsExist && activeTab === 'tests.json' ? (React.createElement(Alert, { variant: "danger" },
                     React.createElement("h4", null, "Tests did not run to completion"),
-                    React.createElement("p", null, "The test results file (tests.json) was not found or could not be loaded."),
-                    React.createElement("div", { className: "mt-3" },
-                        React.createElement(Button, { variant: "outline-light", onClick: () => setRoute('logs'), className: "me-2" }, "View Runtime Logs"),
-                        React.createElement(Button, { variant: "outline-light", onClick: () => navigate(`/projects/${projectName}#${runtime}`) }, "View Build Logs")))) : testData ? (React.createElement("div", { className: "test-results" }, testData.givens.map((given, i) => {
-                    var _a, _b;
-                    return (React.createElement("div", { key: i, className: "mb-4 card" },
-                        React.createElement("div", { className: "card-header bg-primary text-white" },
-                            React.createElement("div", { className: "d-flex justify-content-between align-items-center" },
-                                React.createElement("div", null,
-                                    React.createElement("h4", null,
-                                        "Given: ",
-                                        given.name),
-                                    ((_a = given.features) === null || _a === void 0 ? void 0 : _a.length) > 0 && (React.createElement("div", { className: "mt-1" },
-                                        React.createElement("small", null, "Features:"),
-                                        React.createElement("ul", { className: "list-unstyled" }, given.features.map((feature, fi) => (React.createElement("li", { key: fi }, feature.startsWith('http') ? (React.createElement("a", { href: feature, target: "_blank", rel: "noopener noreferrer", className: "text-white" }, new URL(feature).hostname)) : (React.createElement("span", { className: "text-white" }, feature))))))))),
-                                ((_b = given.artifacts) === null || _b === void 0 ? void 0 : _b.length) > 0 && (React.createElement("div", { className: "dropdown" },
-                                    React.createElement("button", { className: "btn btn-sm btn-light dropdown-toggle", type: "button", "data-bs-toggle": "dropdown" },
-                                        "Artifacts (",
-                                        given.artifacts.length,
-                                        ")"),
-                                    React.createElement("ul", { className: "dropdown-menu dropdown-menu-end" }, given.artifacts.map((artifact, ai) => (React.createElement("li", { key: ai },
-                                        React.createElement("a", { className: "dropdown-item", href: `/testeranto/reports/${projectName}/${testName.split('.').slice(0, -1).join('.')}/${runtime}/${artifact}`, target: "_blank", rel: "noopener noreferrer" }, artifact.split('/').pop()))))))))),
-                        React.createElement("div", { className: "card-body" },
-                            given.whens.map((when, j) => {
-                                var _a, _b;
-                                return (React.createElement("div", { key: `w-${j}`, className: `p-3 mb-2 ${when.error ? 'bg-danger text-white' : 'bg-success text-white'}` },
-                                    React.createElement("div", { className: "d-flex justify-content-between align-items-start" },
-                                        React.createElement("div", null,
-                                            React.createElement("div", null,
-                                                React.createElement("strong", null, "When:"),
-                                                " ",
-                                                when.name,
-                                                ((_a = when.features) === null || _a === void 0 ? void 0 : _a.length) > 0 && (React.createElement("div", { className: "mt-2" },
-                                                    React.createElement("small", null, "Features:"),
-                                                    React.createElement("ul", { className: "list-unstyled" }, when.features.map((feature, fi) => (React.createElement("li", { key: fi }, feature.startsWith('http') ? (React.createElement("a", { href: feature, target: "_blank", rel: "noopener noreferrer" }, new URL(feature).hostname)) : (feature))))))),
-                                                when.error && React.createElement("pre", { className: "mt-2" }, when.error))),
-                                        ((_b = when.artifacts) === null || _b === void 0 ? void 0 : _b.length) > 0 && (React.createElement("div", { className: "ms-3" },
-                                            React.createElement("strong", null, "Artifacts:"),
-                                            React.createElement("ul", { className: "list-unstyled" }, when.artifacts.map((artifact, ai) => (React.createElement("li", { key: ai },
-                                                React.createElement("a", { href: `/testeranto/reports/${projectName}/${testName.split('.').slice(0, -1).join('.')}/${runtime}/${artifact}`, target: "_blank", className: "text-white", rel: "noopener noreferrer" }, artifact.split('/').pop()))))))))));
-                            }),
-                            given.thens.map((then, k) => {
-                                var _a, _b;
-                                return (React.createElement("div", { key: `t-${k}`, className: `p-3 mb-2 ${then.error ? 'bg-danger text-white' : 'bg-success text-white'}` },
-                                    React.createElement("div", { className: "d-flex justify-content-between align-items-start" },
-                                        React.createElement("div", null,
-                                            React.createElement("div", null,
-                                                React.createElement("strong", null, "Then:"),
-                                                " ",
-                                                then.name,
-                                                ((_a = then.features) === null || _a === void 0 ? void 0 : _a.length) > 0 && (React.createElement("div", { className: "mt-2" },
-                                                    React.createElement("small", null, "Features:"),
-                                                    React.createElement("ul", { className: "list-unstyled" }, then.features.map((feature, fi) => (React.createElement("li", { key: fi }, feature.startsWith('http') ? (React.createElement("a", { href: feature, target: "_blank", rel: "noopener noreferrer" }, new URL(feature).hostname)) : (feature))))))),
-                                                then.error && React.createElement("pre", { className: "mt-2" }, then.error))),
-                                        ((_b = then.artifacts) === null || _b === void 0 ? void 0 : _b.length) > 0 && (React.createElement("div", { className: "ms-3" },
-                                            React.createElement("strong", null, "Artifacts:"),
-                                            React.createElement("ul", { className: "list-unstyled" }, then.artifacts.map((artifact, ai) => (React.createElement("li", { key: ai },
-                                                React.createElement("a", { href: `/testeranto/reports/${projectName}/${testName.split('.').slice(0, -1).join('.')}/${runtime}/${artifact}`, target: "_blank", className: "text-white", rel: "noopener noreferrer" }, artifact.split('/').pop()))))))))));
-                            }))));
-                }))) : (React.createElement(Alert, { variant: "warning" }, "No test results found"))),
-                React.createElement(Tab.Pane, { eventKey: "logs" }, logs === undefined ? (React.createElement(Alert, { variant: "danger" },
-                    React.createElement("h4", null, "Logs file missing"),
-                    React.createElement("p", null, "The runtime logs file (logs.txt) was not found."),
-                    React.createElement("p", null, "This suggests the test may not have executed properly."))) : logs === '' ? (React.createElement(Alert, { variant: "success" },
-                    React.createElement("h4", null, "No runtime logs"),
-                    React.createElement("p", null, "The test executed successfully with no log output."))) : (React.createElement("pre", { className: "bg-dark text-white p-3" }, logs))),
-                React.createElement(Tab.Pane, { eventKey: "types" }, typeErrors ? (React.createElement("pre", { className: "bg-dark text-white p-3" }, typeErrors)) : (React.createElement(Alert, { variant: "warning" }, "No type errors found"))),
-                React.createElement(Tab.Pane, { eventKey: "lint" }, lintErrors ? (React.createElement("pre", { className: "bg-dark text-white p-3" }, lintErrors)) : (React.createElement(Alert, { variant: "warning" }, "No lint errors found"))),
-                React.createElement(Tab.Pane, { eventKey: "coverage" },
-                    React.createElement("div", { className: "coverage-report" },
-                        React.createElement(Alert, { variant: "info" }, "Coverage reports coming soon!"),
-                        React.createElement("div", { className: "coverage-stats" },
-                            React.createElement("div", { className: "stat-card bg-success text-white" },
-                                React.createElement("h4", null, "85%"),
-                                React.createElement("p", null, "Lines Covered")),
-                            React.createElement("div", { className: "stat-card bg-warning text-dark" },
-                                React.createElement("h4", null, "72%"),
-                                React.createElement("p", null, "Branches Covered")),
-                            React.createElement("div", { className: "stat-card bg-info text-white" },
-                                React.createElement("h4", null, "91%"),
-                                React.createElement("p", null, "Functions Covered")))))))));
+                    React.createElement("p", null, "The test results file (tests.json) was not found or could not be loaded."))) : activeTab === 'tests.json' && logs['tests.json'] ? (typeof logs['tests.json'] === 'string'
+                    ? renderTestResults(JSON.parse(logs['tests.json']))
+                    : renderTestResults(logs['tests.json'])) : logs[activeTab] ? (React.createElement("pre", { className: "bg-dark text-white p-3" },
+                    React.createElement("code", null, typeof logs[activeTab] === 'string'
+                        ? logs[activeTab]
+                        : JSON.stringify(logs[activeTab], null, 2)))) : (React.createElement(Alert, { variant: "info" }, "No content available for this log")))))));
 };

package/dist/module/src/components/pure/TestPageView.test/implementation.js

@@ -0,0 +1,166 @@
+/* eslint-disable @typescript-eslint/no-empty-object-type */
+import { assert } from "chai";
+import * as React from "react";
+import * as ReactDom from "react-dom/client";
+const mockTestData = {
+    name: "Test Suite",
+    givens: [
+        {
+            name: "Given Scenario",
+            whens: [{ name: "When Action" }],
+            thens: [{ name: "Then Assertion" }],
+        },
+    ],
+};
+export const implementation = {
+    suites: {
+        Default: "TestPageView basic rendering",
+        Navigation: "TestPageView navigation behavior",
+        ErrorStates: "TestPageView error handling",
+    },
+    givens: {
+        Default: () => ({
+            route: "results",
+            setRoute: () => { },
+            navigate: () => { },
+            projectName: "test-project",
+            testName: "test-suite.test.ts",
+            decodedTestPath: "test-suite",
+            runtime: "node",
+            testData: mockTestData,
+            logs: "Test logs content",
+            typeErrors: "",
+            lintErrors: "",
+            testsExist: true,
+            errorCounts: {
+                runTimeErrors: 0, // BDD test failures
+                typeErrors: 0, // Type checker errors
+                staticErrors: 0, // Linter errors
+            },
+        }),
+        WithErrors: () => ({
+            route: "results",
+            setRoute: () => { },
+            navigate: () => { },
+            projectName: "test-project",
+            testName: "test-suite.test.ts",
+            decodedTestPath: "test-suite",
+            runtime: "node",
+            testData: null, // Missing tests.json indicates BDD failure
+            logs: undefined,
+            typeErrors: "Type error message", // Only shown if tests.json exists
+            lintErrors: "Lint error message", // Only shown if tests.json exists
+            testsExist: false,
+            errorCounts: {
+                runTimeErrors: 1, // Highest priority - BDD failed
+                typeErrors: 2, // Secondary - type errors
+                staticErrors: 3, // Lowest priority - linter errors
+            },
+        }),
+        WithLogs: () => ({
+            route: "logs",
+            setRoute: () => { },
+            navigate: () => { },
+            projectName: "test-project",
+            testName: "test-suite.test.ts",
+            decodedTestPath: "test-suite",
+            runtime: "node",
+            testData: mockTestData,
+            logs: "Detailed test logs\nLine 1\nLine 2",
+            typeErrors: "",
+            lintErrors: "",
+            testsExist: true,
+            errorCounts: {
+                runTimeErrors: 0,
+                typeErrors: 0,
+                staticErrors: 0,
+            },
+        }),
+    },
+    whens: {
+        SwitchToTab: (tabName) => (selection) => {
+            selection.reactElement = React.cloneElement(selection.reactElement, {
+                route: tabName,
+            });
+            ReactDom.createRoot(selection.domRoot).render(selection.reactElement);
+            return selection;
+        },
+        ClickAiderButton: () => (selection) => {
+            const button = selection.container.querySelector('button[aria-label="Aider"]');
+            if (button) {
+                button.click();
+            }
+            return selection;
+        },
+    },
+    thens: {
+        takeScreenshot: (name) => async ({ htmlElement }, pm) => {
+            const p = await pm.page();
+            await pm.customScreenShot({ path: name }, p);
+            return { htmlElement };
+        },
+        RendersNavBar: () => async (selection) => {
+            const navBar = selection.container.querySelector(".navbar");
+            assert.isNotNull(navBar);
+            return selection;
+        },
+        ShowsActiveTab: (tabName) => async (selection) => {
+            const activeTab = selection.container.querySelector(".tab-pane.active");
+            assert.include(activeTab === null || activeTab === void 0 ? void 0 : activeTab.textContent, tabName);
+            return selection;
+        },
+        ShowsErrorCounts: () => async (selection) => {
+            const badges = selection.container.querySelectorAll(".badge");
+            // First check for BDD failures
+            if (!selection.testsExist) {
+                assert.isAbove(badges.length, 0);
+                const bddBadge = selection.container.querySelector(".badge.bg-danger");
+                assert.isNotNull(bddBadge);
+            }
+            // Then check type errors if BDD passed
+            else if (selection.errorCounts.typeErrors > 0) {
+                const typeBadge = selection.container.querySelector(".badge.bg-warning");
+                assert.isNotNull(typeBadge);
+            }
+            // Finally check linter errors if both above passed
+            else if (selection.errorCounts.staticErrors > 0) {
+                const lintBadge = selection.container.querySelector(".badge.bg-info");
+                assert.isNotNull(lintBadge);
+            }
+            return selection;
+        },
+        ShowsTestResults: () => async (selection) => {
+            // Only expect test results if BDD tests passed
+            if (selection.testsExist) {
+                const testResults = selection.container.querySelector(".test-results");
+                assert.isNotNull(testResults);
+            }
+            return selection;
+        },
+        ShowsLogs: () => async (selection) => {
+            const logs = selection.container.querySelector("pre");
+            assert.isNotNull(logs);
+            return selection;
+        },
+        ShowsTypeErrors: () => async (selection) => {
+            const typeErrors = selection.container.querySelector("#types-tab");
+            assert.isNotNull(typeErrors);
+            return selection;
+        },
+        ShowsLintErrors: () => async (selection) => {
+            const lintErrors = selection.container.querySelector("#lint-tab");
+            assert.isNotNull(lintErrors);
+            return selection;
+        },
+        AiderButtonCopiesCommand: () => async (selection) => {
+            Object.assign(navigator, {
+                clipboard: {
+                    writeText: jest.fn().mockResolvedValue(undefined),
+                },
+            });
+            await implementation.whens.ClickAiderButton()(selection);
+            assert.isTrue(navigator.clipboard.writeText.called);
+            return selection;
+        },
+    },
+};

package/dist/module/src/components/pure/TestPageView.test/index.js

@@ -0,0 +1,10 @@
+import Testeranto from "testeranto-react/src/react-dom/jsx/web";
+import { MemoryRouter } from "react-router-dom";
+import { implementation } from "./implementation";
+import { specification } from "./specification";
+import { TestPageView } from "../TestPageView";
+import React from "react";
+import "./../../../App.scss";
+const WrappedTestPageView = (props) => (React.createElement(MemoryRouter, null,
+    React.createElement(TestPageView, Object.assign({}, props))));
+export default Testeranto(implementation, specification, WrappedTestPageView);

package/dist/module/src/components/pure/TestPageView.test/specification.js

@@ -0,0 +1,22 @@
+export const specification = (Suite, Given, When, Then) => {
+    return [
+        Suite.Default("TestPageView basic rendering", {
+            "renders navigation bar": Given.Default([], [], [Then.RendersNavBar()]),
+            "shows error counts": Given.Default([], [], [Then.ShowsErrorCounts()]),
+            "shows test results when data exists": Given.Default([], [], [Then.takeScreenshot("shot.png"), Then.ShowsTestResults()]),
+        }),
+        Suite.Navigation("TestPageView navigation behavior", {
+            "shows results tab by default": Given.Default([], [], [Then.ShowsActiveTab("results")]),
+            "switches to logs tab": Given.Default([], [When.SwitchToTab("logs")], [Then.ShowsActiveTab("logs"), Then.ShowsLogs()]),
+            "copies aider command when button clicked": Given.Default([], [When.ClickAiderButton()], [Then.AiderButtonCopiesCommand()]),
+        }),
+        Suite.ErrorStates("TestPageView error handling", {
+            "shows error state when tests fail": Given.WithErrors([], [], [
+                Then.ShowsErrorCounts(),
+                Then.ShowsTypeErrors(),
+                Then.ShowsLintErrors(),
+            ]),
+            "shows logs when available": Given.WithLogs([], [], [Then.ShowsLogs()]),
+        }),
+    ];
+};

package/dist/module/src/components/pure/TestPageView.test/types.js

@@ -0,0 +1,3 @@
+/* eslint-disable @typescript-eslint/no-empty-object-type */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export {};

package/dist/module/src/components/pure/ThemeCard.js

@@ -0,0 +1,8 @@
+import React from "react";
+export const ThemeCard = ({ theme, handleThemeChange, value, title, description, style, }) => (React.createElement("div", { className: "col-md-4" },
+    React.createElement("div", { className: `card theme-card ${theme === value ? "border-primary" : ""}`, onClick: () => handleThemeChange({
+            target: { value },
+        }), style: style },
+        React.createElement("div", { className: "card-body text-center p-3" },
+            React.createElement("h5", { className: "card-title mb-1" }, title),
+            React.createElement("p", { className: "small text-muted mb-0" }, description)))));

package/dist/module/src/components/stateful/FeaturesReporter.js

@@ -0,0 +1,22 @@
+import React, { useEffect, useState } from 'react';
+import { FeaturesReporterView } from '../pure/FeaturesReporterView';
+import { buildTree } from '../../types/features';
+export const FeaturesReporter = () => {
+    const [treeData, setTreeData] = useState([]);
+    useEffect(() => {
+        const fetchProjects = async () => {
+            try {
+                const response = await fetch('testeranto/projects.json');
+                if (!response.ok)
+                    throw new Error('Failed to fetch projects');
+                const projectNames = await response.json();
+                setTreeData(buildTree(projectNames));
+            }
+            catch (error) {
+                console.error('Error loading projects:', error);
+            }
+        };
+        fetchProjects();
+    }, []);
+    return React.createElement(FeaturesReporterView, { treeData: treeData });
+};

package/dist/module/src/components/stateful/ProjectPage.js

@@ -59,5 +59,5 @@ export const ProjectPage = () => {
         };
         fetchData();
     }, [name]);
-    return (React.createElement(ProjectPageView, { summary: summary, nodeLogs: nodeLogs, webLogs: webLogs, pureLogs: pureLogs, config: config, loading: loading, error: error, projectName: projectName, route: route, setRoute: setRoute, navigate: navigate }));
+    return (React.createElement(ProjectPageView, { summary: summary, nodeLogs: nodeLogs, webLogs: webLogs, pureLogs: pureLogs, config: config, loading: loading, error: error, projectName: projectName, activeTab: route, setActiveTab: setRoute }));
 };

package/dist/module/src/components/stateful/TestPage.js

@@ -1,7 +1,8 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
 import React, { useEffect, useState } from 'react';
 import { useLocation, useNavigate, useParams } from 'react-router-dom';
-import { TestPageView } from '../pure/TestPageView';
 import { fetchTestData } from '../../utils/api';
+import { TestPageView } from '../pure/TestPageView';
 export const TestPage = () => {
     const navigate = useNavigate();
     const location = useLocation();
@@ -17,10 +18,10 @@ export const TestPage = () => {
         }
     }, [location.hash]);
     const [testName, setTestName] = useState('');
-    const [testData, setTestData] = useState(null);
-    const [logs, setLogs] = useState('');
-    const [typeErrors, setTypeErrors] = useState('');
-    const [lintErrors, setLintErrors] = useState('');
+    // const [testData, setTestData] = useState(null);
+    const [logs, setLogs] = useState({});
+    // const [typeErrors, setTypeErrors] = useState('');
+    // const [lintErrors, setLintErrors] = useState('');
     const [loading, setLoading] = useState(true);
     const [error, setError] = useState(null);
     const [testsExist, setTestsExist] = useState(true);
@@ -42,11 +43,22 @@ export const TestPage = () => {
         const fetchData = async () => {
             try {
                 const testResponse = await fetchTestData(projectName, testPath, runtime);
-                setTestData(testResponse.testData);
-                setTestsExist(!!testResponse.testData);
-                setLogs(testResponse.logs === null ? undefined : testResponse.logs);
-                setTypeErrors(testResponse.typeErrors);
-                setLintErrors(testResponse.lintErrors);
+                console.log("testResponse", testResponse);
+                // setTestData(testResponse.testData);
+                // setTestsExist(!!testResponse.testData);
+                const receivedLogs = await testResponse.logs;
+                // Ensure tests.json is properly formatted
+                if (receivedLogs['tests.json'] && typeof receivedLogs['tests.json'] === 'string') {
+                    try {
+                        receivedLogs['tests.json'] = JSON.parse(receivedLogs['tests.json']);
+                    }
+                    catch (e) {
+                        console.error('Failed to parse tests.json:', e);
+                    }
+                }
+                setLogs(receivedLogs);
+                // setTypeErrors(testResponse.typeErrors);
+                // setLintErrors(testResponse.lintErrors);
                 try {
                     const summaryResponse = await fetch(`reports/${projectName}/summary.json`);
                     if (!summaryResponse.ok)
@@ -78,5 +90,7 @@ export const TestPage = () => {
         };
         fetchData();
     }, []);
-    return (React.createElement(TestPageView, { route: route, setRoute: setRoute, navigate: navigate, projectName: projectName, testName: testName, decodedTestPath: decodedTestPath, runtime: runtime, testData: testData, logs: logs, typeErrors: typeErrors, lintErrors: lintErrors, loading: loading, error: error, testsExist: testsExist, errorCounts: errorCounts, summary: summary }));
+    if (!logs)
+        return React.createElement("div", null, "loading...");
+    return (React.createElement(TestPageView, { route: route, setRoute: setRoute, navigate: navigate, projectName: projectName, testName: testName, decodedTestPath: decodedTestPath, runtime: runtime, logs: logs, testsExist: testsExist, errorCounts: errorCounts }));
 };

package/dist/module/src/defaultConfig.js

@@ -9,6 +9,7 @@ const config = {
     nodePlugins: [],
     webPlugins: [],
     importPlugins: [],
+    webLoaders: {},
     featureIngestor: function (s) {
         throw new Error("Function not implemented.");
     },

package/dist/module/src/esbuildConfigs/web.js

@@ -26,7 +26,7 @@ export default (config, entryPoints, testName) => {
             "util",
             "process",
             "dns",
-        ], platform: "browser", entryPoints: [...entryPoints], plugins: [
+        ], platform: "browser", entryPoints: [...entryPoints], loader: config.webLoaders, plugins: [
             featuresPlugin,
             inputFilesPluginFactory,
             polyfillNode({

package/dist/module/src/lib/BaseSuite.js

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
 import { beforeAllProxy, afterAllProxy } from "./pmProxy";
 export class BaseSuite {
     addArtifact(path) {

package/dist/module/src/lib/BaseSuite.test/mock.js

@@ -17,11 +17,8 @@ export class MockGiven extends BaseGiven {
 }
 export class MockWhen extends BaseWhen {
     async andWhen(store, whenCB, testResource, pm) {
-        console.log("[DEBUG] MockWhen - andWhen - input store:", JSON.stringify(store));
         const newStore = Object.assign(Object.assign({}, store), { testSelection: true });
-        console.log("[DEBUG] MockWhen - andWhen - calling whenCB");
         const result = await whenCB(newStore);
-        console.log("[DEBUG] MockWhen - andWhen - result:", JSON.stringify(result));
         return result;
     }
     addArtifact(name, content) {
@@ -31,10 +28,6 @@ export class MockWhen extends BaseWhen {
 }
 export class MockThen extends BaseThen {
     async butThen(store, thenCB, testResourceConfiguration, pm) {
-        console.log("[DEBUG] MockThen - butThen - input store:", JSON.stringify(store));
-        if (!store) {
-            throw new Error("Store is undefined in butThen");
-        }
         // Create test selection with explicit type
         const testSelection = {
             name: store.name,
@@ -42,10 +35,8 @@ export class MockThen extends BaseThen {
             testSelection: store.testSelection || false,
             error: store.error ? true : undefined,
         };
-        console.log("[DEBUG] MockThen - passing testSelection:", JSON.stringify(testSelection));
         try {
             const result = await thenCB(testSelection);
-            console.log("[DEBUG] MockThen - received result:", JSON.stringify(result));
             if (!result || typeof result.testSelection === "undefined") {
                 throw new Error(`Invalid test selection result: ${JSON.stringify(result)}`);
             }
@@ -62,13 +53,11 @@ export class MockSuite extends BaseSuite {
         if (!name) {
             throw new Error("MockSuite requires a non-empty name");
         }
-        console.log("[DEBUG] Creating MockSuite with name:", name, "index:", index);
         const suiteName = name || "testSuite"; // Ensure name is never undefined
         super(suiteName, index, {
             testGiven: new MockGiven("testGiven", ["testFeature"], [new MockWhen("testWhen", () => Promise.resolve({ testStore: true }))], [
                 new MockThen("testThen", async () => Promise.resolve({ testSelection: true })),
             ]),
         });
-        console.log("[DEBUG] MockSuite created:", this.name, this.index);
     }
 }