testeranto 0.202.0 → 0.203.0

package/dist/module/design-editor/DesignEditor.js

@@ -1,40 +0,0 @@
-import React, { useEffect, useRef } from 'react';
-import { Canvas, Rect, Text } from 'fabric';
-export const DesignEditor = () => {
-    const canvasRef = useRef(null);
-    useEffect(() => {
-        if (!canvasRef.current)
-            return;
-        // Initialize the fabric canvas
-        const canvas = new Canvas(canvasRef.current, {
-            width: 800,
-            height: 600,
-            backgroundColor: '#f0f0f0'
-        });
-        // Add a simple rectangle
-        const rect = new Rect({
-            left: 100,
-            top: 100,
-            width: 100,
-            height: 100,
-            fill: 'red',
-            angle: 0
-        });
-        // Add text
-        const text = new Text('Hello Fabric.js!', {
-            left: 50,
-            top: 50,
-            fontSize: 20,
-            fill: 'blue'
-        });
-        // Add objects to canvas
-        canvas.add(rect, text);
-        canvas.renderAll();
-        // Cleanup
-        return () => {
-            canvas.dispose();
-        };
-    }, []);
-    return (React.createElement("div", null,
-        React.createElement("canvas", { ref: canvasRef })));
-};

package/dist/module/design-editor/index.js

@@ -1,2 +0,0 @@
-export * from './DesignEditor';
-export * from './server';

package/dist/module/design-editor/server.js

@@ -1,92 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { WebSocketServer } from "ws";
-import fs from "fs";
-import path from "path";
-const projects = new Map();
-export function startDesignEditorServer(wssPort, httpPort) {
-    const wss = new WebSocketServer({ port: wssPort });
-    wss.on("connection", (ws, req) => {
-        // Create URL from request URL and host header
-        const url = new URL(req.url || "", `http://${req.headers.host}`);
-        const projectId = url.searchParams.get("project") || "default";
-        if (!projects.has(projectId)) {
-            projects.set(projectId, {
-                connections: new Set(),
-                design: loadDesign(projectId),
-            });
-        }
-        const project = projects.get(projectId);
-        project.connections.add(ws);
-        // Send current design to new collaborator
-        ws.send(JSON.stringify({
-            type: "design_update",
-            data: project.design,
-        }));
-        broadcastCollaborators(projectId);
-        ws.on("message", (message) => {
-            const data = JSON.parse(message);
-            if (data.type === "design_update") {
-                project.design = data.data;
-                saveDesign(projectId, data.data);
-                broadcastToProject(projectId, message.toString());
-            }
-        });
-        ws.on("close", (code, reason) => {
-            project.connections.delete(ws);
-            if (project.connections.size === 0) {
-                projects.delete(projectId);
-            }
-            else {
-                broadcastCollaborators(projectId);
-            }
-        });
-    });
-    console.log(`Design editor WebSocket server running on port ${wssPort}`);
-}
-function broadcastToProject(projectId, message) {
-    const project = projects.get(projectId);
-    if (project) {
-        project.connections.forEach((client) => {
-            if (client.readyState === client.OPEN) {
-                client.send(message);
-            }
-        });
-    }
-}
-function broadcastCollaborators(projectId) {
-    const project = projects.get(projectId);
-    if (project) {
-        const collaborators = Array.from(project.connections).map((_, i) => ({
-            id: `user-${i}`,
-            name: `Collaborator ${i + 1}`,
-        }));
-        broadcastToProject(projectId, JSON.stringify({
-            type: "collaborators_update",
-            data: collaborators,
-        }));
-    }
-}
-function loadDesign(projectId) {
-    const designsDir = path.join(process.cwd(), "designs");
-    const filePath = path.join(designsDir, `${projectId}.json`);
-    try {
-        const data = fs.readFileSync(filePath, "utf-8");
-        return JSON.parse(data);
-    }
-    catch (_a) {
-        return {
-            version: "1.0",
-            background: "#ffffff",
-            objects: [],
-        };
-    }
-}
-function saveDesign(projectId, design) {
-    const designsDir = path.join(process.cwd(), "designs");
-    if (!fs.existsSync(designsDir)) {
-        fs.mkdirSync(designsDir, { recursive: true });
-    }
-    const filePath = path.join(designsDir, `${projectId}.json`);
-    fs.writeFileSync(filePath, JSON.stringify(design, null, 2));
-}

package/dist/module/design-editor/types.js

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

package/dist/module/package.json

@@ -1,3 +0,0 @@
-{
-    "type": "module"
-}

package/dist/module/src/App.js

@@ -1,176 +0,0 @@
-import React, { useState, useEffect, createContext, useContext } from 'react';
-import ReactDom from "react-dom/client";
-import { HashRouter as Router, Routes, Route } from 'react-router-dom';
-import { TestPage } from './components/stateful/TestPage';
-import { ProjectPage } from './components/stateful/ProjectPage';
-import { ProjectsPage } from './components/stateful/ProjectsPage';
-import { AppFrame } from './components/pure/AppFrame';
-import { SignIn } from './components/pure/SignIn';
-import { FeaturesReporter } from './components/stateful/FeaturesReporter';
-import { DesignEditorPage } from './components/DesignEditorPage';
-import { TextEditorPage } from './components/stateful/TextEditorPage';
-import { ProcessManagerPage } from './components/stateful/ProcessManagerPage';
-import { SingleProcessPage } from './components/stateful/SingleProcessPage';
-import { Settings } from './components/pure/Settings';
-import { GitIntegrationPage } from './components/stateful/GitIntegrationPage';
-import { AuthCallbackPage } from './components/stateful/AuthCallbackPage';
-import { githubAuthService } from './services/GitHubAuthService';
-// Create a context for the WebSocket
-const WebSocketContext = createContext({
-    ws: null,
-    isConnected: false,
-});
-// Create a context for tutorial mode
-const TutorialModeContext = createContext({
-    tutorialMode: false,
-    setTutorialMode: () => { },
-});
-// Create a context for authentication
-const AuthContext = createContext({
-    isAuthenticated: false,
-    user: null,
-    login: () => { },
-    logout: () => { },
-});
-export const useWebSocket = () => {
-    return useContext(WebSocketContext);
-};
-export const useTutorialMode = () => {
-    return useContext(TutorialModeContext);
-};
-export const useAuth = () => {
-    return useContext(AuthContext);
-};
-export const App = () => {
-    const [ws, setWs] = useState(null);
-    const [isConnected, setIsConnected] = useState(false);
-    const [tutorialMode, setTutorialMode] = useState(false);
-    const [isAuthenticated, setIsAuthenticated] = useState(githubAuthService.isAuthenticated);
-    const [user, setUser] = useState(githubAuthService.userInfo);
-    useEffect(() => {
-        // Load tutorial mode from localStorage
-        const savedTutorialMode = localStorage.getItem('tutorialMode');
-        if (savedTutorialMode) {
-            setTutorialMode(savedTutorialMode === 'true');
-        }
-        // Listen for auth changes
-        const handleAuthChange = (authenticated) => {
-            setIsAuthenticated(authenticated);
-            setUser(githubAuthService.userInfo);
-        };
-        githubAuthService.on('authChange', handleAuthChange);
-        // Handle GitHub OAuth callback from popup
-        const handleMessage = async (event) => {
-            if (event.data.type === 'github-auth-callback') {
-                const { code } = event.data;
-                try {
-                    const success = await githubAuthService.handleCallback(code);
-                    if (success) {
-                        console.log('GitHub authentication successful');
-                    }
-                    else {
-                        console.error('GitHub authentication failed');
-                    }
-                }
-                catch (error) {
-                    console.error('Error handling GitHub callback:', error);
-                }
-            }
-            else if (event.data.type === 'github-auth-error') {
-                console.error('GitHub authentication error:', event.data.error);
-            }
-        };
-        window.addEventListener('message', handleMessage);
-        const wsProtocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
-        const wsUrl = `${wsProtocol}//${window.location.host}`;
-        const websocket = new WebSocket(wsUrl);
-        websocket.onopen = () => {
-            console.log('WebSocket connected');
-            setWs(websocket);
-            setIsConnected(true);
-        };
-        websocket.onclose = () => {
-            console.log('WebSocket disconnected');
-            setWs(null);
-            setIsConnected(false);
-        };
-        websocket.onerror = (error) => {
-            console.error('WebSocket error:', error);
-            setIsConnected(false);
-        };
-        return () => {
-            githubAuthService.off('authChange', handleAuthChange);
-            window.removeEventListener('message', handleMessage);
-            websocket.close();
-        };
-    }, []);
-    const authContextValue = {
-        isAuthenticated,
-        user,
-        login: () => githubAuthService.initiateLogin(),
-        logout: () => githubAuthService.logout(),
-    };
-    return (React.createElement(WebSocketContext.Provider, { value: { ws, isConnected } },
-        React.createElement(TutorialModeContext.Provider, { value: { tutorialMode, setTutorialMode } },
-            React.createElement(AuthContext.Provider, { value: authContextValue },
-                React.createElement(Router, null,
-                    React.createElement(AppFrame, null,
-                        React.createElement(Routes, null,
-                            React.createElement(Route, { path: "/", element: React.createElement(ProjectsPage, null) }),
-                            React.createElement(Route, { path: "/projects/:projectName", element: React.createElement(ProjectPage, null) }),
-                            React.createElement(Route, { path: "/projects/:projectName/tests/*", element: React.createElement(TestPage, null) }),
-                            React.createElement(Route, { path: "/projects/:projectName#:tab", element: React.createElement(ProjectPage, null) }),
-                            React.createElement(Route, { path: "/signin", element: React.createElement(SignIn, null) }),
-                            React.createElement(Route, { path: "/auth/github/callback", element: React.createElement(AuthCallbackPage, null) }),
-                            React.createElement(Route, { path: "/features-reporter", element: isAuthenticated ? React.createElement(FeaturesReporter, null) : React.createElement(SignIn, null) }),
-                            React.createElement(Route, { path: "/design-editor", element: isAuthenticated ? React.createElement(DesignEditorPage, null) : React.createElement(SignIn, null) }),
-                            React.createElement(Route, { path: "/text-editor", element: isAuthenticated ? React.createElement(TextEditorPage, null) : React.createElement(SignIn, null) }),
-                            isConnected ? (React.createElement(React.Fragment, null,
-                                React.createElement(Route, { path: "/processes", element: isAuthenticated ? React.createElement(ProcessManagerPage, null) : React.createElement(SignIn, null) }),
-                                React.createElement(Route, { path: "/processes/:processId", element: isAuthenticated ? React.createElement(SingleProcessPage, null) : React.createElement(SignIn, null) }))) : null,
-                            React.createElement(Route, { path: "/settings", element: React.createElement(Settings, null) }),
-                            React.createElement(Route, { path: "/git", element: isAuthenticated ? React.createElement(GitIntegrationPage, null) : React.createElement(SignIn, null) }),
-                            React.createElement(Route, { path: "*", element: React.createElement(ProjectsPage, null) }))))))));
-};
-// Export App to global scope
-function initApp() {
-    const rootElement = document.getElementById('root');
-    if (rootElement) {
-        try {
-            // Try to use React 18's createRoot if available
-            if (ReactDom.createRoot) {
-                const root = ReactDom.createRoot(rootElement);
-                root.render(React.createElement(App));
-            }
-            else {
-                // Fall back to React 17's render
-                ReactDom.render(React.createElement(App), rootElement);
-            }
-        }
-        catch (err) {
-            console.error('Error rendering app:', err);
-            // Retry if React isn't loaded yet
-            setTimeout(initApp, 100);
-        }
-    }
-    else {
-        // Retry if root element isn't available yet
-        setTimeout(initApp, 100);
-    }
-}
-// Export App to global scope
-if (typeof window !== 'undefined' && typeof document !== 'undefined') {
-    // @ts-ignore
-    window.App = App;
-    // @ts-ignore
-    window.React = React;
-    // @ts-ignore
-    window.ReactDOM = ReactDom;
-    // Initialize the app when the window is ready
-    if (document.readyState === 'loading') {
-        document.addEventListener('DOMContentLoaded', initApp);
-    }
-    else {
-        initApp();
-    }
-}

package/dist/module/src/CoreTypes.js

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

package/dist/module/src/Init.js

@@ -1,43 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import fs from "fs";
-export default async () => {
-    [
-        `testeranto/`,
-        `testeranto/bundles/`,
-        `testeranto/bundles/node`,
-        `testeranto/bundles/web`,
-        `testeranto/bundles/pure`,
-        `testeranto/reports/`,
-        `testeranto/features/`,
-        `testeranto/externalTests/`,
-    ].forEach((f) => {
-        try {
-            fs.mkdirSync(`${process.cwd()}/${f}`);
-        }
-        catch (e) {
-            console.error(e);
-        }
-    });
-    fs.copyFileSync(`node_modules/testeranto/dist/prebuild/App.js`, `testeranto/App.js`);
-    fs.copyFileSync(`node_modules/testeranto/dist/prebuild/App.css`, `testeranto/App.css`);
-    // fs.copyFileSync(
-    //   `node_modules/testeranto/dist/prebuild/ReportClient.js`,
-    //   `testeranto/ReportClient.js`
-    // );
-    // fs.copyFileSync(
-    //   `node_modules/testeranto/dist/prebuild/Project.css`,
-    //   `testeranto/Project.css`
-    // );
-    // fs.copyFileSync(
-    //   `node_modules/testeranto/dist/prebuild/ReportClient.css`,
-    //   `testeranto/ReportClient.css`
-    // );
-    // fs.copyFileSync(
-    //   `node_modules/testeranto/dist/prebuild/TestReport.js`,
-    //   `testeranto/TestReport.js`
-    // );
-    // fs.copyFileSync(
-    //   `node_modules/testeranto/dist/prebuild/TestReport.css`,
-    //   `testeranto/TestReport.css`
-    // );
-};

package/dist/module/src/Node.js

@@ -1,33 +0,0 @@
-// import Testeranto from "./lib/core.js";
-import { defaultTestResourceRequirement, } from "./lib/index.js";
-import { PM_Node } from "./PM/node.js";
-import Tiposkripto from "./lib/Tiposkripto.js";
-let ipcfile;
-export class NodeTesteranto extends Tiposkripto {
-    constructor(input, testSpecification, testImplementation, testResourceRequirement, testAdapter) {
-        super(input, testSpecification, testImplementation, testResourceRequirement, testAdapter, () => {
-            // no-op
-        });
-    }
-    async receiveTestResourceConfig(partialTestResource) {
-        return await this.testJobs[0].receiveTestResourceConfig(new PM_Node(JSON.parse(partialTestResource), ipcfile));
-    }
-}
-const testeranto = async (input, testSpecification, testImplementation, testAdapter, testResourceRequirement = defaultTestResourceRequirement) => {
-    try {
-        const t = new NodeTesteranto(input, testSpecification, testImplementation, testResourceRequirement, testAdapter);
-        process.on("unhandledRejection", (reason, promise) => {
-            console.error("Unhandled Rejection at:", promise, "reason:", reason);
-            // Optionally, terminate the process or perform cleanup
-            // t.registerUncaughtPromise(reason, promise);
-        });
-        ipcfile = process.argv[3];
-        process.exit((await t.receiveTestResourceConfig(process.argv[2])).fails);
-    }
-    catch (e) {
-        console.error(e);
-        console.error(e.stack);
-        process.exit(-1);
-    }
-};
-export default testeranto;

package/dist/module/src/NodeSidecar.js

@@ -1,11 +0,0 @@
-import { Sidecar } from "./lib/Sidecar";
-import { PM_Node_Sidecar } from "./PM/nodeSidecar";
-export class NodeSidecar extends Sidecar {
-    constructor(t) {
-        super();
-        this.pm = new PM_Node_Sidecar(t);
-        this.pm.start(this.stop).then(() => {
-            this.start(JSON.parse(process.argv[2]));
-        });
-    }
-}

package/dist/module/src/PM/PM_WithBuild.js

@@ -1,128 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import esbuild from "esbuild";
-import esbuildNodeConfiger from "../esbuildConfigs/node.js";
-import esbuildWebConfiger from "../esbuildConfigs/web.js";
-import esbuildImportConfiger from "../esbuildConfigs/pure.js";
-import { getRunnables } from "../utils.js";
-import { PM_WithWebSocket } from "./PM_WithWebSocket.js";
-export class PM_WithBuild extends PM_WithWebSocket {
-    constructor(configs, name, mode) {
-        super(configs);
-        this.currentBuildResolve = null;
-        this.currentBuildReject = null;
-        this.configs = configs;
-        this.name = name;
-        this.mode = mode;
-    }
-    async startBuildProcesses() {
-        const { nodeEntryPoints, webEntryPoints, pureEntryPoints } = getRunnables(this.configs.tests, this.name);
-        console.log(`Starting build processes for ${this.name}...`);
-        console.log(`  Node entry points: ${Object.keys(nodeEntryPoints).length}`);
-        console.log(`  Web entry points: ${Object.keys(webEntryPoints).length}`);
-        console.log(`  Pure entry points: ${Object.keys(pureEntryPoints).length}`);
-        // Start all build processes (only node, web, pure)
-        await Promise.all([
-            this.startBuildProcess(esbuildNodeConfiger, nodeEntryPoints, "node"),
-            this.startBuildProcess(esbuildWebConfiger, webEntryPoints, "web"),
-            this.startBuildProcess(esbuildImportConfiger, pureEntryPoints, "pure"),
-        ]);
-    }
-    async startBuildProcess(configer, entryPoints, runtime) {
-        const entryPointKeys = Object.keys(entryPoints);
-        if (entryPointKeys.length === 0)
-            return;
-        // Store reference to 'this' for use in the plugin
-        const self = this;
-        // Create a custom plugin to track build processes
-        const buildProcessTrackerPlugin = {
-            name: 'build-process-tracker',
-            setup(build) {
-                build.onStart(() => {
-                    const processId = `build-${runtime}-${Date.now()}`;
-                    const command = `esbuild ${runtime} for ${self.name}`;
-                    // Create a promise that will resolve when the build completes
-                    const buildPromise = new Promise((resolve, reject) => {
-                        // Store resolve and reject functions to call them in onEnd
-                        self.currentBuildResolve = resolve;
-                        self.currentBuildReject = reject;
-                    });
-                    // Add to process manager
-                    if (self.addPromiseProcess) {
-                        self.addPromiseProcess(processId, buildPromise, command, "build-time", self.name, runtime);
-                    }
-                    console.log(`Starting ${runtime} build for ${entryPointKeys.length} entry points`);
-                    // Broadcast build start event
-                    if (self.broadcast) {
-                        self.broadcast({
-                            type: "buildEvent",
-                            event: "start",
-                            runtime,
-                            timestamp: new Date().toISOString(),
-                            entryPoints: entryPointKeys.length,
-                            processId
-                        });
-                    }
-                });
-                build.onEnd((result) => {
-                    const event = {
-                        type: "buildEvent",
-                        event: result.errors.length > 0 ? "error" : "success",
-                        runtime,
-                        timestamp: new Date().toISOString(),
-                        errors: result.errors.length,
-                        warnings: result.warnings.length
-                    };
-                    if (result.errors.length > 0) {
-                        console.error(`Build ${runtime} failed with ${result.errors.length} errors`);
-                        if (self.currentBuildReject) {
-                            self.currentBuildReject(new Error(`Build failed with ${result.errors.length} errors`));
-                        }
-                    }
-                    else {
-                        console.log(`Build ${runtime} completed successfully`);
-                        if (self.currentBuildResolve) {
-                            self.currentBuildResolve();
-                        }
-                    }
-                    // Broadcast build result event
-                    if (self.broadcast) {
-                        self.broadcast(event);
-                    }
-                    // Clear the current build handlers
-                    self.currentBuildResolve = null;
-                    self.currentBuildReject = null;
-                });
-            }
-        };
-        // Get the base config and add our tracking plugin
-        const baseConfig = configer(this.configs, entryPointKeys, this.name);
-        const configWithPlugin = Object.assign(Object.assign({}, baseConfig), { plugins: [...(baseConfig.plugins || []), buildProcessTrackerPlugin] });
-        try {
-            const ctx = await esbuild.context(configWithPlugin);
-            if (this.mode === "dev") {
-                // In dev mode, start watching - each rebuild will be tracked as a separate process
-                await ctx.watch();
-            }
-            else {
-                // In once mode, do a single build which will be tracked by the plugin
-                const result = await ctx.rebuild();
-                await ctx.dispose();
-            }
-        }
-        catch (error) {
-            console.error(`Failed to start ${runtime} build context:`, error);
-            // Broadcast error event
-            if (this.broadcast) {
-                this.broadcast({
-                    type: "buildEvent",
-                    event: "error",
-                    runtime,
-                    timestamp: new Date().toISOString(),
-                    errors: 1,
-                    warnings: 0,
-                    message: error.message
-                });
-            }
-        }
-    }
-}