testeranto 0.189.0 → 0.198.0

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

@@ -77,26 +77,121 @@ const TestPage = () => {
             return;
         setTestName(testPath);
         const fetchData = async () => {
+            var _a;
             try {
-                const testResponse = await (0, api_1.fetchTestData)(projectName, testPath, runtime);
-                console.log("testResponse", testResponse);
-                // setTestData(testResponse.testData);
-                // setTestsExist(!!testResponse.testData);
+                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'] && typeof receivedLogs['tests.json'] === 'string') {
+                if (receivedLogs['tests.json']) {
+                    console.log('tests.json content type:', typeof receivedLogs['tests.json']);
                     try {
-                        receivedLogs['tests.json'] = JSON.parse(receivedLogs['tests.json']);
+                        // 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`);
+                    const summaryResponse = await fetch(`/reports/${projectName}/summary.json`);
                     if (!summaryResponse.ok)
                         throw new Error('Failed to fetch summary');
                     const allSummaries = await summaryResponse.json();
@@ -128,6 +223,7 @@ const TestPage = () => {
     }, []);
     if (!logs)
         return react_1.default.createElement("div", null, "loading...");
-    return (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 }));
+    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/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/lib/{abstractBase.js → BaseGiven.js}

@@ -2,20 +2,19 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseThen = exports.BaseWhen = exports.BaseGiven = void 0;
+exports.BaseGiven = void 0;
 const pmProxy_js_1 = require("./pmProxy.js");
 class BaseGiven {
     addArtifact(path) {
-        console.log("Given addArtifact", path);
         const normalizedPath = path.replace(/\\/g, "/"); // Normalize path separators
         this.artifacts.push(normalizedPath);
     }
     constructor(name, features, whens, thens, givenCB, initialValues) {
         this.artifacts = [];
         this.name = name;
-        this.features = features;
-        this.whens = whens;
-        this.thens = thens;
+        this.features = features || [];
+        this.whens = whens || [];
+        this.thens = thens || [];
         this.givenCB = givenCB;
         this.initialValues = initialValues;
     }
@@ -26,17 +25,17 @@ class BaseGiven {
         return {
             key: this.key,
             name: this.name,
-            whens: this.whens.map((w) => {
+            whens: (this.whens || []).map((w) => {
                 if (w && w.toObj)
                     return w.toObj();
                 console.error("w is not as expected!", JSON.stringify(w));
                 return {};
             }),
-            thens: this.thens.map((t) => t.toObj()),
+            thens: (this.thens || []).map((t) => t && t.toObj ? t.toObj() : {}),
             error: this.error ? [this.error, this.error.stack] : null,
             failed: this.failed,
-            features: this.features,
-            artifacts: this.artifacts,
+            features: this.features || [],
+            artifacts: this.artifacts || [],
         };
     }
     async afterEach(store, key, artifactory, pm) {
@@ -53,7 +52,9 @@ class BaseGiven {
             tLog(e.stack);
         });
         try {
-            const proxiedPm = (0, pmProxy_js_1.beforeEachProxy)(pm, suiteNdx.toString(), this.addArtifact.bind(this));
+            // Ensure addArtifact is properly bound to 'this'
+            const addArtifact = this.addArtifact.bind(this);
+            const proxiedPm = (0, pmProxy_js_1.beforeEachProxy)(pm, suiteNdx.toString(), addArtifact);
             this.store = await this.givenThat(subject, testResourceConfiguration, givenArtifactory, this.givenCB, this.initialValues, proxiedPm);
         }
         catch (e) {
@@ -80,7 +81,9 @@ class BaseGiven {
         }
         finally {
             try {
-                const proxiedPm = (0, pmProxy_js_1.afterEachProxy)(pm, suiteNdx.toString(), key, this.addArtifact.bind(this));
+                // Ensure addArtifact is properly bound to 'this'
+                const addArtifact = this.addArtifact.bind(this);
+                const proxiedPm = (0, pmProxy_js_1.afterEachProxy)(pm, suiteNdx.toString(), key, addArtifact);
                 // (proxiedPm as any).currentStep = this;
                 await this.afterEach(this.store, this.key, givenArtifactory, proxiedPm);
             }
@@ -94,83 +97,3 @@ class BaseGiven {
     }
 }
 exports.BaseGiven = BaseGiven;
-class BaseWhen {
-    addArtifact(path) {
-        console.log("When addArtifact", path);
-        const normalizedPath = path.replace(/\\/g, "/"); // Normalize path separators
-        this.artifacts.push(normalizedPath);
-    }
-    constructor(name, whenCB) {
-        this.artifacts = [];
-        this.name = name;
-        this.whenCB = whenCB;
-    }
-    toObj() {
-        const obj = {
-            name: this.name,
-            error: this.error
-                ? `${this.error.name}: ${this.error.message}\n${this.error.stack}`
-                : null,
-            artifacts: this.artifacts || [],
-        };
-        console.log(`[TOOBJ] Serializing ${this.constructor.name} with artifacts:`, obj.artifacts);
-        return obj;
-    }
-    async test(store, testResourceConfiguration, tLog, pm, filepath) {
-        try {
-            // tLog(" When:", this.name);
-            const proxiedPm = (0, pmProxy_js_1.andWhenProxy)(pm, filepath, this.addArtifact.bind(this));
-            // (proxiedPm as any).currentStep = this;
-            const result = await this.andWhen(store, this.whenCB, testResourceConfiguration, proxiedPm);
-            return result;
-        }
-        catch (e) {
-            console.error("[ERROR] When step failed:", this.name.toString(), e.toString());
-            this.error = e;
-            throw e;
-        }
-    }
-}
-exports.BaseWhen = BaseWhen;
-class BaseThen {
-    constructor(name, thenCB) {
-        this.artifacts = [];
-        this.name = name;
-        this.thenCB = thenCB;
-        this.error = false;
-        this.artifacts = [];
-    }
-    addArtifact(path) {
-        console.log("Then addArtifact", path);
-        const normalizedPath = path.replace(/\\/g, "/"); // Normalize path separators
-        this.artifacts.push(normalizedPath);
-    }
-    toObj() {
-        const obj = {
-            name: this.name,
-            error: this.error,
-            artifacts: this.artifacts,
-        };
-        return obj;
-    }
-    async test(store, testResourceConfiguration, tLog, pm, filepath) {
-        const proxiedPm = (0, pmProxy_js_1.butThenProxy)(pm, filepath, this.addArtifact.bind(this));
-        return this.butThen(store, async (s) => {
-            try {
-                if (typeof this.thenCB === "function") {
-                    return await this.thenCB(s, proxiedPm);
-                }
-                else {
-                    return this.thenCB;
-                }
-            }
-            catch (e) {
-                console.error(e.stack);
-            }
-        }, testResourceConfiguration, proxiedPm).catch((e) => {
-            this.error = e.stack;
-            // throw e;
-        });
-    }
-}
-exports.BaseThen = BaseThen;

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

@@ -5,7 +5,6 @@ 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);
     }
@@ -61,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];
@@ -74,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) {