testeranto 0.177.0 → 0.197.0

package/dist/common/src/components/stateful/SettingsPage.js

@@ -0,0 +1,72 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SettingsPage = void 0;
+const react_1 = __importStar(require("react"));
+const react_bootstrap_1 = require("react-bootstrap");
+// import { AppFrame } from '../pure/AppFrame';
+const SettingsPage = () => {
+    const [theme, setTheme] = (0, react_1.useState)(localStorage.getItem('theme') || 'system');
+    (0, react_1.useEffect)(() => {
+        let themeToApply = theme;
+        if (theme === 'system') {
+            themeToApply = window.matchMedia('(prefers-color-scheme: light)').matches ? 'light' : 'dark';
+        }
+        document.documentElement.setAttribute('data-bs-theme', themeToApply);
+    }, [theme]);
+    const handleThemeChange = (e) => {
+        const newTheme = e.target.value;
+        setTheme(newTheme);
+        localStorage.setItem('theme', newTheme);
+        let themeToApply = newTheme;
+        if (newTheme === 'system') {
+            themeToApply = window.matchMedia('(prefers-color-scheme: light)').matches ? 'light' : 'dark';
+        }
+        document.documentElement.setAttribute('data-bs-theme', themeToApply);
+    };
+    return (react_1.default.createElement(react_bootstrap_1.Container, null,
+        react_1.default.createElement(react_bootstrap_1.Row, { className: "justify-content-center" },
+            react_1.default.createElement(react_bootstrap_1.Col, { lg: 8 },
+                react_1.default.createElement(react_bootstrap_1.Card, { className: "theme-card" },
+                    react_1.default.createElement(react_bootstrap_1.Card.Body, null,
+                        react_1.default.createElement(react_bootstrap_1.Form, null,
+                            react_1.default.createElement(react_bootstrap_1.Form.Group, { className: "mb-4" },
+                                react_1.default.createElement(react_bootstrap_1.Form.Label, { className: "h6 mb-3" }, "Theme"),
+                                react_1.default.createElement("div", { className: "d-flex flex-wrap gap-3" },
+                                    react_1.default.createElement(react_bootstrap_1.Form.Check, { type: "radio", name: "theme", id: "light-theme", label: "Light", value: "light", checked: theme === 'light', onChange: handleThemeChange, className: "theme-option" }),
+                                    react_1.default.createElement(react_bootstrap_1.Form.Check, { type: "radio", name: "theme", id: "dark-theme", label: "Dark", value: "dark", checked: theme === 'dark', onChange: handleThemeChange, className: "theme-option" }),
+                                    react_1.default.createElement(react_bootstrap_1.Form.Check, { type: "radio", name: "theme", id: "system-theme", label: "System", value: "system", checked: theme === 'system', onChange: handleThemeChange, className: "theme-option" }))))))))));
+};
+exports.SettingsPage = SettingsPage;

package/dist/common/src/components/stateful/SingleProcessPage.js

@@ -0,0 +1,147 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SingleProcessPage = void 0;
+const react_1 = __importStar(require("react"));
+const react_router_dom_1 = require("react-router-dom");
+const SingleProcessView_1 = require("../pure/SingleProcessView");
+const SingleProcessPage = () => {
+    const [process, setProcess] = (0, react_1.useState)(null);
+    const [ws, setWs] = (0, react_1.useState)(null);
+    const [loading, setLoading] = (0, react_1.useState)(true);
+    const navigate = (0, react_router_dom_1.useNavigate)();
+    const { processId } = (0, react_router_dom_1.useParams)();
+    // Connect to WebSocket
+    (0, react_1.useEffect)(() => {
+        const wsProtocol = window.location.protocol === "https:" ? "wss:" : "ws:";
+        const wsUrl = `${wsProtocol}//${window.location.host}`;
+        const websocket = new WebSocket(wsUrl);
+        setWs(websocket);
+        // Set a timeout to handle cases where we don't get a response
+        const timeoutId = setTimeout(() => {
+            if (loading) {
+                setLoading(false);
+                // If we're still loading after 3 seconds, show an error
+                setProcess(null);
+            }
+        }, 3000);
+        // Request specific process when connected
+        websocket.onopen = () => {
+            setLoading(true);
+            if (processId) {
+                websocket.send(JSON.stringify({
+                    type: "getProcess",
+                    processId,
+                }));
+            }
+        };
+        websocket.onerror = (error) => {
+            console.error("WebSocket error:", error);
+            setLoading(false);
+            setProcess(null);
+            clearTimeout(timeoutId);
+        };
+        const handleMessage = (event) => {
+            try {
+                const data = JSON.parse(event.data);
+                // Handle process data response - this should include all captured logs
+                if (data.type === "processData" && data.processId === processId) {
+                    setProcess({
+                        processId: data.processId,
+                        command: data.command,
+                        pid: data.pid,
+                        timestamp: data.timestamp,
+                        status: data.status || "running",
+                        exitCode: data.exitCode,
+                        error: data.error,
+                        // Use the logs sent from the server, which should include all captured logs
+                        logs: data.logs || [],
+                    });
+                    setLoading(false);
+                    clearTimeout(timeoutId);
+                }
+                // Handle new log messages that come after the initial data
+                else if ((data.type === "processStdout" || data.type === "processStderr") &&
+                    data.processId === processId) {
+                    setProcess((prev) => prev
+                        ? Object.assign(Object.assign({}, prev), { logs: [...(prev.logs || []), data.data] }) : null);
+                }
+                // Handle process completion
+                else if ((data.type === "processExited" || data.type === "processError") &&
+                    data.processId === processId) {
+                    setProcess((prev) => prev
+                        ? Object.assign(Object.assign({}, prev), { status: data.type === "processExited" ? "exited" : "error", exitCode: data.exitCode, error: data.error }) : null);
+                }
+            }
+            catch (error) {
+                console.error("Error parsing process message:", error);
+                setLoading(false);
+                setProcess(null);
+                clearTimeout(timeoutId);
+            }
+        };
+        websocket.addEventListener("message", handleMessage);
+        return () => {
+            websocket.removeEventListener("message", handleMessage);
+            websocket.close();
+            clearTimeout(timeoutId);
+        };
+    }, [processId]);
+    // Try to find the process in the global state if WebSocket doesn't respond
+    (0, react_1.useEffect)(() => {
+        // This is a fallback - in a real implementation, you'd want to get this from a global state
+        // or through some other means
+    }, []);
+    const handleBack = (0, react_1.useCallback)(() => {
+        navigate("/processes");
+    }, [navigate]);
+    const handleKillProcess = (0, react_1.useCallback)((processId) => {
+        if (ws && ws.readyState === WebSocket.OPEN) {
+            console.log("Sending killProcess for:", processId);
+            ws.send(JSON.stringify({
+                type: "killProcess",
+                processId,
+            }));
+        }
+        else {
+            console.log("Cannot send killProcess - WebSocket not ready:", {
+                wsExists: !!ws,
+                wsReady: ws === null || ws === void 0 ? void 0 : ws.readyState,
+            });
+        }
+    }, [ws]);
+    return (react_1.default.createElement(SingleProcessView_1.SingleProcessView, { process: process, onBack: handleBack, loading: loading, onKillProcess: handleKillProcess, ws: ws }));
+};
+exports.SingleProcessPage = SingleProcessPage;

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

@@ -0,0 +1,229 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestPage = void 0;
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const react_1 = __importStar(require("react"));
+const react_router_dom_1 = require("react-router-dom");
+const api_1 = require("../../utils/api");
+const TestPageView_1 = require("../pure/TestPageView");
+const TestPage = () => {
+    const navigate = (0, react_router_dom_1.useNavigate)();
+    const location = (0, react_router_dom_1.useLocation)();
+    const [route, setRoute] = (0, react_1.useState)('results');
+    // Sync route with hash changes
+    (0, react_1.useEffect)(() => {
+        const hash = location.hash.replace('#', '');
+        if (hash && ['results', 'logs', 'types', 'lint', 'coverage'].includes(hash)) {
+            setRoute(hash);
+        }
+        else {
+            setRoute('results');
+        }
+    }, [location.hash]);
+    const [testName, setTestName] = (0, react_1.useState)('');
+    // const [testData, setTestData] = useState(null);
+    const [logs, setLogs] = (0, react_1.useState)({});
+    // const [typeErrors, setTypeErrors] = useState('');
+    // const [lintErrors, setLintErrors] = useState('');
+    const [loading, setLoading] = (0, react_1.useState)(true);
+    const [error, setError] = (0, react_1.useState)(null);
+    const [testsExist, setTestsExist] = (0, react_1.useState)(true);
+    const [errorCounts, setErrorCounts] = (0, react_1.useState)({
+        typeErrors: 0,
+        staticErrors: 0,
+        runTimeErrors: 0
+    });
+    const [summary, setSummary] = (0, react_1.useState)(null);
+    const { projectName, '*': splat } = (0, react_router_dom_1.useParams)();
+    const pathParts = splat ? splat.split('/') : [];
+    const runtime = pathParts.pop() || '';
+    const testPath = pathParts.join('/');
+    const decodedTestPath = testPath ? decodeURIComponent(testPath) : '';
+    (0, react_1.useEffect)(() => {
+        if (!projectName || !testPath || !runtime)
+            return;
+        setTestName(testPath);
+        const fetchData = async () => {
+            var _a;
+            try {
+                const [testResponse, metafileRes] = await Promise.all([
+                    (0, api_1.fetchTestData)(projectName, testPath, runtime),
+                    fetch(`/metafiles/${runtime}/${projectName}.json`)
+                ]);
+                console.log('Fetching test data for:', { projectName, testPath, runtime });
+                const receivedLogs = await testResponse.logs;
+                console.log('Received logs:', Object.keys(receivedLogs));
+                let sourceFiles = {};
+                if (metafileRes.ok) {
+                    const metafile = await metafileRes.json();
+                    if ((_a = metafile === null || metafile === void 0 ? void 0 : metafile.metafile) === null || _a === void 0 ? void 0 : _a.outputs) {
+                        // Find input files only for this test's entry point
+                        const tsSources = new Set();
+                        const testEntryPoint = `src/${testPath}`;
+                        // First find all outputs that match this test
+                        const matchingOutputs = Object.entries(metafile.metafile.outputs)
+                            .filter(([outputPath, output]) => {
+                            const normalizedTestPath = testPath.replace(/\./g, '_');
+                            const testFileName = testPath.split('/').pop();
+                            const testBaseName = testFileName === null || testFileName === void 0 ? void 0 : testFileName.split('.').slice(0, -1).join('.');
+                            return output.entryPoint === testEntryPoint ||
+                                outputPath.includes(normalizedTestPath) ||
+                                (testBaseName && outputPath.includes(testBaseName));
+                        });
+                        // Then collect all inputs from matching outputs
+                        matchingOutputs.forEach(([_, output]) => {
+                            Object.keys(output.inputs).forEach(inputPath => {
+                                // Check if this input is a TypeScript file and not in node_modules
+                                if ((inputPath.endsWith('.ts') || inputPath.endsWith('.tsx')) &&
+                                    !inputPath.includes('node_modules')) {
+                                    // Get the full input details from metafile.inputs
+                                    const inputDetails = metafile.metafile.inputs[inputPath];
+                                    if (inputDetails) {
+                                        tsSources.add(inputPath);
+                                        // Also include any imported TypeScript files
+                                        inputDetails.imports.forEach(imp => {
+                                            if ((imp.path.endsWith('.ts') || imp.path.endsWith('.tsx')) &&
+                                                !imp.path.includes('node_modules') &&
+                                                !imp.external) {
+                                                tsSources.add(imp.path);
+                                            }
+                                        });
+                                    }
+                                }
+                            });
+                        });
+                        // Organize source files into directory tree structure
+                        const fileTree = {};
+                        const filesList = await Promise.all(Array.from(tsSources).map(async (filePath) => {
+                            try {
+                                const fetchPath = filePath.startsWith('/')
+                                    ? filePath
+                                    : `/${filePath.replace(/^\.\//, '')}`;
+                                const res = await fetch(fetchPath);
+                                if (res.ok) {
+                                    return {
+                                        path: filePath,
+                                        content: await res.text()
+                                    };
+                                }
+                                return null;
+                            }
+                            catch (err) {
+                                console.warn(`Failed to fetch source file ${filePath}:`, err);
+                                return null;
+                            }
+                        }));
+                        filesList.forEach(file => {
+                            if (!file)
+                                return;
+                            const parts = file.path.split('/');
+                            let currentLevel = fileTree;
+                            parts.forEach((part, index) => {
+                                if (!currentLevel[part]) {
+                                    if (index === parts.length - 1) {
+                                        currentLevel[part] = {
+                                            __isFile: true,
+                                            content: file.content
+                                        };
+                                    }
+                                    else {
+                                        currentLevel[part] = {};
+                                    }
+                                }
+                                currentLevel = currentLevel[part];
+                            });
+                        });
+                        sourceFiles = fileTree;
+                    }
+                }
+                // Add source files to logs
+                receivedLogs['source_files'] = sourceFiles;
+                console.log('Source files structure:', sourceFiles);
+                // Ensure tests.json is properly formatted
+                if (receivedLogs['tests.json']) {
+                    console.log('tests.json content type:', typeof receivedLogs['tests.json']);
+                    try {
+                        // Handle both string and already-parsed JSON
+                        if (typeof receivedLogs['tests.json'] === 'string') {
+                            receivedLogs['tests.json'] = JSON.parse(receivedLogs['tests.json']);
+                        }
+                        // If it's already an object, leave it as is
+                    }
+                    catch (e) {
+                        console.error('Failed to parse tests.json:', e);
+                        // Keep the original content but don't replace it with an error object
+                    }
+                }
+                setLogs(receivedLogs);
+                // setTypeErrors(testResponse.typeErrors);
+                // setLintErrors(testResponse.lintErrors);
+                try {
+                    const summaryResponse = await fetch(`/reports/${projectName}/summary.json`);
+                    if (!summaryResponse.ok)
+                        throw new Error('Failed to fetch summary');
+                    const allSummaries = await summaryResponse.json();
+                    const testSummary = allSummaries[testPath];
+                    if (testSummary) {
+                        const counts = {
+                            typeErrors: Number(testSummary.typeErrors) || 0,
+                            staticErrors: Number(testSummary.staticErrors) || 0,
+                            runTimeErrors: Number(testSummary.runTimeErrors) || 0
+                        };
+                        setSummary(testSummary);
+                        setErrorCounts(counts);
+                        setTestsExist(testSummary.testsExist !== false);
+                    }
+                }
+                catch (err) {
+                    console.error('Failed to load summary:', err);
+                }
+            }
+            catch (err) {
+                setError(err instanceof Error ? err.message : 'Unknown error');
+                setTestsExist(false);
+            }
+            finally {
+                setLoading(false);
+            }
+        };
+        fetchData();
+    }, []);
+    if (!logs)
+        return react_1.default.createElement("div", null, "loading...");
+    return (react_1.default.createElement(react_1.default.Fragment, null,
+        react_1.default.createElement(TestPageView_1.TestPageView, { route: route, setRoute: setRoute, navigate: navigate, projectName: projectName, testName: testName, decodedTestPath: decodedTestPath, runtime: runtime, logs: logs, testsExist: testsExist, errorCounts: errorCounts })));
+};
+exports.TestPage = TestPage;

package/dist/common/src/components/stateful/TextEditorPage.js

@@ -0,0 +1,154 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextEditorPage = void 0;
+const react_1 = __importStar(require("react"));
+const react_2 = require("@monaco-editor/react");
+const FileTree_1 = require("./FileTree");
+const TextEditorPage = () => {
+    const [files, setFiles] = (0, react_1.useState)([]);
+    const [activeFile, setActiveFile] = (0, react_1.useState)(null);
+    const [editorTheme, setEditorTheme] = (0, react_1.useState)('vs-dark');
+    // Initialize with sample files
+    (0, react_1.useEffect)(() => {
+        const sampleFiles = [
+            {
+                path: 'src/index.ts',
+                content: '// TypeScript code here\nconst message = "Hello World";\nconsole.log(message);',
+                language: 'typescript'
+            },
+            {
+                path: 'package.json',
+                content: '{\n  "name": "my-project",\n  "version": "1.0.0"\n}',
+                language: 'json'
+            }
+        ];
+        setFiles(sampleFiles);
+        setActiveFile(sampleFiles[0]);
+    }, []);
+    const handleFileSelect = (filePath) => {
+        const selectedFile = files.find(f => f.path === filePath);
+        if (selectedFile) {
+            setActiveFile(selectedFile);
+        }
+    };
+    const handleEditorChange = (value) => {
+        if (activeFile && value !== undefined) {
+            setFiles(files.map(f => f.path === activeFile.path ? Object.assign(Object.assign({}, f), { content: value }) : f));
+        }
+    };
+    const [widths, setWidths] = (0, react_1.useState)({
+        fileTree: 250,
+        editor: window.innerWidth - 550, // Initial editor width (total width minus side panels)
+        preview: 300
+    });
+    const containerStyle = {
+        display: 'flex',
+        height: '100vh',
+        width: '100%'
+    };
+    const panelStyle = {
+        height: '100%',
+        overflow: 'hidden',
+        position: 'relative'
+    };
+    const [isResizing, setIsResizing] = (0, react_1.useState)(false);
+    const [startX, setStartX] = (0, react_1.useState)(0);
+    const [startWidth, setStartWidth] = (0, react_1.useState)(0);
+    const startResizing = (e, panel) => {
+        setIsResizing(true);
+        setStartX(e.clientX);
+        setStartWidth(widths[panel]);
+    };
+    const resize = (e) => {
+        if (isResizing) {
+            const dx = e.clientX - startX;
+            const newFileTreeWidth = Math.max(200, Math.min(400, startWidth + dx));
+            setWidths({
+                fileTree: newFileTreeWidth,
+                editor: window.innerWidth - newFileTreeWidth - widths.preview,
+                preview: widths.preview
+            });
+        }
+    };
+    const stopResizing = () => {
+        setIsResizing(false);
+    };
+    (0, react_1.useEffect)(() => {
+        window.addEventListener('mousemove', resize);
+        window.addEventListener('mouseup', stopResizing);
+        return () => {
+            window.removeEventListener('mousemove', resize);
+            window.removeEventListener('mouseup', stopResizing);
+        };
+    }, [isResizing, startX, startWidth]);
+    return (react_1.default.createElement("div", { style: containerStyle },
+        react_1.default.createElement("div", { style: Object.assign(Object.assign({}, panelStyle), { width: widths.fileTree }) },
+            react_1.default.createElement(FileTree_1.FileTree, { files: files, onSelect: handleFileSelect, activeFile: activeFile === null || activeFile === void 0 ? void 0 : activeFile.path }),
+            react_1.default.createElement("div", { style: {
+                    width: '4px',
+                    height: '100%',
+                    cursor: 'col-resize',
+                    backgroundColor: isResizing ? '#aaa' : '#ddd',
+                    position: 'absolute',
+                    right: 0,
+                    top: 0,
+                    zIndex: 1
+                }, onMouseDown: (e) => startResizing(e, 'fileTree') })),
+        react_1.default.createElement("div", { style: Object.assign(Object.assign({}, panelStyle), { width: widths.editor }) }, activeFile && (react_1.default.createElement(react_2.Editor, { height: "100%", path: activeFile.path, defaultLanguage: activeFile.language, defaultValue: activeFile.content, onChange: handleEditorChange, theme: editorTheme, options: {
+                minimap: { enabled: false },
+                fontSize: 14,
+                wordWrap: 'on',
+                automaticLayout: true
+            } }))),
+        react_1.default.createElement("div", { style: Object.assign(Object.assign({}, panelStyle), { width: widths.preview }) },
+            react_1.default.createElement("div", { style: {
+                    width: '4px',
+                    height: '100%',
+                    cursor: 'col-resize',
+                    backgroundColor: isResizing ? '#aaa' : '#ddd',
+                    position: 'absolute',
+                    left: 0,
+                    top: 0,
+                    zIndex: 1
+                }, onMouseDown: (e) => startResizing(e, 'editor') }),
+            activeFile && (react_1.default.createElement("div", null)
+            // <FilePreview 
+            //   content={activeFile.content}
+            //   language={activeFile.language}
+            // />
+            ))));
+};
+exports.TextEditorPage = TextEditorPage;

package/dist/common/src/defaultConfig.js

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

package/dist/common/src/esbuildConfigs/inputFilesPlugin.js

@@ -12,10 +12,9 @@ const register = (entrypoint, sources) => {
     sources.forEach((s) => otherInputs[entrypoint].add(s));
 };
 exports.default = (platform, testName) => {
-    const d = `testeranto/bundles/${platform}/${testName}/`;
-    const f = `testeranto/bundles/${platform}/${testName}/metafile.json`;
-    if (!fs_1.default.existsSync(d)) {
-        fs_1.default.mkdirSync(d);
+    const f = `testeranto/metafiles/${platform}/${testName}.json`;
+    if (!fs_1.default.existsSync(`testeranto/metafiles/${platform}`)) {
+        fs_1.default.mkdirSync(`testeranto/metafiles/${platform}`, { recursive: true });
     }
     return {
         register,

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

@@ -31,7 +31,7 @@ exports.default = (config, entryPoints, testName) => {
             "util",
             "process",
             "dns",
-        ], platform: "browser", entryPoints: [...entryPoints], plugins: [
+        ], platform: "browser", entryPoints: [...entryPoints], loader: config.webLoaders, plugins: [
             featuresPlugin_js_1.default,
             inputFilesPluginFactory,
             (0, esbuild_plugin_polyfill_node_1.polyfillNode)({

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

@@ -1,10 +1,10 @@
 "use strict";
+/* eslint-disable @typescript-eslint/no-unused-vars */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseSuite = void 0;
 const pmProxy_1 = require("./pmProxy");
 class BaseSuite {
     addArtifact(path) {
-        console.log("Suite addArtifact", path);
         const normalizedPath = path.replace(/\\/g, "/"); // Normalize path separators
         this.artifacts.push(normalizedPath);
     }
@@ -60,7 +60,9 @@ class BaseSuite {
         // console.log("\nSuite:", this.index, this.name);
         // tLog("\nSuite:", this.index, this.name);
         const sNdx = this.index;
-        const proxiedPm = (0, pmProxy_1.beforeAllProxy)(pm, sNdx.toString(), this);
+        // Ensure addArtifact is properly bound to 'this'
+        const addArtifact = this.addArtifact.bind(this);
+        const proxiedPm = (0, pmProxy_1.beforeAllProxy)(pm, sNdx.toString(), addArtifact);
         const subject = await this.setup(input, suiteArtifactory, testResourceConfiguration, proxiedPm);
         for (const [gKey, g] of Object.entries(this.givens)) {
             const giver = this.givens[gKey];
@@ -73,7 +75,9 @@ class BaseSuite {
             });
         }
         try {
-            const afterAllPm = (0, pmProxy_1.afterAllProxy)(pm, sNdx.toString(), this);
+            // Ensure addArtifact is properly bound to 'this'
+            const addArtifact = this.addArtifact.bind(this);
+            const afterAllPm = (0, pmProxy_1.afterAllProxy)(pm, sNdx.toString(), addArtifact);
             this.afterAll(this.store, artifactory, afterAllPm);
         }
         catch (e) {