npm - testeranto - Versions diffs - 0.100.0 → 0.110.0 - Mend

testeranto 0.100.0 → 0.110.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (285) hide show

package/dist/common/utils.js ADDED Viewed

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptPather = exports.bddExitCodePather = exports.bddPather = exports.lintExitCodePather = exports.lintPather = exports.tscExitCodePather = exports.tscPather = exports.destinationOfRuntime = void 0;
+const path_1 = __importDefault(require("path"));
+const destinationOfRuntime = (f, r, configs) => {
+    return path_1.default
+        .normalize(`${configs.buildDir}/${r}/${f}`)
+        .split(".")
+        .slice(0, -1)
+        .join(".");
+};
+exports.destinationOfRuntime = destinationOfRuntime;
+const tscPather = (entryPoint, platform) => {
+    return path_1.default.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `type_errors.txt`);
+};
+exports.tscPather = tscPather;
+const tscExitCodePather = (entryPoint, platform) => {
+    return path_1.default.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `type_errors.txt`);
+};
+exports.tscExitCodePather = tscExitCodePather;
+const lintPather = (entryPoint, platform) => {
+    return path_1.default.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `lint_errors.json`);
+};
+exports.lintPather = lintPather;
+const lintExitCodePather = (entryPoint, platform) => {
+    return path_1.default.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `lint_errors.txt`);
+};
+exports.lintExitCodePather = lintExitCodePather;
+const bddPather = (entryPoint, platform) => {
+    return path_1.default.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `tests.json`);
+};
+exports.bddPather = bddPather;
+const bddExitCodePather = (entryPoint, platform) => {
+    return path_1.default.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `bdd_errors.txt`);
+};
+exports.bddExitCodePather = bddExitCodePather;
+const promptPather = (entryPoint, platform) => {
+    return path_1.default.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `prompt.txt`);
+};
+exports.promptPather = promptPather;

package/dist/module/Footer.js ADDED Viewed

@@ -0,0 +1,4 @@
+import React from "react";
+export const Footer = () => React.createElement("footer", null,
+    "made with \u2764\uFE0F and ",
+    React.createElement("a", { href: "https://www.npmjs.com/package/testeranto" }, "testeranto "));

package/dist/module/Init.js ADDED Viewed

@@ -0,0 +1,63 @@
+import fs from "fs";
+export default async (partialConfig) => {
+    const config = Object.assign(Object.assign({}, partialConfig), { buildDir: process.cwd() + "/" + partialConfig.outdir });
+    try {
+        fs.mkdirSync(`${process.cwd()}/${config.outdir}`);
+    }
+    catch (_a) {
+        // console.log()
+    }
+    fs.writeFileSync(`${config.outdir}/index.html`, `
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta name="description" content="Webpage description goes here" />
+  <meta charset="utf-8" />
+  <title>kokomoBay - testeranto</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <meta name="author" content="" />
+  <link rel="stylesheet" href="/kokomoBay/docs/ReportClient.css" />
+  <script type="module" src="/kokomoBay/docs/ReportClient.js"></script>
+</head>
+<body>
+  <div id="root">
+    react is loading
+  </div>
+</body>
+</html>
+    `);
+    fs.copyFileSync(`node_modules/testeranto/dist/prebuild/ReportClient.js`, `${config.outdir}/ReportClient.js`);
+    fs.copyFileSync(`node_modules/testeranto/dist/prebuild/ReportClient.css`, `${config.outdir}/ReportClient.css`);
+    fs.copyFileSync(`node_modules/testeranto/dist/prebuild/TestReport.js`, `${config.outdir}/TestReport.js`);
+    fs.copyFileSync(`node_modules/testeranto/dist/prebuild/TestReport.css`, `${config.outdir}/TestReport.css`);
+    fs.writeFileSync(`${config.outdir}/testeranto.json`, JSON.stringify(Object.assign(Object.assign({}, config), { buildDir: process.cwd() + "/" + config.outdir }), null, 2));
+    try {
+        fs.mkdirSync(`${process.cwd()}/${config.outdir}/node`);
+    }
+    catch (_b) {
+        // console.log()
+    }
+    try {
+        fs.mkdirSync(`${process.cwd()}/${config.outdir}/web`);
+    }
+    catch (_c) {
+        // console.log()
+    }
+    try {
+        fs.mkdirSync(`${process.cwd()}/${config.outdir}/features`);
+    }
+    catch (_d) {
+        // console.log()
+    }
+    try {
+        fs.mkdirSync(`${process.cwd()}/${config.outdir}/ts`);
+    }
+    catch (_e) {
+        // console.log()
+    }
+};

package/dist/module/{src/PM → PM}/main.js RENAMED Viewed

@@ -1,58 +1,100 @@
 import fs from "fs";
 import path from "path";
 import puppeteer from "puppeteer-core";
-import crypto from "crypto";
+import ansiC from "ansi-colors";
+import { bddExitCodePather, lintExitCodePather, tscExitCodePather, } from "../utils";
 import { PM } from "./index.js";
 const fileStreams3 = [];
 const fPaths = [];
 const files = {};
 const recorders = {};
 const screenshots = {};
-const red = "\x1b[31m";
-const green = "\x1b[32m";
-const reset = "\x1b[0m"; // Resets to default color
 const statusMessagePretty = (failures, test) => {
     if (failures === 0) {
-        console.log(green + `${test} completed successfully` + reset);
+        console.log(ansiC.green(ansiC.inverse(`> ${test} completed successfully`)));
     }
     else {
-        console.log(red + `${test} failed ${failures} times` + reset);
+        console.log(ansiC.red(ansiC.inverse(`> ${test} failed ${failures} times`)));
     }
 };
+async function writeFileAndCreateDir(filePath, data) {
+    const dirPath = path.dirname(filePath);
+    try {
+        await fs.promises.mkdir(dirPath, { recursive: true });
+        await fs.appendFileSync(filePath, data);
+    }
+    catch (error) {
+        console.error(`Error writing file: ${error}`);
+    }
+}
+function isValidUrl(string) {
+    try {
+        new URL(string);
+        return true;
+    }
+    catch (err) {
+        return false;
+    }
+}
 export class PM_Main extends PM {
     constructor(configs) {
         super();
         this.shutdownMode = false;
+        this.bigBoard = {};
         this.checkForShutdown = () => {
-            const anyRunning = Object.values(this.registry).filter((x) => x === false).length > 0;
+            const anyRunning = Object.values(this.bigBoard).filter((x) => x.status === "running")
+                .length > 0;
             if (anyRunning) {
             }
             else {
                 this.browser.disconnect().then(() => {
-                    console.log("Goodbye");
+                    const final = {
+                        timestamp: Date.now(),
+                        tests: this.configs.tests.reduce((mm, t) => {
+                            const bddErrors = fs
+                                .readFileSync(bddExitCodePather(t[0], t[1]))
+                                .toString();
+                            const lintErrors = fs
+                                .readFileSync(lintExitCodePather(t[0], t[1]))
+                                .toString();
+                            const typeErrors = fs
+                                .readFileSync(tscExitCodePather(t[0], t[1]))
+                                .toString();
+                            mm[t[0]] = {
+                                bddErrors,
+                                lintErrors,
+                                typeErrors,
+                            };
+                            return mm;
+                        }, {}),
+                    };
+                    const s = JSON.stringify(final, null, 2);
+                    fs.writeFileSync("docs/summary.json", s);
+                    console.log(ansiC.inverse("Goodbye"));
                     process.exit();
                 });
             }
         };
-        this.register = (src) => {
-            this.registry[src] = false;
+        this.testIsNowRunning = (src) => {
+            this.bigBoard[src].status = "running";
         };
-        this.deregister = (src) => {
-            this.registry[src] = true;
+        this.testIsNowDone = (src) => {
+            this.bigBoard[src].status = "waiting";
             if (this.shutdownMode) {
                 this.checkForShutdown();
             }
         };
         this.launchNode = async (src, dest) => {
-            console.log("! node", src);
-            this.register(src);
+            // console.log(ansiC.yellow(`! node, ${src}`));
+            console.log(ansiC.green(ansiC.inverse(`! node, ${src}`)));
+            this.testIsNowRunning(src);
             const destFolder = dest.replace(".mjs", "");
             let argz = "";
             const testConfig = this.configs.tests.find((t) => {
                 return t[0] === src;
             });
             if (!testConfig) {
-                console.error("missing test config");
+                console.log(ansiC.inverse("missing test config! Exiting ungracefully!"));
                 process.exit(-1);
             }
             const testConfigResource = testConfig[2];
@@ -121,13 +163,15 @@ export class PM_Main extends PM {
                         this.receiveFeatures(features, destFolder, src);
                         // console.log(`${src} completed with ${failed} errors`);
                         statusMessagePretty(failed, src);
+                        this.receiveExitCode(src, failed);
                     })
                         .catch((e) => {
-                        console.log(`${src} errored with`, e);
+                        console.log(ansiC.red(ansiC.inverse(`${src} errored with: ${e}`)));
+                        // console.log(reset, `${src} errored with`, e);
                     })
                         .finally(() => {
                         webSideCares.forEach((webSideCar) => webSideCar.close());
-                        this.deregister(src);
+                        this.testIsNowDone(src);
                     });
                 });
             });
@@ -140,7 +184,8 @@ export class PM_Main extends PM {
         };
         this.launchWebSideCar = async (src, dest, testConfig) => {
             const d = dest + ".mjs";
-            console.log("launchWebSideCar", src, dest, d);
+            // console.log(green, "launchWebSideCar", src, dest, d);
+            console.log(ansiC.green(ansiC.inverse(`launchWebSideCar ${src}`)));
             const destFolder = dest.replace(".mjs", "");
             // const webArgz = JSON.stringify({
             //   name: dest,
@@ -247,7 +292,8 @@ export class PM_Main extends PM {
         };
         this.launchNodeSideCar = async (src, dest, testConfig) => {
             const d = dest + ".mjs";
-            console.log("launchNodeSideCar", src, dest, d);
+            // console.log(green, "launchNodeSideCar", src, dest, d);
+            console.log(ansiC.green(ansiC.inverse(`launchNodeSideCar ${src}`)));
             const destFolder = dest.replace(".mjs", "");
             let argz = "";
             const testConfigResource = testConfig[2];
@@ -317,8 +363,9 @@ export class PM_Main extends PM {
             }
         };
         this.launchWeb = (t, dest) => {
-            console.log("! web", t);
-            this.register(t);
+            // console.log(green, "! web", t);
+            console.log(ansiC.green(ansiC.inverse(`! web ${t}`)));
+            this.testIsNowRunning(t);
             // sidecars.map((sidecar) => {
             //   if (sidecar[1] === "node") {
             //     return this.launchNodeSideCar(
@@ -337,9 +384,9 @@ export class PM_Main extends PM {
             });
             const d = `${dest}?cacheBust=${Date.now()}`;
             const evaluation = `
-    console.log("importing ${d}");
     import('${d}').then(async (x) => {
-      console.log("imported", (await x.default));
       try {
         return await (await x.default).receiveTestResourceConfig(${webArgz})
       } catch (e) {
@@ -518,7 +565,7 @@ export class PM_Main extends PM {
                     Promise.all(screenshots[t] || []).then(() => {
                         delete screenshots[t];
                         page.close();
-                        this.deregister(t);
+                        this.testIsNowDone(t);
                         stderrStream.close();
                         stdoutStream.close();
                     });
@@ -536,7 +583,7 @@ export class PM_Main extends PM {
                     }
                     console.debug(`Error from message ${t}: [${err.message}] `);
                     stderrStream.write(err.message);
-                    // close();
+                    close();
                 });
                 page.on("console", (log) => {
                     // console.debug(`Log from ${t}: [${log.text()}] `);
@@ -555,11 +602,14 @@ export class PM_Main extends PM {
                     this.receiveFeatures(features, destFolder, t);
                     // console.log(`${t} completed with ${failed} errors`);
                     statusMessagePretty(failed, t);
+                    this.receiveExitCode(t, failed);
                 })
                     .catch((e) => {
-                    console.log(`${t} errored with`, e);
+                    // console.log(red, `${t} errored with`, e);
+                    console.log(ansiC.red(ansiC.inverse(`${t} errored with: ${e}`)));
                 })
                     .finally(() => {
+                    // this.testIsNowDone(t);
                     close();
                 });
                 return page;
@@ -585,14 +635,13 @@ export class PM_Main extends PM {
                                 // throw error;
                             }
                         }
-                        fs.symlink(u.pathname, newPath, (err) => {
-                            if (err) {
-                                // console.error("Error creating symlink:", err);
-                            }
-                            else {
-                                // console.log("Symlink created successfully");
-                            }
-                        });
+                        // fs.symlink(u.pathname, newPath, (err) => {
+                        //   if (err) {
+                        //     // console.error("Error creating symlink:", err);
+                        //   } else {
+                        //     // console.log("Symlink created successfully");
+                        //   }
+                        // });
                         accum.files.push(newPath);
                     }
                     else if (u.protocol === "http:" || u.protocol === "https:") {
@@ -606,13 +655,6 @@ export class PM_Main extends PM {
                     await fs.promises.mkdir(path.dirname(featureDestination), {
                         recursive: true,
                     });
-                    // const newPath = `${process.cwd()}/docs/features/plain/${await sha256(
-                    //   featureStringKey
-                    // )}`;
-                    // writeFileAndCreateDir(
-                    //   `${featureDestination}/${await sha256(featureStringKey)}`,
-                    //   featureStringKey
-                    // );
                     accum.strings.push(featureStringKey);
                 }
                 return accum;
@@ -625,32 +667,46 @@ export class PM_Main extends PM {
                 })
                     .join("\n"));
             });
+            this.writeBigBoard();
+        };
+        this.receiveExitCode = (srcTest, failures) => {
+            this.bigBoard[srcTest].runTimeError = failures;
+            this.writeBigBoard();
+        };
+        this.writeBigBoard = () => {
+            fs.writeFileSync("./docs/bigBoard.json", JSON.stringify(this.bigBoard, null, 2));
         };
         this.server = {};
         this.configs = configs;
         this.ports = {};
-        this.registry = {};
+        this.configs.tests.forEach(([t]) => {
+            this.bigBoard[t] = {
+                status: "?",
+            };
+        });
         this.configs.ports.forEach((element) => {
             this.ports[element] = "true"; // set ports as open
         });
         globalThis["waitForSelector"] = async (pageKey, sel) => {
-            console.log("waitForSelector", pageKey, sel);
-            const page = (await this.browser.pages()).find((p) => p.mainFrame()._id === pageKey);
+            const page = (await this.browser.pages()).find(
+            /* @ts-ignore:next-line */
+            (p) => p.mainFrame()._id === pageKey);
             await (page === null || page === void 0 ? void 0 : page.waitForSelector(sel));
         };
         globalThis["screencastStop"] = async (path) => {
             return recorders[path].stop();
         };
         globalThis["closePage"] = async (pageKey) => {
-            const page = (await this.browser.pages()).find((p) => p.mainFrame()._id === pageKey);
+            const page = (await this.browser.pages()).find(
+            /* @ts-ignore:next-line */
+            (p) => p.mainFrame()._id === pageKey);
+            /* @ts-ignore:next-line */
             return page.close();
         };
-        // globalThis["closePage"] = (p) => {
-        //   console.log("closePage", p);
-        //   return p.close();
-        // };
         globalThis["goto"] = async (pageKey, url) => {
-            const page = (await this.browser.pages()).find((p) => p.mainFrame()._id === pageKey);
+            const page = (await this.browser.pages()).find(
+            /* @ts-ignore:next-line */
+            (p) => p.mainFrame()._id === pageKey);
             await (page === null || page === void 0 ? void 0 : page.goto(url));
             return;
         };
@@ -669,14 +725,9 @@ export class PM_Main extends PM {
             return false;
         };
         globalThis["writeFileSync"] = (filepath, contents, testName) => {
-            // console.log(testName, "writeFileSync", filepath, testName);
-            // Create directories if they don't exist
-            const dir = path.dirname(filepath);
-            // console.log(testName, "mkdirSync", dir);
-            fs.mkdirSync(dir, {
+            fs.mkdirSync(path.dirname(filepath), {
                 recursive: true,
             });
-            // console.log(testName, "mkdirSync2");
             if (!files[testName]) {
                 files[testName] = new Set();
             }
@@ -723,7 +774,9 @@ export class PM_Main extends PM {
         //   // page.evaluate(`window["screenshot done"]`);
         // };
         globalThis["customScreenShot"] = async (opts, pageKey, testName) => {
-            const page = (await this.browser.pages()).find((p) => p.mainFrame()._id === pageKey);
+            const page = (await this.browser.pages()).find(
+            /* @ts-ignore:next-line */
+            (p) => p.mainFrame()._id === pageKey);
             const p = opts.path;
             const dir = path.dirname(p);
             fs.mkdirSync(dir, {
@@ -742,7 +795,9 @@ export class PM_Main extends PM {
             return sPromise;
         };
         globalThis["screencast"] = async (opts, pageKey) => {
-            const page = (await this.browser.pages()).find((p) => p.mainFrame()._id === pageKey);
+            const page = (await this.browser.pages()).find(
+            /* @ts-ignore:next-line */
+            (p) => p.mainFrame()._id === pageKey);
             const p = opts.path;
             const dir = path.dirname(p);
             fs.mkdirSync(dir, {
@@ -876,36 +931,14 @@ export class PM_Main extends PM {
     async startPuppeteer(options, destfolder) {
         this.browser = (await puppeteer.launch(options));
     }
-    ////////////////////////////////////////////////////////////////////////////////
+    // goodbye = () => {
+    //   this.browser.disconnect().then(() => {
+    //     console.log("Goodbye");
+    //     process.exit();
+    //   });
+    // };
     shutDown() {
-        console.log("shutting down...");
         this.shutdownMode = true;
         this.checkForShutdown();
     }
 }
-async function writeFileAndCreateDir(filePath, data) {
-    const dirPath = path.dirname(filePath);
-    try {
-        await fs.promises.mkdir(dirPath, { recursive: true });
-        await fs.appendFileSync(filePath, data);
-    }
-    catch (error) {
-        console.error(`Error writing file: ${error}`);
-    }
-}
-async function sha256(rawData) {
-    const data = typeof rawData === "object" ? JSON.stringify(rawData) : String(rawData);
-    const msgBuffer = new TextEncoder().encode(data);
-    const hashBuffer = await crypto.subtle.digest("SHA-256", msgBuffer);
-    const hashArray = Array.from(new Uint8Array(hashBuffer));
-    return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
-}
-function isValidUrl(string) {
-    try {
-        new URL(string);
-        return true;
-    }
-    catch (err) {
-        return false;
-    }
-}

package/dist/module/ReportClient.js ADDED Viewed

@@ -0,0 +1,97 @@
+import ReactDom from "react-dom/client";
+import React, { useEffect, useState } from "react";
+import 'bootstrap/dist/css/bootstrap.min.css';
+import "./style.css";
+import { Footer } from "./Footer";
+const BigBoard = () => {
+    const [configs, setConfigs] = useState();
+    useEffect(() => {
+        (async () => {
+            fetch('/kokomoBay/docs/testeranto.json')
+                .then(response => response.json())
+                .then(json => {
+                setConfigs(json);
+            })
+                .catch(error => console.error(error));
+        })();
+    }, []);
+    const [bigBoard, setBigBoard] = useState({});
+    useEffect(() => {
+        (async () => {
+            fetch('/kokomoBay/docs/bigBoard.json')
+                .then(response => response.json())
+                .then(json => {
+                setBigBoard(json);
+            })
+                .catch(error => console.error(error));
+        })();
+    }, []);
+    const [staticAnalysis, setStaticAnalysis] = useState({});
+    useEffect(() => {
+        (async () => {
+            let accumulator = {};
+            for (const t of (configs || { tests: [] }).tests) {
+                accumulator[t[0]] = await (await fetch(`/kokomoBay/docs/${t[1]}/${t[0].split(".").slice(0, -1).join(".")}/lint_errors.txt`)).text();
+            }
+            setStaticAnalysis(accumulator);
+        })();
+    }, [configs, bigBoard]);
+    const [typeErrors, setTypeErrors] = useState({});
+    useEffect(() => {
+        (async () => {
+            let accumulator = {};
+            for (const t of (configs || { tests: [] }).tests) {
+                accumulator[t[0]] = await (await fetch(`/kokomoBay/docs/${t[1]}/${t[0].split(".").slice(0, -1).join(".")}/type_errors.txt`)).text();
+            }
+            setTypeErrors(accumulator);
+        })();
+    }, [configs, bigBoard]);
+    const [bddErrors, setBddErrors] = useState({});
+    useEffect(() => {
+        (async () => {
+            let accumulator = {};
+            for (const t of (configs || { tests: [] }).tests) {
+                accumulator[t[0]] = await (await fetch(`/kokomoBay/docs/${t[1]}/${t[0].split(".").slice(0, -1).join(".")}/bdd_errors.txt`)).text();
+            }
+            setBddErrors(accumulator);
+        })();
+    }, [configs, bigBoard]);
+    if (!configs || !staticAnalysis || !typeErrors || !bddErrors) {
+        return React.createElement("div", null, "loading...");
+    }
+    const collated = configs.tests.map((c) => {
+        return Object.assign(Object.assign({}, bigBoard[c[0]]), { name: c[0], runTime: c[1], tr: c[2], sidecars: c[3], staticAnalysis: staticAnalysis[c[0]], typeErrors: typeErrors[c[0]], bddErrors: bddErrors[c[0]] });
+    });
+    return React.createElement("div", null,
+        React.createElement("table", null,
+            React.createElement("tr", null,
+                React.createElement("td", null, "name"),
+                React.createElement("td", null, "run time"),
+                React.createElement("td", null, "BDD errors"),
+                React.createElement("td", null, "Lint errors"),
+                React.createElement("td", null, "Type errors"),
+                React.createElement("td", null, "prompt")),
+            ...collated.map((c) => {
+                return React.createElement("tr", null,
+                    React.createElement("td", null, c.name),
+                    React.createElement("td", null, c.runTime),
+                    React.createElement("td", null,
+                        React.createElement("a", { href: `${c.runTime}/${c.name.split(".").slice(0, -1).join(".")}/littleBoard.html` }, c.bddErrors)),
+                    React.createElement("td", null,
+                        React.createElement("a", { href: `${c.runTime}/${c.name.split(".").slice(0, -1).join(".")}/lint_errors.json` }, c.staticAnalysis)),
+                    React.createElement("td", null,
+                        React.createElement("a", { href: `${c.runTime}/${c.name.split(".").slice(0, -1).join(".")}/type_errors.txt` }, c.typeErrors)),
+                    React.createElement("td", null,
+                        React.createElement("pre", null,
+                            "aider --model deepseek/deepseek-chat --load ",
+                            `docs/${c.runTime}/${c.name.split(".").slice(0, -1).join(".")}/prompt.txt`)));
+            })),
+        React.createElement(Footer, null));
+};
+document.addEventListener("DOMContentLoaded", function () {
+    const elem = document.getElementById("root");
+    if (elem) {
+        ReactDom.createRoot(elem).render(React.createElement(BigBoard, {}, []));
+    }
+});
+console.log("hello BigBoard!");

package/dist/module/ReportServer.js ADDED Viewed

@@ -0,0 +1,17 @@
+import staticServer from "node-static";
+import http from "http";
+const main = async () => {
+    process.chdir("../"); // Navigate one level up
+    const fileServer = new staticServer.Server(".", {});
+    http
+        .createServer(function (request, response) {
+        request
+            .addListener("end", function () {
+            fileServer.serve(request, response);
+        })
+            .resume();
+    })
+        .listen(8080);
+    console.log("Server running on port 8080");
+};
+main();

package/dist/module/SubPackages/react/jsx/index.js ADDED Viewed

@@ -0,0 +1,15 @@
+import React from "react";
+export const testInterface = {
+    andWhen: async (s, whenCB) => {
+        await whenCB(s());
+        return new Promise((resolve, rej) => {
+            resolve(React.createElement(s));
+        });
+    },
+    butThen: async (subject, thenCB) => {
+        await thenCB(subject());
+        return new Promise((resolve, rej) => {
+            resolve(React.createElement(subject));
+        });
+    },
+};

package/dist/module/{src/SubPackages → SubPackages}/react-dom/component/node.js RENAMED Viewed

@@ -5,34 +5,21 @@ import Testeranto from "../../../Node.js";
 export { renderToStaticMarkup, renderToStaticNodeStream, Stream };
 export default (testImplementations, testSpecifications, testInput) => {
     return Testeranto(testInput, testSpecifications, testImplementations, {
-        // beforeAll: async (
-        //   prototype,
-        //   artificer
-        // ): Promise<ISubject> => {
-        //   return await new Promise((resolve, rej) => {
-        //     const elem = document.getElementById("root");
-        //     if (elem) {
-        //       resolve({ htmlElement: elem });
-        //     }
-        //   })
-        // },
-        beforeEach: async (reactComponent, ndx, testRsource, artificer) => {
+        beforeEach: async () => {
             return new Promise((resolve, rej) => {
-                // Ignore these type errors
                 resolve(createElement(testInput));
             });
         },
         andWhen: async function (s, whenCB) {
             return whenCB(s);
-            // return s
         },
         butThen: async function (s) {
             return s;
         },
-        afterEach: async function (store, ndx, artificer) {
+        afterEach: async function () {
             return {};
         },
-        afterAll: (store, artificer) => {
+        afterAll: () => {
             return;
         },
     });