testeranto 0.121.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/{Project.js → src/Project.js}

@@ -5,7 +5,10 @@ import "./style.css";
 import { Footer } from "./Footer";
 import { Table } from "react-bootstrap";
 const BigBoard = () => {
-    const projects = JSON.parse(document.getElementById('bigConfig').innerHTML);
+    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(() => {
@@ -99,7 +102,7 @@ const BigBoard = () => {
                             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.html` }, y.staticErrors)),
+                                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,
@@ -111,7 +114,7 @@ const BigBoard = () => {
 document.addEventListener("DOMContentLoaded", function () {
     const elem = document.getElementById("root");
     if (elem) {
-        ReactDom.createRoot(elem).render(React.createElement(BigBoard, {}, []));
+        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;
+    };
 };

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

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

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

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

package/dist/module/src/SubPackages/react-dom/component/static.js

@@ -0,0 +1,22 @@
+import { createElement } from "react";
+export const testInterfacer = (testInput) => {
+    return {
+        beforeEach: async () => {
+            return new Promise((resolve, rej) => {
+                resolve(createElement(testInput));
+            });
+        },
+        andWhen: async function (s, whenCB) {
+            return whenCB(s);
+        },
+        butThen: async function (s) {
+            return s;
+        },
+        afterEach: async function () {
+            return {};
+        },
+        afterAll: () => {
+            return;
+        },
+    };
+};

package/dist/module/src/SubPackages/react-dom/component/web.js

@@ -0,0 +1,11 @@
+import Testeranto from "../../../Web.js";
+export default (testInput, testSpecifications, testImplementations, testInterface) => {
+    const t = Testeranto(testInput, testSpecifications, testImplementations, testInterface);
+    document.addEventListener("DOMContentLoaded", function () {
+        const elem = document.getElementById("root");
+        if (elem) {
+            return t;
+        }
+    });
+    return t;
+};

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

@@ -1,10 +1,6 @@
 import { createElement } from "react";
-import { renderToStaticMarkup, renderToStaticNodeStream, } from "react-dom/server";
-import Stream from "stream";
-import Testeranto from "../../../Node.js";
-export { renderToStaticMarkup, renderToStaticNodeStream, Stream };
-export default (testImplementations, testSpecifications, testInput) => {
-    return Testeranto(testInput, testSpecifications, testImplementations, {
+export const testInterfacer = (testInput) => {
+    return {
         beforeAll: async (prototype, artificer) => {
             return await new Promise((resolve, rej) => {
                 resolve(null);
@@ -27,5 +23,5 @@ export default (testImplementations, testSpecifications, testInput) => {
         afterAll: (store, artificer) => {
             return;
         },
-    });
+    };
 };

package/dist/module/src/SubPackages/react-dom/jsx/node.js

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

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

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