testeranto 0.203.0 → 0.205.0

package/dist/module/src/app/frontend/testPage/TestPageView.test/implementation.js

@@ -0,0 +1,122 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { assert } from "chai";
+import * as React from "react";
+import * as ReactDom from "react-dom/client";
+export const implementation = {
+    suites: {
+        Default: "TestPageView basic rendering",
+        Navigation: "TestPageView navigation behavior",
+        ErrorStates: "TestPageView error handling",
+    },
+    givens: {
+        Default: () => (props) => {
+            // Create a container and render the component
+            const container = document.createElement("div");
+            document.body.appendChild(container);
+            const reactElement = React.createElement(props);
+            const domRoot = ReactDom.createRoot(container);
+            domRoot.render(reactElement);
+            return Object.assign({ container,
+                reactElement,
+                domRoot }, props);
+        },
+        WithErrors: () => (props) => {
+            const container = document.createElement("div");
+            document.body.appendChild(container);
+            const reactElement = React.createElement(props);
+            const domRoot = ReactDom.createRoot(container);
+            domRoot.render(reactElement);
+            return Object.assign(Object.assign({ container,
+                reactElement,
+                domRoot }, props), { errorCounts: {
+                    runTimeErrors: 1,
+                    typeErrors: 1,
+                    staticErrors: 1,
+                } });
+        },
+        WithLogs: () => (props) => {
+            const container = document.createElement("div");
+            document.body.appendChild(container);
+            const reactElement = React.createElement(props);
+            const domRoot = ReactDom.createRoot(container);
+            domRoot.render(reactElement);
+            return Object.assign(Object.assign({ container,
+                reactElement,
+                domRoot }, props), { logs: {
+                    "tests.json": "{}",
+                    "stdout.log": "test log content",
+                } });
+        },
+    },
+    whens: {
+        SwitchToTab: (tabName) => async (selection, tr, utils) => {
+            // Update the props to switch tabs
+            const newProps = Object.assign(Object.assign({}, selection), { activeTab: tabName });
+            const newReactElement = React.createElement(selection.reactElement.type, newProps);
+            selection.domRoot.render(newReactElement);
+            return (sel) => (Object.assign(Object.assign({}, sel), { reactElement: newReactElement, activeTab: tabName }));
+        },
+        ClickAiderButton: () => async (selection, tr, utils) => {
+            // Find and click the Aider button
+            const button = selection.container.querySelector("button");
+            if (button) {
+                button.click();
+            }
+            return (sel) => sel;
+        },
+    },
+    thens: {
+        takeScreenshot: (name) => async (ssel, utils) => (sel) => {
+            // Screenshot functionality would be implemented here
+            return Promise.resolve(sel);
+        },
+        RendersNavBar: () => async (ssel, utils) => (sel) => {
+            const navBar = sel.container.querySelector(".navbar");
+            assert.isNotNull(navBar, "Navbar should be rendered");
+            return Promise.resolve(sel);
+        },
+        ShowsActiveTab: (tabName) => async (ssel, utils) => (sel) => {
+            // Check if the active tab matches
+            assert.equal(sel.activeTab, tabName, `Active tab should be ${tabName}`);
+            return Promise.resolve(sel);
+        },
+        ShowsErrorCounts: () => async (ssel, utils) => (sel) => {
+            // Check for error badges
+            const badges = sel.container.querySelectorAll(".badge");
+            assert.isAtLeast(badges.length, 0, "Should show at least one badge");
+            return Promise.resolve(sel);
+        },
+        ShowsTestResults: () => async (ssel, utils) => (sel) => {
+            // Check if test results are shown
+            if (sel.testsExist) {
+                const testResults = sel.container.querySelector(".test-results");
+                assert.isNotNull(testResults, "Test results should be shown when tests exist");
+            }
+            return Promise.resolve(sel);
+        },
+        ShowsLogs: () => async (ssel, utils) => (sel) => {
+            // Check if logs are shown
+            const logs = sel.container.querySelector("pre");
+            assert.isNotNull(logs, "Logs should be shown");
+            return Promise.resolve(sel);
+        },
+        ShowsTypeErrors: () => async (ssel, utils) => (sel) => {
+            // Check if type errors are shown
+            const typeErrors = sel.container.querySelector('[data-testid="type-errors"]');
+            assert.isNotNull(typeErrors, "Type errors should be shown");
+            return Promise.resolve(sel);
+        },
+        ShowsLintErrors: () => async (ssel, utils) => (sel) => {
+            // Check if lint errors are shown
+            const lintErrors = sel.container.querySelector('[data-testid="lint-errors"]');
+            assert.isNotNull(lintErrors, "Lint errors should be shown");
+            return Promise.resolve(sel);
+        },
+        AiderButtonCopiesCommand: () => async (ssel, utils) => (sel) => {
+            // Check if Aider button exists
+            const aiderButton = sel.container.querySelector('button[title*="AI Assistant"]');
+            assert.isNotNull(aiderButton, "Aider button should be present");
+            return Promise.resolve(sel);
+        },
+    },
+};

package/dist/module/src/app/frontend/testPage/TestPageView.test/index.js

@@ -0,0 +1,10 @@
+import Testeranto from "testeranto-react/src/react-dom/jsx/web";
+import React from "react";
+import { MemoryRouter } from "react-router-dom";
+import { implementation } from "./implementation";
+import { specification } from "./specification";
+import { TestPageView } from "../TestPageView";
+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/app/frontend/testPage/TestPageView.test/specification.js

@@ -0,0 +1,23 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+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/app/frontend/testPage/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/app/frontend/testPage/TestPageView_utils.js

@@ -0,0 +1,120 @@
+import React from "react";
+// Determine language from file extension
+export const getLanguage = (path) => {
+    var _a;
+    const ext = (_a = path.split(".").pop()) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+    switch (ext) {
+        case "ts":
+            return "typescript";
+        case "tsx":
+            return "typescript";
+        case "js":
+            return "javascript";
+        case "json":
+            return "json";
+        case "md":
+            return "markdown";
+        case "py":
+            return "python";
+        default:
+            return "plaintext";
+    }
+};
+const statusToClassName = (status) => {
+    if (status === undefined)
+        return "bg-secondary";
+    if (status === false)
+        return "bg-danger";
+    if (status === true)
+        return "bg-success";
+    throw `idk status: ${status}`;
+};
+export const renderTestResults = (testData, buildErrors, projectName, testName, runtime) => {
+    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 ${statusToClassName(given.status)} 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 text-white ${statusToClassName(when.status)}` },
+                    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 text-white ${statusToClassName(then.status)}` },
+                    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()))))))))))))))),
+        (buildErrors.errors.length > 0 || buildErrors.warnings.length > 0) && (React.createElement("div", { className: "mb-4 card border-danger" },
+            React.createElement("div", { className: "card-header bg-danger text-white" },
+                React.createElement("h4", null, "Build Errors and Warnings")),
+            React.createElement("div", { className: "card-body" },
+                buildErrors.errors.length > 0 && (React.createElement(React.Fragment, null,
+                    React.createElement("h5", null, "Errors"),
+                    React.createElement("ul", null, buildErrors.errors.map((error, idx) => (React.createElement("li", { key: `build-error-${idx}` },
+                        React.createElement("strong", null, error.text),
+                        error.location && (React.createElement("div", null,
+                            "File: ",
+                            error.location.file,
+                            " Line:",
+                            " ",
+                            error.location.line,
+                            " Column: ",
+                            error.location.column)))))))),
+                buildErrors.warnings.length > 0 && (React.createElement(React.Fragment, null,
+                    React.createElement("h5", null, "Warnings"),
+                    React.createElement("ul", null, buildErrors.warnings.map((warning, idx) => (React.createElement("li", { key: `build-warning-${idx}` },
+                        React.createElement("strong", null, warning.text),
+                        warning.location && (React.createElement("div", null,
+                            "File: ",
+                            warning.location.file,
+                            " Line:",
+                            " ",
+                            warning.location.line,
+                            " Column:",
+                            " ",
+                            warning.location.column)))))))))))));
+};

package/dist/module/src/app/frontend/useFileSystemSync.js

@@ -0,0 +1,108 @@
+"use strict";
+// /* eslint-disable @typescript-eslint/no-unused-vars */
+// import { useState, useEffect, useCallback } from "react";
+// import { useWebSocket } from "../App";
+// // Remove any imports that might import backend-specific code
+// export interface FileEntry {
+//   name: string;
+//   type: "folder" | "file";
+//   path: string;
+// }
+// export interface FileSystemState {
+//   files: Record<string, FileEntry[]>;
+//   fileContents: Record<string, string>;
+// }
+// export const useFileSystemSync = (initialPath = "/") => {
+//   const [fileSystem, setFileSystem] = useState<FileSystemState>({
+//     files: {},
+//     fileContents: {},
+//   });
+//   const [loading, setLoading] = useState(false);
+//   const [error, setError] = useState<string | null>(null);
+//   const wsContext = useWebSocket();
+//   const ws = wsContext?.ws;
+//   const listDirectory = useCallback(async (project: string) => {
+//     setLoading(true);
+//     setError(null);
+//     try {
+//       // Use the project tree endpoint
+//       const response = await fetch(
+//         `/api/projects/tree?project=${encodeURIComponent(project)}`
+//       );
+//       if (response.ok) {
+//         const data = await response.json();
+//         // The API should return { sourceFiles: [...] }
+//         const items = data.sourceFiles || data;
+//         setFileSystem((prev) => ({
+//           ...prev,
+//           files: {
+//             ...prev.files,
+//             [project]: items,
+//           },
+//         }));
+//         setLoading(false);
+//         return items;
+//       } else {
+//         throw new Error(`Failed to list directory: ${response.status}`);
+//       }
+//     } catch (error) {
+//       const errorMessage =
+//         error instanceof Error ? error.message : "Unknown error";
+//       console.error("Error listing directory:", error);
+//       setError(errorMessage);
+//       setLoading(false);
+//       throw error;
+//     }
+//   }, []);
+//   const readFile = useCallback(async (path: string) => {
+//     try {
+//       // Use the read file endpoint
+//       const response = await fetch(
+//         `/api/files/read?path=${encodeURIComponent(path)}`
+//       );
+//       if (response.ok) {
+//         const content = await response.text();
+//         setFileSystem((prev) => ({
+//           ...prev,
+//           fileContents: {
+//             ...prev.fileContents,
+//             [path]: content,
+//           },
+//         }));
+//         return content;
+//       } else {
+//         throw new Error(`Failed to read file: ${response.status}`);
+//       }
+//     } catch (error) {
+//       console.error("Error reading file:", error);
+//       throw error;
+//     }
+//   }, []);
+//   useEffect(() => {
+//     if (!ws) return;
+//     const handleMessage = (event: MessageEvent) => {
+//       try {
+//         const data = JSON.parse(event.data);
+//         if (data.type === "fileChanged") {
+//           setFileSystem((prev) => ({
+//             ...prev,
+//             fileContents: {
+//               ...prev.fileContents,
+//               [data.path]: data.content,
+//             },
+//           }));
+//         }
+//       } catch (error) {
+//         console.error("Error processing WebSocket message:", error);
+//       }
+//     };
+//     ws.addEventListener("message", handleMessage);
+//     return () => ws.removeEventListener("message", handleMessage);
+//   }, [ws]);
+//   return {
+//     fileSystem,
+//     listDirectory,
+//     readFile,
+//     refresh: () => listDirectory(initialPath),
+//   };
+// };

package/dist/module/src/app/frontend/useFs.js

@@ -0,0 +1,11 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { createContext, useContext } from "react";
+import { DevelopmentFileService } from "./DevelopmentFileService";
+export const FileServiceContext = createContext(new DevelopmentFileService());
+export const useFs = () => {
+    const context = useContext(FileServiceContext);
+    if (!context) {
+        throw new Error("useFileService must be used within a FileServiceProvider");
+    }
+    return context;
+};

package/dist/module/src/app/frontend/useGitMode.js

@@ -0,0 +1,16 @@
+import { useState, useEffect } from "react";
+import { useWebSocket } from "./useWebSocket";
+export const useGitMode = () => {
+    const { isConnected } = useWebSocket();
+    const [mode, setMode] = useState(isConnected ? "dev" : "static");
+    useEffect(() => {
+        setMode(isConnected ? "dev" : "static");
+    }, [isConnected]);
+    return {
+        mode,
+        setMode,
+        isStatic: mode === "static",
+        isDev: mode === "dev",
+        isGit: mode === "git",
+    };
+};

package/dist/module/src/app/frontend/useTerminalWebSocket.js

@@ -0,0 +1,40 @@
+import { useState, useEffect, useCallback } from "react";
+export const useTerminalWebSocket = (ws, selectedProcess) => {
+    const [processLogs, setProcessLogs] = useState([]);
+    // Handle WebSocket messages for the selected process
+    const handleMessage = useCallback((event) => {
+        try {
+            const data = JSON.parse(event.data);
+            // Handle process data response
+            if (data.type === "processData" &&
+                selectedProcess &&
+                data.processId === selectedProcess.processId) {
+                setProcessLogs(data.logs || []);
+            }
+            // Handle new log messages
+            else if ((data.type === "processStdout" || data.type === "processStderr") &&
+                selectedProcess &&
+                data.processId === selectedProcess.processId) {
+                setProcessLogs((prev) => [...prev, data.data]);
+            }
+        }
+        catch (error) {
+            console.error("Error parsing WebSocket message:", error);
+        }
+    }, [selectedProcess]);
+    // Reset logs when selected process changes
+    useEffect(() => {
+        setProcessLogs((selectedProcess === null || selectedProcess === void 0 ? void 0 : selectedProcess.logs) || []);
+    }, [selectedProcess]);
+    useEffect(() => {
+        if (!ws)
+            return;
+        ws.addEventListener("message", handleMessage);
+        return () => {
+            ws.removeEventListener("message", handleMessage);
+        };
+    }, [ws, handleMessage]);
+    return {
+        processLogs,
+    };
+};

package/dist/module/src/app/frontend/useWebSocket.js

@@ -0,0 +1,12 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { createContext, useContext } from "react";
+export const WebSocketContext = createContext({
+    ws: null,
+    isConnected: false,
+    sendMessage: function (message) {
+        throw new Error("Function not implemented.");
+    },
+});
+export const useWebSocket = () => {
+    return useContext(WebSocketContext);
+};

package/dist/module/src/app/types.js

@@ -0,0 +1 @@
+export {};

package/dist/module/src/builders/golang.js

@@ -0,0 +1,28 @@
+console.log("Golang build process started");
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+async function runGolangBuild() {
+    try {
+        // Build Go code
+        console.log("Building Go code...");
+        const { stdout, stderr } = await execAsync('go build -o /tmp/golang-build ./example/Calculator.go');
+        if (stdout)
+            console.log(stdout);
+        if (stderr)
+            console.error(stderr);
+        // Run tests if they exist
+        console.log("Running Go tests...");
+        const testResult = await execAsync('go test ./...');
+        if (testResult.stdout)
+            console.log(testResult.stdout);
+        if (testResult.stderr)
+            console.error(testResult.stderr);
+        console.log("Golang build completed successfully");
+    }
+    catch (error) {
+        console.error("Golang build failed:", error);
+        process.exit(1);
+    }
+}
+runGolangBuild();

package/dist/module/src/builders/node.js

@@ -0,0 +1,33 @@
+console.log("Node build process started");
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+async function runNodeBuild() {
+    try {
+        // Install dependencies
+        console.log("Installing Node.js dependencies...");
+        const installResult = await execAsync('npm install');
+        if (installResult.stdout)
+            console.log(installResult.stdout);
+        // Run tests
+        console.log("Running Node.js tests...");
+        const testResult = await execAsync('npm test');
+        if (testResult.stdout)
+            console.log(testResult.stdout);
+        if (testResult.stderr)
+            console.error(testResult.stderr);
+        // Build the project
+        console.log("Building Node.js project...");
+        const buildResult = await execAsync('npm run build');
+        if (buildResult.stdout)
+            console.log(buildResult.stdout);
+        if (buildResult.stderr)
+            console.error(buildResult.stderr);
+        console.log("Node.js build completed successfully");
+    }
+    catch (error) {
+        console.error("Node.js build failed:", error);
+        process.exit(1);
+    }
+}
+runNodeBuild();

package/dist/module/src/builders/python.js

@@ -0,0 +1,26 @@
+console.log("Python build process started");
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+async function runPythonBuild() {
+    try {
+        // Run Python syntax check using local environment
+        console.log("Checking Python syntax...");
+        const syntaxCheck = await execAsync('python3 -m py_compile ./example/Calculator.py');
+        if (syntaxCheck.stdout)
+            console.log(syntaxCheck.stdout);
+        // Run Python tests if they exist using local environment
+        console.log("Running Python tests...");
+        const testResult = await execAsync('python3 -m pytest ./example/ -v');
+        if (testResult.stdout)
+            console.log(testResult.stdout);
+        if (testResult.stderr)
+            console.error(testResult.stderr);
+        console.log("Python build completed successfully");
+    }
+    catch (error) {
+        console.error("Python build failed:", error);
+        process.exit(1);
+    }
+}
+runPythonBuild();

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

@@ -0,0 +1,33 @@
+console.log("Web build process started");
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+async function runWebBuild() {
+    try {
+        // Install dependencies
+        console.log("Installing web dependencies...");
+        const installResult = await execAsync('npm install');
+        if (installResult.stdout)
+            console.log(installResult.stdout);
+        // Run linting
+        console.log("Running linting...");
+        const lintResult = await execAsync('npm run lint');
+        if (lintResult.stdout)
+            console.log(lintResult.stdout);
+        if (lintResult.stderr)
+            console.error(lintResult.stderr);
+        // Build the web assets
+        console.log("Building web assets...");
+        const buildResult = await execAsync('npm run build');
+        if (buildResult.stdout)
+            console.log(buildResult.stdout);
+        if (buildResult.stderr)
+            console.error(buildResult.stderr);
+        console.log("Web build completed successfully");
+    }
+    catch (error) {
+        console.error("Web build failed:", error);
+        process.exit(1);
+    }
+}
+runWebBuild();

package/dist/module/src/defaultConfig.js

@@ -0,0 +1,17 @@
+const config = {
+    src: "src",
+    tests: [],
+    debugger: true,
+    clearScreen: false,
+    minify: false,
+    ports: ["3001"],
+    externals: [],
+    nodePlugins: [],
+    webPlugins: [],
+    importPlugins: [],
+    webLoaders: {},
+    featureIngestor: function (s) {
+        throw new Error("Function not implemented.");
+    },
+};
+export default config;

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

@@ -0,0 +1,32 @@
+import fs from "fs";
+export const consoleDetectorPlugin = {
+    name: "console-detector",
+    setup(build) {
+        build.onLoad({ filter: /\.(js|ts)$/ }, async (args) => {
+            const contents = await fs.promises.readFile(args.path, "utf8");
+            const consolePattern = /console\.(log|error|warn|info|debug|trace|dir|dirxml|table|group|groupEnd|clear|count|countReset|assert|profile|profileEnd|time|timeLog|timeEnd|timeStamp|context|memory)/g;
+            const matches = contents.match(consolePattern);
+            if (matches) {
+                const uniqueMethods = [...new Set(matches)];
+                return {
+                    warnings: uniqueMethods.map((method) => ({
+                        text: `call of "${method}" was detected, which is not supported in the pure runtime.`,
+                        // location: {
+                        //   file: args.path,
+                        //   line:
+                        //     contents
+                        //       .split("\n")
+                        //       .findIndex((line) => line.includes(method)) + 1,
+                        //   column: 0,
+                        // },
+                    })),
+                };
+            }
+            return null;
+        });
+        build.onEnd((buildResult) => {
+            if (buildResult.warnings.find((br) => br.pluginName === "console-detector"))
+                console.warn(`Warning: An unsupported method call was detected in a source file used to build for the pure runtime. It is possible that this method call is in a comment block. If you really want to use this function, change this test to the "node" runtime.`);
+        });
+    },
+};