testeranto 0.114.1 → 0.125.0

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

@@ -0,0 +1,154 @@
+import net from "net";
+import fs from "fs";
+import path from "path";
+import { PM } from ".";
+const fPaths = [];
+export class PM_Node extends PM {
+    constructor(t) {
+        super();
+        this.testResourceConfiguration = t;
+    }
+    start() {
+        return new Promise((res) => {
+            process.on("message", (message) => {
+                if (message.path) {
+                    this.client = net.createConnection(message.path, () => {
+                        res();
+                    });
+                }
+            });
+        });
+    }
+    stop() {
+        throw new Error("Method not implemented.");
+    }
+    send(command, ...argz) {
+        return new Promise((res) => {
+            const key = Math.random().toString();
+            const myListener = (event) => {
+                const x = JSON.parse(event);
+                if (x.key === key) {
+                    process.removeListener("message", myListener);
+                    res(x.payload);
+                }
+            };
+            process.addListener("message", myListener);
+            this.client.write(JSON.stringify([command, ...argz, key]));
+        });
+    }
+    async pages() {
+        return this.send("pages", ...arguments);
+    }
+    waitForSelector(p, s) {
+        return this.send("waitForSelector", ...arguments);
+    }
+    closePage(p) {
+        return this.send("closePage", ...arguments);
+        // return globalThis["closePage"](p);
+    }
+    goto(page, url) {
+        return this.send("goto", ...arguments);
+        // return globalThis["goto"](cdpPage.mainFrame()._id, url);
+    }
+    async newPage() {
+        return this.send("newPage");
+    }
+    $(selector) {
+        return this.send("$", ...arguments);
+    }
+    isDisabled(selector) {
+        return this.send("isDisabled", ...arguments);
+    }
+    getAttribute(selector, attribute) {
+        return this.send("getAttribute", ...arguments);
+    }
+    getValue(selector) {
+        return this.send("getValue", ...arguments);
+    }
+    focusOn(selector) {
+        return this.send("focusOn", ...arguments);
+    }
+    typeInto(selector) {
+        return this.send("typeInto", ...arguments);
+    }
+    page() {
+        return this.send("page");
+    }
+    click(selector) {
+        return this.send("click", ...arguments);
+    }
+    screencast(opts, page) {
+        return this.send("screencast", Object.assign(Object.assign({}, opts), { path: this.testResourceConfiguration.fs + "/" + opts.path }), page, this.testResourceConfiguration.name);
+    }
+    screencastStop(p) {
+        return this.send("screencastStop", ...arguments);
+    }
+    customScreenShot(opts, page) {
+        return this.send("customScreenShot", Object.assign(Object.assign({}, opts), { path: this.testResourceConfiguration.fs + "/" + opts.path }), page, this.testResourceConfiguration.name);
+    }
+    async existsSync(destFolder) {
+        return await this.send("existsSync", this.testResourceConfiguration.fs + "/" + destFolder);
+    }
+    mkdirSync() {
+        return this.send("mkdirSync", this.testResourceConfiguration.fs + "/");
+    }
+    async write(uid, contents) {
+        return await this.send("write", ...arguments);
+    }
+    async writeFileSync(filepath, contents) {
+        return await this.send("writeFileSync", this.testResourceConfiguration.fs + "/" + filepath, contents, this.testResourceConfiguration.name);
+    }
+    async createWriteStream(filepath) {
+        return await this.send("createWriteStream", this.testResourceConfiguration.fs + "/" + filepath, this.testResourceConfiguration.name);
+    }
+    async end(uid) {
+        return await this.send("end", ...arguments);
+    }
+    async customclose() {
+        return await this.send("customclose", this.testResourceConfiguration.fs, this.testResourceConfiguration.name);
+    }
+    testArtiFactoryfileWriter(tLog, callback) {
+        return (fPath, value) => {
+            callback(new Promise((res, rej) => {
+                tLog("testArtiFactory =>", fPath);
+                const cleanPath = path.resolve(fPath);
+                fPaths.push(cleanPath.replace(process.cwd(), ``));
+                const targetDir = cleanPath.split("/").slice(0, -1).join("/");
+                fs.mkdir(targetDir, { recursive: true }, async (error) => {
+                    if (error) {
+                        console.error(`❗️testArtiFactory failed`, targetDir, error);
+                    }
+                    fs.writeFileSync(path.resolve(targetDir.split("/").slice(0, -1).join("/"), "manifest"), fPaths.join(`\n`), {
+                        encoding: "utf-8",
+                    });
+                    if (Buffer.isBuffer(value)) {
+                        fs.writeFileSync(fPath, value, "binary");
+                        res();
+                    }
+                    else if (`string` === typeof value) {
+                        fs.writeFileSync(fPath, value.toString(), {
+                            encoding: "utf-8",
+                        });
+                        res();
+                    }
+                    else {
+                        /* @ts-ignore:next-line */
+                        const pipeStream = value;
+                        const myFile = fs.createWriteStream(fPath);
+                        pipeStream.pipe(myFile);
+                        pipeStream.on("close", () => {
+                            myFile.close();
+                            res();
+                        });
+                    }
+                });
+            }));
+        };
+    }
+    // launch(options?: PuppeteerLaunchOptions): Promise<Browser>;
+    startPuppeteer(options) {
+        // return puppeteer.connect(options).then((b) => {
+        //   this.browser = b;
+        // });
+    }
+}

package/dist/module/{PM/node.js → src/PM/pure.js}

@@ -1,13 +1,22 @@
 import fs from "fs";
 import path from "path";
-import { PM } from "./index.js";
+import { PM } from ".";
 const fPaths = [];
-export class PM_Node extends PM {
+export class PM_Pure extends PM {
     constructor(t) {
         super();
         this.server = {};
         this.testResourceConfiguration = t;
     }
+    start() {
+        return new Promise((r) => r());
+    }
+    stop() {
+        return new Promise((r) => r());
+    }
+    pages() {
+        return globalThis["pages"]();
+    }
     waitForSelector(p, s) {
         return globalThis["waitForSelector"](p, s);
     }
@@ -21,22 +30,22 @@ export class PM_Node extends PM {
         return globalThis["newPage"]();
     }
     $(selector) {
-        throw new Error("Method not implemented.");
+        return globalThis["$"](selector);
     }
     isDisabled(selector) {
-        throw new Error("Method not implemented.");
+        return globalThis["isDisabled"](selector);
     }
     getAttribute(selector, attribute) {
-        throw new Error("Method not implemented.");
+        return globalThis["getAttribute"](selector, attribute);
     }
     getValue(selector) {
-        throw new Error("Method not implemented.");
+        return globalThis["getValue"](selector);
     }
     focusOn(selector) {
-        throw new Error("Method not implemented.");
+        return globalThis["focusOn"](selector);
     }
-    typeInto(value) {
-        throw new Error("Method not implemented.");
+    typeInto(selector, value) {
+        return globalThis["typeInto"](selector, value);
     }
     page() {
         return globalThis["page"]();
@@ -45,13 +54,13 @@ export class PM_Node extends PM {
         return globalThis["click"](selector);
     }
     screencast(opts, page) {
-        return globalThis["screencast"](Object.assign(Object.assign({}, opts), { path: this.testResourceConfiguration.fs + "/" + opts.path }), page.mainFrame()._id, this.testResourceConfiguration.name);
+        return globalThis["screencast"](Object.assign(Object.assign({}, opts), { path: this.testResourceConfiguration.fs + "/" + opts.path }), page, this.testResourceConfiguration.name);
     }
     screencastStop(p) {
         return globalThis["screencastStop"](p);
     }
-    customScreenShot(opts, cdpPage) {
-        return globalThis["customScreenShot"](Object.assign(Object.assign({}, opts), { path: this.testResourceConfiguration.fs + "/" + opts.path }), cdpPage.mainFrame()._id, this.testResourceConfiguration.name);
+    customScreenShot(opts, page) {
+        return globalThis["customScreenShot"](Object.assign(Object.assign({}, opts), { path: this.testResourceConfiguration.fs + "/" + opts.path }), page, this.testResourceConfiguration.name);
     }
     existsSync(destFolder) {
         return globalThis["existsSync"](this.testResourceConfiguration.fs + "/" + destFolder);
@@ -59,8 +68,8 @@ export class PM_Node extends PM {
     mkdirSync() {
         return globalThis["mkdirSync"](this.testResourceConfiguration.fs + "/");
     }
-    write(writeObject, contents) {
-        return globalThis["write"](writeObject.uid, contents);
+    write(uid, contents) {
+        return globalThis["write"](uid, contents);
     }
     writeFileSync(filepath, contents) {
         return globalThis["writeFileSync"](this.testResourceConfiguration.fs + "/" + filepath, contents, this.testResourceConfiguration.name);
@@ -68,8 +77,8 @@ export class PM_Node extends PM {
     createWriteStream(filepath) {
         return globalThis["createWriteStream"](this.testResourceConfiguration.fs + "/" + filepath, this.testResourceConfiguration.name);
     }
-    end(writeObject) {
-        return globalThis["end"](writeObject.uid);
+    end(uid) {
+        return globalThis["end"](uid);
     }
     customclose() {
         globalThis["customclose"](this.testResourceConfiguration.fs, this.testResourceConfiguration.name);

package/dist/module/{PM → src/PM}/web.js

@@ -1,15 +1,18 @@
-import { PM } from "./index.js";
-export class PM_Web extends PM {
+export class PM_Web {
     constructor(t) {
-        super();
-        this.server = {};
         this.testResourceConfiguration = t;
     }
+    start() {
+        return new Promise((r) => r());
+    }
+    stop() {
+        return new Promise((r) => r());
+    }
     waitForSelector(p, s) {
         return window["waitForSelector"](p, s);
     }
-    screencast(opts) {
-        return window["screencast"](Object.assign(Object.assign({}, opts), { path: this.testResourceConfiguration.fs + "/" + opts.path }), this.testResourceConfiguration.name);
+    screencast(opts, page) {
+        return window["screencast"](Object.assign(Object.assign({}, opts), { path: this.testResourceConfiguration.fs + "/" + opts.path }), page.mainFrame()._id, this.testResourceConfiguration.name);
     }
     screencastStop(recorder) {
         return window["screencastStop"](recorder);
@@ -47,7 +50,7 @@ export class PM_Web extends PM {
     click(selector) {
         return window["click"](selector);
     }
-    customScreenShot(opts) {
+    customScreenShot(opts, page) {
         return window["customScreenShot"](Object.assign(Object.assign({}, opts), { path: this.testResourceConfiguration.fs + "/" + opts.path }), this.testResourceConfiguration.name);
     }
     existsSync(destFolder) {
@@ -56,8 +59,8 @@ export class PM_Web extends PM {
     mkdirSync(x) {
         return window["mkdirSync"](this.testResourceConfiguration.fs + "/");
     }
-    write(writeObject, contents) {
-        return window["write"](writeObject.uid, contents);
+    write(uid, contents) {
+        return window["write"](uid, contents);
     }
     writeFileSync(filepath, contents) {
         return window["writeFileSync"](this.testResourceConfiguration.fs + "/" + filepath, contents, this.testResourceConfiguration.name);
@@ -65,8 +68,8 @@ export class PM_Web extends PM {
     createWriteStream(filepath) {
         return window["createWriteStream"](this.testResourceConfiguration.fs + "/" + filepath, this.testResourceConfiguration.name);
     }
-    end(writeObject) {
-        return window["end"](writeObject.uid);
+    end(uid) {
+        return window["end"](uid);
     }
     customclose() {
         window["customclose"](this.testResourceConfiguration.fs, this.testResourceConfiguration.name);
@@ -75,42 +78,6 @@ export class PM_Web extends PM {
         return (fPath, value) => {
             callback(new Promise((res, rej) => {
                 tLog("testArtiFactory =>", fPath);
-                // const cleanPath = path.resolve(fPath);
-                // fPaths.push(cleanPath.replace(process.cwd(), ``));
-                // const targetDir = cleanPath.split("/").slice(0, -1).join("/");
-                // fs.mkdir(targetDir, { recursive: true }, async (error) => {
-                //   if (error) {
-                //     console.error(`❗️testArtiFactory failed`, targetDir, error);
-                //   }
-                //   fs.writeFileSync(
-                //     path.resolve(
-                //       targetDir.split("/").slice(0, -1).join("/"),
-                //       "manifest"
-                //     ),
-                //     fPaths.join(`\n`),
-                //     {
-                //       encoding: "utf-8",
-                //     }
-                //   );
-                //   if (Buffer.isBuffer(value)) {
-                //     fs.writeFileSync(fPath, value, "binary");
-                //     res();
-                //   } else if (`string` === typeof value) {
-                //     fs.writeFileSync(fPath, value.toString(), {
-                //       encoding: "utf-8",
-                //     });
-                //     res();
-                //   } else {
-                //     /* @ts-ignore:next-line */
-                //     const pipeStream: PassThrough = value;
-                //     const myFile = fs.createWriteStream(fPath);
-                //     pipeStream.pipe(myFile);
-                //     pipeStream.on("close", () => {
-                //       myFile.close();
-                //       res();
-                //     });
-                //   }
-                // });
             }));
         };
     }

package/dist/module/src/Project.js

@@ -0,0 +1,120 @@
+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";
+import { Table } from "react-bootstrap";
+const BigBoard = () => {
+    const bigConfigElement = document.getElementById('bigConfig');
+    if (!bigConfigElement)
+        throw new Error('bigConfig element not found');
+    const projects = JSON.parse(bigConfigElement.innerHTML);
+    // const projects = Object.keys(bigConfig.projects);
+    // const [configs, setConfigs] = useState<IBuiltConfig>();
+    // useEffect(() => {
+    //   (async () => {
+    //     fetch('/kokomoBay/docs/testeranto.json')
+    //       .then(response => response.json())
+    //       .then(json => {
+    //         setConfigs(json)
+    //       })
+    //       .catch(error => console.error(error));
+    //   })();
+    // }, []);
+    // const [bigBoard, setBigBoard] = useState<Record<string, ISummary>>({});
+    // useEffect(() => {
+    //   (async () => {
+    //     fetch('/kokomoBay/docs/summary.json')
+    //       .then(response => response.json())
+    //       .then(json => {
+    //         setBigBoard(json)
+    //       })
+    //       .catch(error => console.error(error));
+    //   })();
+    // }, []);
+    const [summary, setSummary] = useState();
+    useEffect(() => {
+        (async () => {
+            const x = projects.map(async (p) => {
+                return [
+                    p,
+                    (await (await fetch(`/kokomoBay/testeranto/reports/${p}/config.json`)).json()),
+                    (await (await fetch(`/kokomoBay/testeranto/reports/${p}/summary.json`)).json())
+                ];
+            });
+            Promise.all(x).then((v) => {
+                setSummary(v);
+            });
+            // fetch('/kokomoBay/docs/summary.json')
+            //   .then(response => response.json())
+            //   .then(json => {
+            //     setBigBoard(json)
+            //   })
+            //   .catch(error => console.error(error));
+        })();
+    }, []);
+    if (!summary || (summary === null || summary === void 0 ? void 0 : summary.length) === 0) {
+        return React.createElement("div", null, "loading...");
+    }
+    console.log("summary", summary);
+    // const collated: ICollations = configs.tests.map((c) => {
+    //   return {
+    //     ...bigBoard[c[0]],
+    //     name: c[0],
+    //     runTime: c[1],
+    //     tr: c[2],
+    //     sidecars: c[3],
+    //     staticAnalysis: bigBoard[c[0]].staticErrors,
+    //     typeErrors: bigBoard[c[0]].typeErrors,
+    //     bddErrors: bigBoard[c[0]].runTimeError,
+    //     prompt: bigBoard[c[0]].prompt
+    //   } as ICollation
+    // });
+    function copyToClipboard(text) {
+        navigator.clipboard.writeText(text)
+            .then(() => {
+            console.log('Text copied to clipboard');
+        })
+            .catch(err => {
+            console.error('Error copying text: ', err);
+        });
+    }
+    return React.createElement("div", null,
+        React.createElement(Table, { striped: true, bordered: true, hover: true },
+            React.createElement("thead", null,
+                React.createElement("tr", null,
+                    React.createElement("th", null, "project"),
+                    React.createElement("th", null, "platform"),
+                    React.createElement("th", null, "BDD errors"),
+                    React.createElement("th", null, "Lint errors"),
+                    React.createElement("th", null, "Type errors"),
+                    React.createElement("th", null, "prompt"))),
+            React.createElement("tbody", null, ...summary.map((s) => {
+                return React.createElement(React.Fragment, null,
+                    React.createElement("tr", null,
+                        React.createElement("th", null, s[0])),
+                    ...s[1].tests.map((t) => {
+                        const x = `${s[0]}/${t[0].split(".").slice(0, -1).join(".")}/${t[1]}`;
+                        const y = s[2][t[0]];
+                        return React.createElement("tr", null,
+                            React.createElement("td", null, t[0]),
+                            React.createElement("td", null, t[1]),
+                            React.createElement("td", null,
+                                React.createElement("a", { href: `/kokomoBay/testeranto/reports/${x}/littleBoard.html` }, y.runTimeError)),
+                            React.createElement("td", null,
+                                React.createElement("a", { href: `/kokomoBay/testeranto/reports/${x}/lint_errors.json` }, y.staticErrors)),
+                            React.createElement("td", null,
+                                React.createElement("a", { href: `/kokomoBay/testeranto/reports/${x}/type_errors.txt` }, y.typeErrors)),
+                            React.createElement("td", null,
+                                React.createElement("pre", null, s[2][t[0]].prompt)));
+                    }));
+            }))),
+        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/{Node.js → src/Pure.js}

@@ -1,7 +1,7 @@
 import Testeranto from "./lib/core.js";
 import { defaultTestResourceRequirement, } from "./lib/index.js";
-import { PM_Node } from "./PM/node.js";
-export class NodeTesteranto extends Testeranto {
+import { PM_Pure } from "./PM/pure.js";
+export class PureTesteranto extends Testeranto {
     constructor(input, testSpecification, testImplementation, testResourceRequirement, testInterface) {
         super(input, testSpecification, testImplementation, testResourceRequirement, testInterface, () => {
             // no-op
@@ -9,12 +9,14 @@ export class NodeTesteranto extends Testeranto {
     }
     async receiveTestResourceConfig(partialTestResource) {
         const t = JSON.parse(partialTestResource);
-        const pm = new PM_Node(t);
-        const { failed, artifacts, logPromise, features } = await this.testJobs[0].receiveTestResourceConfig(pm);
-        // pm.customclose();
-        return { features, failed };
+        const pm = new PM_Pure(t);
+        return await this.testJobs[0].receiveTestResourceConfig(pm);
+        // const { failed, artifacts, logPromise, features, fails } =
+        //   await this.testJobs[0].receiveTestResourceConfig(pm);
+        // // pm.customclose();
+        // return { features, failed, fails };
     }
 }
 export default async (input, testSpecification, testImplementation, testInterface, testResourceRequirement = defaultTestResourceRequirement) => {
-    return new NodeTesteranto(input, testSpecification, testImplementation, testResourceRequirement, testInterface);
+    return new PureTesteranto(input, testSpecification, testImplementation, testResourceRequirement, testInterface);
 };

package/dist/module/{ReportClient.js → src/ReportClient.js}

@@ -8,7 +8,7 @@ const BigBoard = () => {
     const [configs, setConfigs] = useState();
     useEffect(() => {
         (async () => {
-            fetch('/kokomoBay/docs/testeranto.json')
+            fetch(`/kokomoBay/testeranto/reports/${window.location.pathname.split('/').pop()}/config.json`)
                 .then(response => response.json())
                 .then(json => {
                 setConfigs(json);

package/dist/module/{SubPackages/react/component/web.js → src/SubPackages/react/component/index.js}

@@ -1,7 +1,6 @@
 import React from "react";
-import Testeranto from "../../../Web.js";
-export default (testImplementations, testSpecifications, testInput) => {
-    return Testeranto(testInput, testSpecifications, testImplementations, {
+export const reactInterfacer = (testInput) => {
+    return {
         beforeEach: async () => {
             return new Promise((resolve, rej) => {
                 resolve(React.createElement(testInput, {}, []));
@@ -10,5 +9,5 @@ export default (testImplementations, testSpecifications, testInput) => {
         andWhen: function (s, whenCB) {
             return whenCB()(s);
         },
-    });
+    };
 };

package/dist/module/src/SubPackages/react/component/node.js

@@ -0,0 +1,5 @@
+import Testeranto from "../../../Node.js";
+import { reactInterfacer } from "./index.js";
+export default (testImplementations, testSpecifications, testInput) => {
+    return Testeranto(testInput, testSpecifications, testImplementations, reactInterfacer(testInput));
+};

package/dist/module/src/SubPackages/react/component/pure.js

@@ -0,0 +1,5 @@
+import Testeranto from "../../../Pure.js";
+import { reactInterfacer } from "./index.js";
+export default (testImplementations, testSpecifications, testInput) => {
+    return Testeranto(testInput, testSpecifications, testImplementations, reactInterfacer(testInput));
+};

package/dist/module/{SubPackages/react/jsx → src/SubPackages/react/component}/web.js

@@ -1,5 +1,5 @@
 import Testeranto from "../../../Web.js";
-import { testInterface as baseInterface, } from "./index.js";
-export default (testImplementations, testSpecifications, testInput, testInterface) => {
-    return Testeranto(testInput, testSpecifications, testImplementations, Object.assign(Object.assign({}, baseInterface), testInterface));
+import { reactInterfacer } from "./index.js";
+export default (testImplementations, testSpecifications, testInput) => {
+    return Testeranto(testInput, testSpecifications, testImplementations, reactInterfacer(testInput));
 };

package/dist/module/src/SubPackages/react/jsx/index.js

@@ -0,0 +1,58 @@
+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));
+        });
+    },
+};
+// export type IWhenShape = any;
+// export type IThenShape = any;
+// export type InitialState = unknown;
+// export type IInput = () => JSX.Element;
+// export type ISelection = CElement<any, any>;
+// export type IStore = CElement<any, any>;
+// export type ISubject = CElement<any, any>;
+// export type ITestImpl<
+//   I extends Ibdd_in<
+//     unknown,
+//     unknown,
+//     unknown,
+//     unknown,
+//     unknown,
+//     unknown,
+//     unknown
+//   >,
+//   O extends Ibdd_out<
+//     Record<string, any>,
+//     Record<string, any>,
+//     Record<string, any>,
+//     Record<string, any>,
+//     Record<string, any>
+//   >
+// > = ITestImplementation<I, O>;
+// export type ITestSpec<
+//   I extends Ibdd_in<
+//     unknown,
+//     unknown,
+//     unknown,
+//     unknown,
+//     unknown,
+//     unknown,
+//     unknown
+//   >,
+//   O extends Ibdd_out<
+//     Record<string, any>,
+//     Record<string, any>,
+//     Record<string, any>,
+//     Record<string, any>,
+//     Record<string, any>
+//   >
+// > = ITestSpecification<I, O>;

package/dist/module/{SubPackages → src/SubPackages}/react/jsx/node.js

@@ -1,5 +1,5 @@
 import Testeranto from "../../../Node.js";
-import { testInterface as baseInterface, } from "./index.js";
+import { testInterface as baseInterface } from "./index.js";
 export default (testImplementations, testSpecifications, testInput, testInterface = baseInterface) => {
     return Testeranto(testInput, testSpecifications, testImplementations, testInterface);
 };

package/dist/module/src/SubPackages/react/jsx/pure.js

@@ -0,0 +1,5 @@
+import Testeranto from "../../../Pure.js";
+import { testInterface as baseInterface } from "./index.js";
+export default (testImplementations, testSpecifications, testInput, testInterface = baseInterface) => {
+    return Testeranto(testInput, testSpecifications, testImplementations, testInterface);
+};

package/dist/module/src/SubPackages/react/jsx/web.js

@@ -0,0 +1,5 @@
+import Testeranto from "../../../Web.js";
+import { testInterface as baseInterface } from "./index.js";
+export default (testImplementations, testSpecifications, testInput, testInterface = baseInterface) => {
+    return Testeranto(testInput, testSpecifications, testImplementations, testInterface);
+};

package/dist/module/{SubPackages/react-dom/component/web.js → src/SubPackages/react-dom/component/dynamic.js}

@@ -1,8 +1,7 @@
-import { createElement } from "react";
+import React from "react";
 import ReactDom from "react-dom/client";
-import Testeranto from "../../../Web.js";
-export default (testInput, testSpecifications, testImplementations, testInterface) => {
-    class TesterantoComponent extends testInput {
+export const testInterfacer = () => {
+    class TesterantoComponent extends React.Component {
         constructor(props) {
             super(props);
             this.done = props.done;
@@ -12,7 +11,7 @@ export default (testInput, testSpecifications, testImplementations, testInterfac
             return this.done(this);
         }
     }
-    const t = Testeranto(testInput, testSpecifications, testImplementations, {
+    return {
         beforeAll: async (subject, artificer) => {
             return await new Promise((resolve, rej) => {
                 const htmlElement = document.getElementById("root");
@@ -51,12 +50,5 @@ export default (testInput, testSpecifications, testImplementations, testInterfac
             // store.htmlElement = document.createElement("root");
             return store;
         },
-    });
-    document.addEventListener("DOMContentLoaded", function () {
-        const elem = document.getElementById("root");
-        if (elem) {
-            return t;
-        }
-    });
-    return t;
+    };
 };