testeranto 0.200.1 → 0.203.0

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

@@ -1,206 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import React, { useState, useEffect, useRef } from 'react';
-import { toPng } from 'html-to-image';
-export const DesignEditor = React.forwardRef(({ projectId }, ref) => {
-    const canvasRef = useRef(null);
-    const [design, setDesign] = useState({
-        objects: [],
-        background: '#ffffff',
-        version: '1.0'
-    });
-    const [collaborators, setCollaborators] = useState([]);
-    const wsRef = useRef(null);
-    // Initialize canvas and WebSocket connection
-    useEffect(() => {
-        // @ts-ignore
-        const canvas = new fabric.Canvas('design-canvas', {
-            width: 800,
-            height: 600
-        });
-        canvas.backgroundColor = design.background;
-        canvasRef.current = canvas;
-        const wsPort = window.location.port ? Number(window.location.port) + 1 : 3001;
-        const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
-        const host = window.location.hostname;
-        wsRef.current = new WebSocket(`${protocol}//${host}:${wsPort}/design?project=${projectId}`);
-        wsRef.current.onmessage = (event) => {
-            const message = JSON.parse(event.data);
-            if (message.type === 'design_update' && canvasRef.current) {
-                canvasRef.current.loadFromJSON(message.data, () => {
-                    var _a;
-                    (_a = canvasRef.current) === null || _a === void 0 ? void 0 : _a.renderAll();
-                });
-            }
-            else if (message.type === 'collaborators_update') {
-                setCollaborators(message.data);
-            }
-        };
-        return () => {
-            var _a;
-            (_a = wsRef.current) === null || _a === void 0 ? void 0 : _a.close();
-            canvas.dispose();
-        };
-    }, [projectId]);
-    const addShape = (shape) => {
-        if (!canvasRef.current)
-            return;
-        let object;
-        switch (shape) {
-            case 'rectangle':
-                // @ts-ignore
-                object = new fabric.Rect({
-                    width: 100,
-                    height: 100,
-                    fill: 'red',
-                    left: 100,
-                    top: 100
-                });
-                break;
-            case 'circle':
-                // @ts-ignore
-                object = new fabric.Circle({
-                    radius: 50,
-                    fill: 'blue',
-                    left: 200,
-                    top: 200
-                });
-                break;
-            case 'text':
-                // @ts-ignore
-                object = new fabric.Text('Double click to edit', {
-                    fontFamily: 'Arial',
-                    fontSize: 20,
-                    left: 100,
-                    top: 300
-                });
-                break;
-            default:
-                return;
-        }
-        canvasRef.current.add(object);
-        canvasRef.current.renderAll();
-    };
-    const saveDesign = () => {
-        if (!canvasRef.current) {
-            console.warn('Canvas ref is null, cannot save design');
-            return null;
-        }
-        try {
-            // Get current canvas state
-            const json = canvasRef.current.toJSON();
-            setDesign(json);
-            // Send update to collaborators
-            if (wsRef.current) {
-                wsRef.current.send(JSON.stringify({
-                    type: 'design_update',
-                    data: json
-                }));
-            }
-            // Force re-render of all objects
-            canvasRef.current.getObjects().forEach(obj => {
-                obj.set('dirty', true);
-            });
-            canvasRef.current.renderAll();
-            console.log('Design saved:', json);
-            return json;
-        }
-        catch (err) {
-            console.error('Error saving design:', err);
-            return null;
-        }
-    };
-    const loadDesign = (design) => {
-        console.log('loadDesign called with:', design);
-        if (!canvasRef.current) {
-            console.warn('Canvas ref is null, cannot load design');
-            return;
-        }
-        try {
-            console.log('Loading design into canvas...');
-            // Clear existing canvas
-            canvasRef.current.clear();
-            // Set background color
-            if (design.background) {
-                canvasRef.current.backgroundColor = design.background;
-            }
-            // Load objects if they exist
-            if (design.objects && design.objects.length > 0) {
-                console.log('Loading objects:', design.objects.length);
-                canvasRef.current.loadFromJSON(design, () => {
-                    var _a, _b;
-                    console.log('Design loaded, rendering canvas...');
-                    // Force re-render of all objects
-                    (_a = canvasRef.current) === null || _a === void 0 ? void 0 : _a.getObjects().forEach(obj => {
-                        obj.set('dirty', true);
-                    });
-                    (_b = canvasRef.current) === null || _b === void 0 ? void 0 : _b.renderAll();
-                    console.log('Canvas rendered with new design');
-                });
-            }
-            else {
-                console.log('No objects to load, rendering empty canvas');
-                canvasRef.current.renderAll();
-            }
-            // Force immediate render
-            canvasRef.current.renderAll();
-        }
-        catch (err) {
-            console.error('Error loading design:', err);
-            if (err instanceof Error) {
-                console.error('Error details:', {
-                    name: err.name,
-                    message: err.message,
-                    stack: err.stack
-                });
-            }
-        }
-    };
-    // Expose methods via ref
-    React.useImperativeHandle(ref, () => ({
-        loadDesign,
-        saveDesign
-    }));
-    const exportAsPNG = async () => {
-        if (!canvasRef.current)
-            return;
-        try {
-            // Store current active object and hide controls
-            const activeObject = canvasRef.current.getActiveObject();
-            if (activeObject) {
-                canvasRef.current.discardActiveObject();
-            }
-            // Render once to clear controls
-            canvasRef.current.renderAll();
-            // Get canvas element and export
-            const canvasElement = document.getElementById('design-canvas');
-            if (!canvasElement)
-                return;
-            const dataUrl = await toPng(canvasElement);
-            const link = document.createElement('a');
-            link.download = `design-${projectId}.png`;
-            link.href = dataUrl;
-            link.click();
-            // Restore active object if there was one
-            if (activeObject) {
-                canvasRef.current.setActiveObject(activeObject);
-                canvasRef.current.renderAll();
-            }
-        }
-        catch (error) {
-            console.error('Error exporting PNG:', error);
-        }
-    };
-    return (React.createElement("div", { className: "design-editor" },
-        React.createElement("div", { className: "toolbar" },
-            React.createElement("button", { onClick: () => addShape('rectangle') }, "Add Rectangle"),
-            React.createElement("button", { onClick: () => addShape('circle') }, "Add Circle"),
-            React.createElement("button", { onClick: () => addShape('text') }, "Add Text"),
-            React.createElement("button", { onClick: exportAsPNG }, "Export PNG")),
-        React.createElement("canvas", { id: "design-canvas" }),
-        React.createElement("div", { className: "collaborators" },
-            React.createElement("h3", null,
-                "Collaborators (",
-                collaborators.length,
-                ")"),
-            React.createElement("ul", null, collaborators.map(user => (React.createElement("li", { key: user.id }, user.name)))))));
-});

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,70 +0,0 @@
-import React 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 { 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 { SettingsPage } from './components/stateful/SettingsPage';
-export const App = () => {
-    return (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: "/features-reporter", element: React.createElement(FeaturesReporter, null) }),
-                React.createElement(Route, { path: "/design-editor", element: React.createElement(DesignEditorPage, null) }),
-                React.createElement(Route, { path: "/text-editor", element: React.createElement(TextEditorPage, null) }),
-                React.createElement(Route, { path: "/processes", element: React.createElement(ProcessManagerPage, null) }),
-                React.createElement(Route, { path: "/processes/:processId", element: React.createElement(SingleProcessPage, null) }),
-                React.createElement(Route, { path: "/settings", element: React.createElement(SettingsPage, 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_WithEslintAndTsc.js

@@ -1,185 +0,0 @@
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-/* eslint-disable no-async-promise-executor */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import ts from "typescript";
-import fs from "fs";
-import ansiC from "ansi-colors";
-import { ESLint } from "eslint";
-import tsc from "tsc-prog";
-import { lintPather, tscPather } from "../utils";
-import { PM_Base } from "./base.js";
-import { makePromptInternal } from "../utils/makePrompt";
-const eslint = new ESLint();
-const formatter = await eslint.loadFormatter("./node_modules/testeranto/dist/prebuild/esbuildConfigs/eslint-formatter-testeranto.mjs");
-export class PM_WithEslintAndTsc extends PM_Base {
-    constructor(configs, name, mode) {
-        super(configs);
-        this.summary = {};
-        this.tscCheck = async ({ entrypoint, addableFiles, platform, }) => {
-            console.log(ansiC.green(ansiC.inverse(`tsc < ${entrypoint}`)));
-            try {
-                this.typeCheckIsRunning(entrypoint);
-            }
-            catch (e) {
-                console.error("error in tscCheck");
-                console.error(e);
-                console.error(entrypoint);
-                console.error(JSON.stringify(this.summary, null, 2));
-                process.exit(-1);
-            }
-            const program = tsc.createProgramFromConfig({
-                basePath: process.cwd(), // always required, used for relative paths
-                configFilePath: "tsconfig.json", // config to inherit from (optional)
-                compilerOptions: {
-                    outDir: tscPather(entrypoint, platform, this.name),
-                    // declaration: true,
-                    // skipLibCheck: true,
-                    noEmit: true,
-                },
-                include: addableFiles, //["src/**/*"],
-                // exclude: ["node_modules", "../testeranto"],
-                // exclude: ["**/*.test.ts", "**/*.spec.ts"],
-            });
-            const tscPath = tscPather(entrypoint, platform, this.name);
-            const allDiagnostics = program.getSemanticDiagnostics();
-            const results = [];
-            allDiagnostics.forEach((diagnostic) => {
-                if (diagnostic.file) {
-                    const { line, character } = ts.getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
-                    const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
-                    results.push(`${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`);
-                }
-                else {
-                    results.push(ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n"));
-                }
-            });
-            fs.writeFileSync(tscPath, results.join("\n"));
-            this.typeCheckIsNowDone(entrypoint, results.length);
-        };
-        this.eslintCheck = async (entrypoint, platform, addableFiles) => {
-            console.log(ansiC.green(ansiC.inverse(`eslint < ${entrypoint}`)));
-            try {
-                this.lintIsRunning(entrypoint);
-            }
-            catch (e) {
-                console.error("error in eslintCheck");
-                console.error(e);
-                console.error(entrypoint);
-                console.error(JSON.stringify(this.summary, null, 2));
-                process.exit(-1);
-            }
-            const filepath = lintPather(entrypoint, platform, this.name);
-            if (fs.existsSync(filepath))
-                fs.rmSync(filepath);
-            const results = (await eslint.lintFiles(addableFiles))
-                .filter((r) => r.messages.length)
-                .filter((r) => {
-                return r.messages[0].ruleId !== null;
-            })
-                .map((r) => {
-                delete r.source;
-                return r;
-            });
-            fs.writeFileSync(filepath, await formatter.format(results));
-            this.lintIsNowDone(entrypoint, results.length);
-        };
-        this.makePrompt = async (entryPoint, addableFiles, platform) => {
-            await makePromptInternal(this.summary, this.name, entryPoint, addableFiles, platform);
-            this.checkForShutdown();
-        };
-        this.typeCheckIsRunning = (src) => {
-            if (!this.summary[src]) {
-                throw `this.summary[${src}] is undefined`;
-            }
-            this.summary[src].typeErrors = "?";
-        };
-        this.typeCheckIsNowDone = (src, failures) => {
-            if (!this.summary[src]) {
-                throw `this.summary[${src}] is undefined`;
-            }
-            if (failures === 0) {
-                console.log(ansiC.green(ansiC.inverse(`tsc > ${src}`)));
-            }
-            else {
-                console.log(ansiC.red(ansiC.inverse(`tsc > ${src} failed ${failures} times`)));
-            }
-            this.summary[src].typeErrors = failures;
-            this.writeBigBoard();
-            this.checkForShutdown();
-        };
-        this.lintIsRunning = (src) => {
-            if (!this.summary[src]) {
-                throw `this.summary[${src}] is undefined`;
-            }
-            this.summary[src].staticErrors = "?";
-            this.writeBigBoard();
-        };
-        this.lintIsNowDone = (src, failures) => {
-            if (!this.summary[src]) {
-                throw `this.summary[${src}] is undefined`;
-            }
-            if (failures === 0) {
-                console.log(ansiC.green(ansiC.inverse(`eslint > ${src}`)));
-            }
-            else {
-                console.log(ansiC.red(ansiC.inverse(`eslint > ${src} failed ${failures} times`)));
-            }
-            this.summary[src].staticErrors = failures;
-            this.writeBigBoard();
-            this.checkForShutdown();
-        };
-        this.bddTestIsRunning = (src) => {
-            if (!this.summary[src]) {
-                throw `this.summary[${src}] is undefined`;
-            }
-            this.summary[src].runTimeErrors = "?";
-            this.writeBigBoard();
-        };
-        this.bddTestIsNowDone = (src, failures) => {
-            if (!this.summary[src]) {
-                throw `this.summary[${src}] is undefined`;
-            }
-            this.summary[src].runTimeErrors = failures;
-            this.writeBigBoard();
-            this.checkForShutdown();
-        };
-        this.writeBigBoard = () => {
-            const summaryPath = `./testeranto/reports/${this.name}/summary.json`;
-            const summaryData = JSON.stringify(this.summary, null, 2);
-            fs.writeFileSync(summaryPath, summaryData);
-            // Broadcast the update
-            this.broadcast({
-                type: 'summaryUpdate',
-                data: this.summary
-            });
-        };
-        this.name = name;
-        this.mode = mode;
-        this.summary = {};
-        // Initialize all test entries first
-        this.configs.tests.forEach(([t, rt, tr, sidecars]) => {
-            this.ensureSummaryEntry(t);
-            sidecars.forEach(([sidecarName]) => {
-                this.ensureSummaryEntry(sidecarName, true);
-            });
-        });
-    }
-    ensureSummaryEntry(src, isSidecar = false) {
-        if (!this.summary[src]) {
-            this.summary[src] = {
-                typeErrors: undefined,
-                staticErrors: undefined,
-                runTimeErrors: undefined,
-                prompt: undefined,
-                failingFeatures: {},
-            };
-            if (isSidecar) {
-                // Sidecars don't need all fields
-                // delete this.summary[src].runTimeError;
-                // delete this.summary[src].prompt;
-            }
-        }
-        return this.summary[src];
-    }
-}