testeranto 0.200.1 → 0.203.0

package/dist/module/src/lib/pmProxy.test/specification.js

@@ -1,60 +0,0 @@
-export const specification = (Suite, Given, When, Then) => [
-    Suite.Default("PM Proxy Functionality", {
-        // Basic path rewriting tests
-        writeFileProxyTest: Given.SomeBaseString(["butThenProxy should rewrite writeFileSync paths"], [], [
-            Then.theButTheProxyReturns("writeFileSync", "test/path/butThen/test.txt"),
-        ], "writeFileSync test"),
-        createWriteStreamProxyTest: Given.SomeBaseString(["butThenProxy should rewrite createWriteStream paths"], [], [
-            Then.theButTheProxyReturns("createWriteStream", "test/path/butThen/stream.txt"),
-        ], "createWriteStream test"),
-        screencastProxyTest: Given.SomeBaseString(["butThenProxy should rewrite screencast paths"], [], [
-            Then.theButTheProxyReturns("screencast", "test/path/butThen/screen.png"),
-        ], "screencast test"),
-        customScreenShotProxyTest: Given.SomeBaseString(["butThenProxy should rewrite customScreenShot paths"], [], [
-            Then.theButTheProxyReturns("customScreenShot", "test/path/butThen/shot.png"),
-        ], "customScreenShot test"),
-        // Edge cases
-        emptyPathTest: Given.SomeBaseString(["butThenProxy should handle empty paths"], [], [Then.theButTheProxyReturns("writeFileSync", "test/path/butThen/")], "empty path test"),
-        nestedPathTest: Given.SomeBaseString(["butThenProxy should handle nested paths"], [], [
-            Then.theButTheProxyReturns("writeFileSync", "test/path/butThen/nested/folder/test.txt"),
-        ], "nested path test"),
-        specialCharsTest: Given.SomeBaseString(["butThenProxy should handle special characters in paths"], [], [
-            Then.theButTheProxyReturns("writeFileSync", "test/path/butThen/file with spaces.txt"),
-        ], "special chars test"),
-        testsJsonTest: Given.SomeBaseString(["butThenProxy should handle tests.json correctly"], [], [
-            Then.theButTheProxyReturns("writeFileSync", "test/path/butThen/tests.json"),
-        ], "tests.json test"),
-    }),
-    Suite.Default("Proxy Type Coverage", {
-        // Test all proxy types
-        butThenProxyTest: Given.SomeBaseString(["butThenProxy should work correctly"], [], [
-            Then.theButTheProxyReturns("writeFileSync", "test/path/butThen/test.txt"),
-        ], "butThenProxy test"),
-        andWhenProxyTest: Given.SomeBaseString(["andWhenProxy should work correctly"], [], [
-            Then.theButTheProxyReturns("writeFileSync", "test/path/andWhen/test.txt"),
-        ], "andWhenProxy test"),
-        beforeEachProxyTest: Given.SomeBaseString(["beforeEachProxy should work correctly"], [], [
-            Then.theButTheProxyReturns("writeFileSync", "suite-1/beforeEach/test.txt"),
-        ], "beforeEachProxy test"),
-        afterEachProxyTest: Given.SomeBaseString(["afterEachProxy should work correctly"], [], [
-            Then.theButTheProxyReturns("writeFileSync", "suite-1/given-1/afterEach/test.txt"),
-        ], "afterEachProxy test"),
-    }),
-    Suite.Default("Content Preservation", {
-        // Verify content is preserved
-        contentPreservationTest: Given.SomeBaseString(["Proxies should preserve file content"], [], [
-            Then.theButTheProxyReturns("writeFileSync", "test/path/butThen/test.txt"),
-            Then.verifyContent("test content"),
-        ], "content preservation test"),
-        objectContentTest: Given.SomeBaseString(["Proxies should preserve object content"], [], [
-            Then.theButTheProxyReturns("screencast", "test/path/butThen/screen.png"),
-            Then.verifyContent({ quality: 80, fullPage: true }),
-        ], "object content test"),
-    }),
-    Suite.Default("Error Cases", {
-        invalidPathTest: Given.SomeBaseString(["Proxies should handle invalid paths"], [], [
-            Then.theButTheProxyReturns("writeFileSync", "test/path/butThen/../invalid.txt"),
-        ], "invalid path test"),
-        undefinedInputTest: Given.SomeBaseString(["Proxies should handle undefined inputs"], [], [Then.theButTheProxyReturns("writeFileSync", undefined)], "undefined input test"),
-    }),
-];

package/dist/module/src/lib/pmProxy.test/types.js

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

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

@@ -1,2 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-export {};

package/dist/module/src/mothership/index.js

@@ -1,16 +0,0 @@
-import express from "express";
-const app = express();
-app.get("/", (req, res) => {
-    res.send("Hello World!");
-});
-app.get("/claim", (req, res) => {
-    const { resource } = req.query;
-    console.log(`Resource claimed: ${resource}`);
-    res.status(200).json({ status: 'claimed', resource });
-});
-export default (port) => {
-    app.listen(port, () => {
-        console.log(`Example app listening on port ${port}`);
-    });
-    return app;
-};

package/dist/module/src/mothership/test.js

@@ -1,78 +0,0 @@
-import Testeranto from "../Node";
-import appFactory from "./index";
-const specification = (Suite, Given, When, Then) => {
-    console.log("Suite", Suite);
-    return [
-        Suite.TheMothership("the mothership allows the coordination of test resources", {
-            test0: Given.ItIsRunning([`a resource can be claimed`], [When.IClaimTheResource("test")], [Then.TheResourceIsClaimed("test")]),
-        }, []),
-    ];
-};
-const implementation = {
-    suites: { TheMothership: (x) => x },
-    givens: { ItIsRunning: () => undefined },
-    whens: {
-        IClaimTheResource: (resource) => async (app, tr, pm) => {
-            try {
-                const response = await fetch(`http://localhost:${tr.ports[0]}/claim?resource=${resource}`);
-                if (!response.ok) {
-                    const errorText = await response.text();
-                    console.error(`[ERROR] Failed to claim resource: ${errorText}`);
-                    throw new Error(`Failed to claim resource: ${errorText}`);
-                }
-                const result = await response.json();
-                return app;
-            }
-            catch (error) {
-                console.error("[ERROR] Resource claim failed:", error);
-                throw error;
-            }
-        },
-        IReleaseTheResource: function (resource) {
-            throw new Error("Function not implemented.");
-        },
-        IResetTheResource: function (Iw_0) {
-            throw new Error("Function not implemented.");
-        },
-    },
-    thens: {
-        TheResourceIsClaimed: (expectedResource) => async (app, pm) => {
-            // In a real implementation, we'd check the server state
-            // For now just log and return success
-            return app;
-        },
-        TheResourceIsUnClaimed: function (It_0) {
-            throw new Error("Function not implemented.");
-        },
-    },
-};
-const testAdapter = {
-    beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
-        console.log("beforeEach - starting app on port", testResource.ports[0]);
-        return subject(testResource.ports[0]);
-    },
-    andWhen: async (store, whenCB, testResource, pm) => {
-        console.log("andWhen - executing action");
-        return whenCB(store, testResource, pm);
-    },
-    butThen: async (store, thenCB, testResource, pm) => {
-        console.log("butThen - making assertions");
-        return thenCB(store, pm);
-    },
-    afterEach: async (store, key, pm) => {
-        console.log("afterEach - cleaning up");
-        return store;
-    },
-    afterAll: async (store, pm) => {
-        console.log("afterAll - final cleanup");
-    },
-    beforeAll: async (input, testResource, pm) => {
-        console.log("beforeAll - initial setup");
-        return input;
-    },
-    assertThis: (x) => {
-        console.log("assertThis - validating result");
-        return x;
-    },
-};
-export default Testeranto(appFactory, specification, implementation, testAdapter);

package/dist/module/src/run.js

@@ -1,49 +0,0 @@
-"use strict";
-// import ansiC from "ansi-colors";
-// import readline from "readline";
-// import { PM_Main } from "./PM/main";
-// import { ITestconfig, IBuiltConfig, IProject } from "./Types";
-// readline.emitKeypressEvents(process.stdin);
-// if (process.stdin.isTTY) process.stdin.setRawMode(true);
-// console.log(ansiC.inverse("Press 'q' to initiate a graceful shutdown."));
-// console.log(ansiC.inverse("Press 'x' to quit forcefully."));
-// process.stdin.on("keypress", (str, key) => {
-//   if (key.name === "x") {
-//     console.log(ansiC.inverse("Shutting down forcefully..."));
-//     process.exit(-1);
-//   }
-// });
-// const projectName = process.argv[2];
-// const mode = process.argv[3] as "once" | "dev";
-// if (mode !== "once" && mode !== "dev") {
-//   console.error("the 2nd argument should be 'dev' or 'once' ");
-//   process.exit(-1);
-// }
-// const f = process.cwd() + "/" + "testeranto.config.ts";
-// console.log("config file:", f);
-// import(f).then(async (module) => {
-//   const bigConfig: IProject = module.default || module;
-//   const rawConfig: ITestconfig = bigConfig.projects[projectName];
-//   if (!rawConfig) {
-//     console.error(`Project "${projectName}" does not exist in the configuration.`);
-//     console.error("Available projects:", Object.keys(bigConfig.projects));
-//     process.exit(-1);
-//   }
-//   if (!rawConfig.tests) {
-//     console.error(projectName, "appears to have no tests: ", f);
-//     console.error(`here is the config:`);
-//     console.log(JSON.stringify(rawConfig));
-//     process.exit(-1);
-//   }
-//   const config: IBuiltConfig = {
-//     ...rawConfig,
-//     buildDir: process.cwd() + "/" + `testeranto/${projectName}.json`,
-//   };
-//   const pm = new PM_Main(config, projectName, mode);
-//   pm.start();
-//   process.stdin.on("keypress", (str, key) => {
-//     if (key.name === "q") {
-//       pm.stop();
-//     }
-//   });
-// });

package/dist/module/src/testeranto.js

@@ -1,245 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import ansiC from "ansi-colors";
-import fs from "fs";
-import path from "path";
-import readline from "readline";
-import esbuild from "esbuild";
-import { getRunnables } from "./utils";
-import { AppHtml } from "./utils/buildTemplates";
-import esbuildNodeConfiger from "./esbuildConfigs/node";
-import esbuildWebConfiger from "./esbuildConfigs/web";
-import esbuildImportConfiger from "./esbuildConfigs/pure";
-import webHtmlFrame from "./web.html";
-readline.emitKeypressEvents(process.stdin);
-if (process.stdin.isTTY)
-    process.stdin.setRawMode(true);
-const testName = process.argv[2];
-const mode = process.argv[3];
-if (mode !== "once" && mode !== "dev") {
-    console.error(`The 3rd argument should be 'dev' or 'once', not '${mode}'.`);
-    process.exit(-1);
-}
-const f = process.cwd() + "/" + "testeranto.config.ts";
-console.log("config file:", f);
-import(f).then(async (module) => {
-    const pckge = (await import(`${process.cwd()}/package.json`)).default;
-    const bigConfig = module.default;
-    const project = bigConfig.projects[testName];
-    if (!project) {
-        console.error("no project found for", testName, "in testeranto.config.ts");
-        process.exit(-1);
-    }
-    fs.writeFileSync(`${process.cwd()}/testeranto/projects.json`, JSON.stringify(Object.keys(bigConfig.projects), null, 2));
-    const rawConfig = bigConfig.projects[testName];
-    if (!rawConfig) {
-        console.error(`Project "${testName}" does not exist in the configuration.`);
-        console.error("Available projects:", Object.keys(bigConfig.projects));
-        process.exit(-1);
-    }
-    if (!rawConfig.tests) {
-        console.error(testName, "appears to have no tests: ", f);
-        console.error(`here is the config:`);
-        console.log(JSON.stringify(rawConfig));
-        process.exit(-1);
-    }
-    const config = Object.assign(Object.assign({}, rawConfig), { buildDir: process.cwd() + "/testeranto/bundles/" + testName });
-    console.log(ansiC.inverse("Press 'q' to initiate a graceful shutdown."));
-    console.log(ansiC.inverse("Press 'x' to quit forcefully."));
-    process.stdin.on("keypress", (str, key) => {
-        if (key.name === "x") {
-            console.log(ansiC.inverse("Shutting down forcefully..."));
-            process.exit(-1);
-        }
-    });
-    let nodeDone = false;
-    let webDone = false;
-    let importDone = false;
-    let golangDone = false;
-    let pitonoDone = false;
-    let status = "build";
-    const { nodeEntryPoints, nodeEntryPointSidecars, webEntryPoints, webEntryPointSidecars, pureEntryPoints, pureEntryPointSidecars, } = getRunnables(config.tests, testName);
-    const onNodeDone = () => {
-        nodeDone = true;
-        onDone();
-    };
-    const onWebDone = () => {
-        webDone = true;
-        onDone();
-    };
-    const onImportDone = () => {
-        importDone = true;
-        onDone();
-    };
-    const onGolangDone = () => {
-        golangDone = true;
-        onDone();
-    };
-    const onPitonoDone = () => {
-        pitonoDone = true;
-        onDone();
-    };
-    let pm = null;
-    const onDone = async () => {
-        // Check which test types are present
-        const hasGolangTests = config.tests.some(test => test[1] === 'golang');
-        const hasPitonoTests = config.tests.some(test => test[1] === 'pitono');
-        // Wait for all relevant runtimes to be done
-        const allDone = nodeDone && webDone && importDone &&
-            (!hasGolangTests || golangDone) &&
-            (!hasPitonoTests || pitonoDone);
-        if (allDone) {
-            status = "built";
-            // Start the PM_Main to run the tests after build
-            if (!pm) {
-                const { PM_Main } = await import("./PM/main");
-                pm = new PM_Main(config, testName, mode);
-                await pm.start();
-            }
-        }
-        if (allDone && mode === "once") {
-            console.log(ansiC.inverse(`${testName} was built and the builder exited successfully.`));
-            // Let PM_Main handle the exit after tests are complete
-        }
-    };
-    fs.writeFileSync(`${process.cwd()}/testeranto/projects.html`, AppHtml());
-    Object.keys(bigConfig.projects).forEach((projectName) => {
-        console.log(`testeranto/reports/${projectName}`);
-        if (!fs.existsSync(`testeranto/reports/${projectName}`)) {
-            fs.mkdirSync(`testeranto/reports/${projectName}`);
-        }
-        fs.writeFileSync(`testeranto/reports/${projectName}/config.json`, JSON.stringify(config, null, 2));
-    });
-    const getSecondaryEndpointsPoints = (runtime) => {
-        const meta = (ts, st) => {
-            ts.forEach((t) => {
-                if (t[1] === runtime) {
-                    st.add(t[0]);
-                }
-                if (Array.isArray(t[3])) {
-                    meta(t[3], st);
-                }
-            });
-            return st;
-        };
-        return Array.from(meta(config.tests, new Set()));
-    };
-    // Also handle pitono endpoints for HTML generation if needed
-    [...getSecondaryEndpointsPoints("pitono")].forEach(async (sourceFilePath) => {
-        // You might want to generate specific files for pitono tests here
-        console.log(`Pitono test found: ${sourceFilePath}`);
-    });
-    // Handle golang tests by generating their metafiles
-    const golangTests = config.tests.filter(test => test[1] === 'golang');
-    const hasGolangTests = golangTests.length > 0;
-    if (hasGolangTests) {
-        // Import and use the golang metafile utilities
-        const { generateGolangMetafile, writeGolangMetafile } = await import('./utils/golingvuMetafile');
-        // Get the entry points (first element of each test tuple)
-        const golangEntryPoints = golangTests.map(test => test[0]);
-        const metafile = await generateGolangMetafile(testName, golangEntryPoints);
-        writeGolangMetafile(testName, metafile);
-        // Mark golang as done after writing the metafile
-        onGolangDone();
-    }
-    // Handle pitono (Python) tests by generating their metafiles
-    const pitonoTests = config.tests.filter(test => test[1] === 'pitono');
-    const hasPitonoTests = pitonoTests.length > 0;
-    if (hasPitonoTests) {
-        // Import and use the pitono metafile utilities
-        const { generatePitonoMetafile } = await import('./utils/pitonoMetafile');
-        // Get the entry points (first element of each test tuple)
-        const pitonoEntryPoints = pitonoTests.map(test => test[0]);
-        const metafile = await generatePitonoMetafile(testName, pitonoEntryPoints);
-        // Ensure the directory exists
-        const pitonoMetafilePath = `${process.cwd()}/testeranto/metafiles/python`;
-        await fs.promises.mkdir(pitonoMetafilePath, { recursive: true });
-        // Write the metafile to the specified path
-        fs.writeFileSync(`${pitonoMetafilePath}/core.json`, JSON.stringify(metafile, null, 2));
-        // Mark pitono as done after writing the metafile
-        onPitonoDone();
-    }
-    Promise.resolve(Promise.all([...getSecondaryEndpointsPoints("web")].map(async (sourceFilePath) => {
-        const sourceFileSplit = sourceFilePath.split("/");
-        const sourceDir = sourceFileSplit.slice(0, -1);
-        const sourceFileName = sourceFileSplit[sourceFileSplit.length - 1];
-        const sourceFileNameMinusJs = sourceFileName
-            .split(".")
-            .slice(0, -1)
-            .join(".");
-        const htmlFilePath = path.normalize(`${process.cwd()}/testeranto/bundles/web/${testName}/${sourceDir.join("/")}/${sourceFileNameMinusJs}.html`);
-        const jsfilePath = `./${sourceFileNameMinusJs}.mjs`;
-        const cssFilePath = `./${sourceFileNameMinusJs}.css`;
-        return fs.promises
-            .mkdir(path.dirname(htmlFilePath), { recursive: true })
-            .then((x) => fs.writeFileSync(htmlFilePath, webHtmlFrame(jsfilePath, htmlFilePath, cssFilePath)));
-    })));
-    const x = [
-        ["pure", Object.keys(pureEntryPoints)],
-        ["node", Object.keys(nodeEntryPoints)],
-        ["web", Object.keys(webEntryPoints)],
-    ];
-    x.forEach(async ([runtime, keys]) => {
-        keys.forEach(async (k) => {
-            const folder = `testeranto/reports/${testName}/${k
-                .split(".")
-                .slice(0, -1)
-                .join(".")}/${runtime}`;
-            await fs.mkdirSync(folder, { recursive: true });
-        });
-    });
-    [
-        [pureEntryPoints, pureEntryPointSidecars, "pure"],
-        [webEntryPoints, webEntryPointSidecars, "web"],
-        [nodeEntryPoints, nodeEntryPointSidecars, "node"],
-    ].forEach(([eps, eps2, runtime]) => {
-        [...Object.keys(eps), ...Object.keys(eps2)].forEach((ep) => {
-            const fp = path.resolve(`testeranto`, `reports`, testName, ep.split(".").slice(0, -1).join("."), runtime);
-            fs.mkdirSync(fp, { recursive: true });
-        });
-    });
-    await Promise.all([
-        ...[
-            [
-                esbuildImportConfiger,
-                pureEntryPoints,
-                pureEntryPointSidecars,
-                onImportDone,
-            ],
-            [
-                esbuildNodeConfiger,
-                nodeEntryPoints,
-                nodeEntryPointSidecars,
-                onNodeDone,
-            ],
-            [esbuildWebConfiger, webEntryPoints, webEntryPointSidecars, onWebDone],
-        ].map(([configer, entryPoints, sidecars, done]) => {
-            esbuild
-                .context(configer(config, [...Object.keys(entryPoints), ...Object.keys(sidecars)], testName))
-                .then(async (ctx) => {
-                if (mode === "dev") {
-                    await ctx.watch().then((v) => {
-                        done();
-                    });
-                }
-                else {
-                    ctx.rebuild().then((v) => {
-                        done();
-                    });
-                }
-                return ctx;
-            });
-        }),
-    ]);
-    process.stdin.on("keypress", (str, key) => {
-        if (key.name === "q") {
-            console.log("Testeranto is shutting down gracefully...");
-            if (pm) {
-                pm.stop();
-            }
-            else {
-                process.exit();
-            }
-        }
-    });
-});

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

@@ -1,31 +0,0 @@
-export function buildTree(projects) {
-    return projects.map(projectName => ({
-        name: projectName,
-        type: 'project',
-        children: [{
-                name: 'src',
-                type: 'file',
-                children: [{
-                        name: 'components',
-                        type: 'file',
-                        children: [{
-                                name: 'pure',
-                                type: 'file',
-                                children: [
-                                    { name: 'AppFrame.test', type: 'file', path: 'src/components/pure/AppFrame.test' },
-                                    { name: 'FeaturesReporterView.test', type: 'file', path: 'src/components/pure/FeaturesReporterView.test' },
-                                    { name: 'ProjectPageView.test', type: 'file', path: 'src/components/pure/ProjectPageView.test' }
-                                ]
-                            }]
-                    }, {
-                        name: 'lib',
-                        type: 'file',
-                        children: [{
-                                name: 'baseBuilder.test',
-                                type: 'file',
-                                path: 'src/lib/baseBuilder.test'
-                            }]
-                    }]
-            }]
-    }));
-}

package/dist/module/src/utils/api.js

@@ -1,84 +0,0 @@
-import { getLogFilesForRuntime, STANDARD_LOGS } from "./logFiles";
-export const fetchProjectData = async (projectName) => {
-    const [summaryRes, configRes] = await Promise.all([
-        fetch(`reports/${projectName}/summary.json`),
-        fetch("reports/config.json"),
-    ]);
-    return {
-        summary: (await summaryRes.json()),
-        config: (await configRes.json()),
-    };
-};
-export const fetchTestData = async (projectName, filepath, runTime) => {
-    const basePath = `reports/${projectName}/${filepath
-        .split(".")
-        .slice(0, -1)
-        .join(".")}/${runTime}`;
-    try {
-        const logFiles = getLogFilesForRuntime(runTime);
-        const logs = {};
-        // Fetch all log files in parallel
-        const logRequests = logFiles.map(async (file) => {
-            try {
-                const response = await fetch(`${basePath}/${file}`);
-                if (!response.ok)
-                    return null;
-                const content = file.endsWith('.json')
-                    ? await response.json()
-                    : await response.text();
-                return { file, content };
-            }
-            catch (err) {
-                console.error(`Failed to fetch ${file}:`, err);
-                return null;
-            }
-        });
-        // Wait for all requests and populate logs
-        const logResults = await Promise.all(logRequests);
-        logResults.forEach(result => {
-            if (result) {
-                logs[result.file] = result.content;
-            }
-        });
-        // Ensure we fetch all standard logs
-        for (const file of Object.values(STANDARD_LOGS)) {
-            if (!logs[file]) {
-                try {
-                    const response = await fetch(`${basePath}/${file}`);
-                    if (response.ok) {
-                        logs[file] = file.endsWith('.json')
-                            ? await response.json()
-                            : await response.text();
-                    }
-                }
-                catch (err) {
-                    console.error(`Failed to fetch ${file}:`, err);
-                }
-            }
-        }
-        // const logs = await logFiles.reduce(async (acc, file, i) => {
-        //   acc[file.split(".")[0]] = await logRes[i].text();
-        //   return acc;
-        // }, {});
-        // Check if we got any logs at all
-        if (Object.keys(logs).length === 0) {
-            return {
-                logs: {},
-                error: "No test logs found. The test may not have run or the report files are missing."
-            };
-        }
-        return {
-            logs,
-            error: null
-        };
-    }
-    catch (err) {
-        return {
-            // testData: null,
-            logs: {},
-            // typeErrors: "",
-            // lintErrors: "",
-            error: `Failed to load test data: ${err instanceof Error ? err.message : String(err)}`,
-        };
-    }
-};

package/dist/module/src/utils/buildTemplates.js

@@ -1,33 +0,0 @@
-const getBaseHtml = (title) => `
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta name="description" content="Webpage description goes here" />
-  <meta charset="utf-8" />
-  <title>${title} - testeranto</title>
-  <meta name="viewport" content="width=device-width, initial-scale=1" />
-  <meta name="author" content="" />
-
-  <script>
-    function initApp() {
-      if (window.React && window.ReactDOM && window.App) {
-        const root = ReactDOM.createRoot(document.getElementById('root'));
-        root.render(React.createElement(App));
-      } else {
-        setTimeout(initApp, 100);
-      }
-    }
-    window.addEventListener('DOMContentLoaded', initApp);
-  </script>
-`;
-export const AppHtml = () => `
-  ${getBaseHtml("Testeranto")}
-  
-  <link rel="stylesheet" href="App.css" />
-  <script src="App.js"></script>
-</head>
-<body>
-  <div id="root"></div>
-</body>
-</html>
-`;

package/dist/module/src/utils/featureUtils.js

@@ -1,24 +0,0 @@
-export const buildTree = (features) => {
-    const tree = {};
-    features.forEach(({ name, status }) => {
-        const parts = name.split(" - ");
-        const projectAndTest = parts.slice(0, 2).join(" - ");
-        const givenAndThen = parts.slice(2).join(" - ");
-        const pathParts = projectAndTest.split("/");
-        let current = tree;
-        pathParts.forEach((part) => {
-            if (!current[part]) {
-                current[part] = {};
-            }
-            current = current[part];
-        });
-        current[givenAndThen] = status;
-    });
-    return tree;
-};
-export const renderTree = (nodes) => (React.createElement("ul", null, Object.entries(nodes).map(([key, value]) => (React.createElement("li", { key: key }, typeof value === "string" ? (React.createElement("span", null,
-    key,
-    " - ",
-    value)) : (React.createElement(React.Fragment, null,
-    React.createElement("span", null, key),
-    renderTree(value))))))));