testeranto 0.75.0 → 0.79.0

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

@@ -5,9 +5,7 @@ import readline from "readline";
 import { glob } from "glob";
 import esbuildNodeConfiger from "./esbuildConfigs/node.js";
 import esbuildWebConfiger from "./esbuildConfigs/web.js";
-import esbuildFeaturesConfiger from "./esbuildConfigs/features.js";
 import webHtmlFrame from "./web.html.js";
-import reportHtmlFrame from "./report.html.js";
 var mode = process.argv[2] === "-dev" ? "DEV" : "PROD";
 readline.emitKeypressEvents(process.stdin);
 if (process.stdin.isTTY)
@@ -19,15 +17,7 @@ process.stdin.on("keypress", (str, key) => {
         onDone();
     }
 });
-// setInterval(() => {
-//   const memoryUsage = process.memoryUsage();
-//   console.log("Memory usage:", memoryUsage);
-// }, 10000); // Check every 10 seconds
-let featuresDone, nodeDone, webDone = false;
-const onFeaturesDone = () => {
-    featuresDone = true;
-    onDone();
-};
+let nodeDone, webDone = false;
 const onNodeDone = () => {
     nodeDone = true;
     onDone();
@@ -38,12 +28,11 @@ const onWebDone = () => {
 };
 const onDone = () => {
     console.log(JSON.stringify({
-        featuresDone,
         nodeDone,
         webDone,
         mode,
     }, null, 2));
-    if (featuresDone && nodeDone && webDone && mode === "PROD") {
+    if (nodeDone && webDone && mode === "PROD") {
         console.log("Testeranto-EsBuild is all done. Goodbye!");
         process.exit();
     }
@@ -52,9 +41,10 @@ const onDone = () => {
     }
 };
 export class ITProject {
-    constructor(config) {
+    constructor(configs) {
         this.mode = `up`;
-        this.config = config;
+        this.config = configs;
+        fs.writeFileSync(`${this.config.outdir}/testeranto.json`, JSON.stringify(Object.assign(Object.assign({}, this.config), { buildDir: process.cwd() + "/" + this.config.outdir }), null, 2));
         Promise.resolve(Promise.all([...this.getSecondaryEndpointsPoints("web")].map(async (sourceFilePath) => {
             const sourceFileSplit = sourceFilePath.split("/");
             const sourceDir = sourceFileSplit.slice(0, -1);
@@ -63,57 +53,24 @@ export class ITProject {
                 .split(".")
                 .slice(0, -1)
                 .join(".");
-            const htmlFilePath = path.normalize(`${process.cwd()}/${config.outdir}/web/${sourceDir.join("/")}/${sourceFileNameMinusJs}.html`);
+            const htmlFilePath = path.normalize(`${process.cwd()}/${this.config.outdir}/web/${sourceDir.join("/")}/${sourceFileNameMinusJs}.html`);
             const jsfilePath = `./${sourceFileNameMinusJs}.mjs`;
             return fs.promises
                 .mkdir(path.dirname(htmlFilePath), { recursive: true })
                 .then((x) => fs.writeFileSync(htmlFilePath, webHtmlFrame(jsfilePath, htmlFilePath)));
         })));
         const [nodeEntryPoints, webEntryPoints] = getRunnables(this.config.tests);
-        // nodeEntryPoints.forEach((nep) => {
-        //   const f = `${process.cwd()}/${nep}`;
-        //   console.log("nep", f);
-        //   import(f).then((module) => {
-        //     return module.default.then((defaultModule) => {
-        //       console.log("defaultModule", defaultModule);
-        //       // defaultModule
-        //       //   .receiveTestResourceConfig(argz)
-        //       //   .then((x) => {
-        //       //     console.log("then", x);
-        //       //     return x;
-        //       //   })
-        //       //   .catch((e) => {
-        //       //     console.log("catch", e);
-        //       //   });
-        //     });
-        //   });
-        // });
-        glob(`./${config.outdir}/chunk-*.mjs`, { ignore: "node_modules/**" }).then((chunks) => {
+        console.log(`this.getSecondaryEndpointsPoints("web")`, this.getSecondaryEndpointsPoints("web"));
+        glob(`./${this.config.outdir}/chunk-*.mjs`, {
+            ignore: "node_modules/**",
+        }).then((chunks) => {
             chunks.forEach((chunk) => {
                 fs.unlinkSync(chunk);
             });
         });
-        fs.copyFileSync("./node_modules/testeranto/dist/prebuild/Report.js", "./docs/Report.js");
-        fs.copyFileSync("./node_modules/testeranto/dist/prebuild/Report.css", "./docs/Report.css");
-        fs.writeFileSync(`${config.outdir}/report.html`, reportHtmlFrame());
         Promise.all([
-            fs.promises.writeFile(`${config.outdir}/testeranto.json`, JSON.stringify(Object.assign(Object.assign({}, config), { buildDir: process.cwd() + "/" + config.outdir }), null, 2)),
-            esbuild
-                .context(esbuildFeaturesConfiger(config))
-                .then(async (featuresContext) => {
-                if (mode == "DEV") {
-                    await featuresContext.watch();
-                    onFeaturesDone();
-                }
-                else {
-                    featuresContext.rebuild().then((v) => {
-                        onFeaturesDone();
-                    });
-                }
-                return featuresContext;
-            }),
             esbuild
-                .context(esbuildNodeConfiger(config, nodeEntryPoints))
+                .context(esbuildNodeConfiger(this.config, nodeEntryPoints))
                 .then(async (nodeContext) => {
                 if (mode == "DEV") {
                     await nodeContext.watch().then((v) => {
@@ -128,7 +85,7 @@ export class ITProject {
                 return nodeContext;
             }),
             esbuild
-                .context(esbuildWebConfiger(config, webEntryPoints))
+                .context(esbuildWebConfiger(this.config, webEntryPoints))
                 .then(async (webContext) => {
                 if (mode == "DEV") {
                     await webContext.watch().then((v) => {
@@ -147,11 +104,12 @@ export class ITProject {
     getSecondaryEndpointsPoints(runtime) {
         const meta = (ts, st) => {
             ts.forEach((t) => {
+                console.log("getSecondaryEndpointsPoints", t);
                 if (t[1] === runtime) {
                     st.add(t[0]);
                 }
-                if (Array.isArray(t[2])) {
-                    meta(t[2], st);
+                if (Array.isArray(t[3])) {
+                    meta(t[3], st);
                 }
             });
             return st;

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

@@ -1,8 +1,8 @@
 import readline from "readline";
 import fs from "fs";
-import path from "path";
-import { jsonc } from "jsonc";
+import watch from "recursive-watch";
 import { PM_Main } from "./PM/main.js";
+import { destinationOfRuntime } from "./utils.js";
 var mode = process.argv[2] === "-dev" ? "DEV" : "PROD";
 const node2web = {};
 const web2node = {};
@@ -10,31 +10,39 @@ const childProcesses = {};
 readline.emitKeypressEvents(process.stdin);
 if (process.stdin.isTTY)
     process.stdin.setRawMode(true);
+// console.log("hello Puppeteer", process.env);
 console.log("\n Puppeteer is running. Press 'q' to quit\n");
 process.stdin.on("keypress", (str, key) => {
     if (key.name === "q") {
         process.exit();
     }
 });
-const main = async () => {
-    const configs = jsonc.parse((await fs.readFileSync("./docs/testeranto.json")).toString());
-    const pm = new PM_Main(configs);
+export default async (partialConfig) => {
+    const config = Object.assign(Object.assign({}, partialConfig), { buildDir: process.cwd() + "/" + partialConfig.outdir });
+    fs.writeFileSync(`${config.outdir}/testeranto.json`, JSON.stringify(Object.assign(Object.assign({}, config), { buildDir: process.cwd() + "/" + config.outdir }), null, 2));
+    const pm = new PM_Main(config);
     await pm.startPuppeteer({
+        // timeout: 1,
         waitForInitialPage: false,
-        executablePath: "/opt/homebrew/bin/chromium",
+        executablePath: 
+        // process.env.CHROMIUM_PATH || "/opt/homebrew/bin/chromium",
+        "/opt/homebrew/bin/chromium",
         headless: true,
         dumpio: true,
+        // timeout: 0,
         args: [
+            // "--auto-open-devtools-for-tabs",
+            "--disable-features=IsolateOrigins,site-per-process",
+            "--disable-site-isolation-trials",
+            "--allow-insecure-localhost",
             "--allow-file-access-from-files",
             "--allow-running-insecure-content",
-            "--auto-open-devtools-for-tabs",
             "--disable-dev-shm-usage",
             "--disable-extensions",
             "--disable-gpu",
             "--disable-setuid-sandbox",
             "--disable-site-isolation-trials",
             "--disable-web-security",
-            "--disable-web-security",
             "--no-first-run",
             "--no-sandbox",
             "--no-startup-window",
@@ -53,30 +61,21 @@ const main = async () => {
             // "--start-maximized",
         ],
     }, ".");
-    const destinationOfRuntime = (f, r) => {
-        return path
-            .normalize(`${configs.buildDir}/${r}/${f}`)
-            .split(".")
-            .slice(0, -1)
-            .join(".");
-    };
-    configs.tests.forEach(([test, runtime, secondaryArtifacts]) => {
+    config.tests.forEach(([test, runtime, tr, sidecars]) => {
         if (runtime === "node") {
-            pm.launchNode(test, destinationOfRuntime(test, "node"));
+            pm.launchNode(test, destinationOfRuntime(test, "node", config));
         }
         else if (runtime === "web") {
-            pm.launchWeb(test, destinationOfRuntime(test, "web"));
+            pm.launchWeb(test, destinationOfRuntime(test, "web", config), sidecars);
         }
         else {
             console.error("runtime makes no sense", runtime);
         }
     });
-    console.log("ready and watching for changes...", configs.buildDir);
-    fs.watch(configs.buildDir, {
-        recursive: true,
-    }, (eventType, changedFile) => {
+    console.log("ready and watching for changes...", config.buildDir);
+    watch(config.buildDir, (eventType, changedFile) => {
         if (changedFile) {
-            configs.tests.forEach(([test, runtime, secondaryArtifacts]) => {
+            config.tests.forEach(([test, runtime, tr, sidecars]) => {
                 if (eventType === "change" || eventType === "rename") {
                     if (changedFile ===
                         test
@@ -85,7 +84,7 @@ const main = async () => {
                             .slice(0, -1)
                             .concat("mjs")
                             .join(".")) {
-                        pm.launchNode(test, destinationOfRuntime(test, "node"));
+                        pm.launchNode(test, destinationOfRuntime(test, "node", config));
                     }
                     if (changedFile ===
                         test
@@ -94,11 +93,51 @@ const main = async () => {
                             .slice(0, -1)
                             .concat("mjs")
                             .join(".")) {
-                        pm.launchWeb(test, destinationOfRuntime(test, "web"));
+                        pm.launchWeb(test, destinationOfRuntime(test, "web", config), sidecars);
                     }
                 }
             });
         }
     });
+    // does not work on linux
+    // fs.watch(
+    //   config.buildDir,
+    //   {
+    //     recursive: true,
+    //   },
+    //   (eventType, changedFile) => {
+    //     if (changedFile) {
+    //       config.tests.forEach(([test, runtime, tr, sidecars]) => {
+    //         if (eventType === "change" || eventType === "rename") {
+    //           if (
+    //             changedFile ===
+    //             test
+    //               .replace("./", "node/")
+    //               .split(".")
+    //               .slice(0, -1)
+    //               .concat("mjs")
+    //               .join(".")
+    //           ) {
+    //             pm.launchNode(test, destinationOfRuntime(test, "node", config));
+    //           }
+    //           if (
+    //             changedFile ===
+    //             test
+    //               .replace("./", "web/")
+    //               .split(".")
+    //               .slice(0, -1)
+    //               .concat("mjs")
+    //               .join(".")
+    //           ) {
+    //             pm.launchWeb(
+    //               test,
+    //               destinationOfRuntime(test, "web", config),
+    //               sidecars
+    //             );
+    //           }
+    //         }
+    //       });
+    //     }
+    //   }
+    // );
 };
-main();

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

@@ -1,7 +1,7 @@
 import { createElement } from "react";
 import ReactDom from "react-dom/client";
 import Testeranto from "../../../Web.js";
-export default (testInput, testSpecifications, testImplementations) => {
+export default (testInput, testSpecifications, testImplementations, testInterface) => {
     class TesterantoComponent extends testInput {
         constructor(props) {
             super(props);
@@ -14,7 +14,6 @@ export default (testInput, testSpecifications, testImplementations) => {
     }
     const t = Testeranto(testInput, testSpecifications, testImplementations, {
         beforeAll: async (initialProps, artificer) => {
-            console.log("mark5", initialProps);
             return await new Promise((resolve, rej) => {
                 const htmlElement = document.getElementById("root");
                 if (htmlElement) {
@@ -66,29 +65,10 @@ export default (testInput, testSpecifications, testImplementations) => {
         butThen: async function (s, thenCB) {
             return thenCB(s);
         },
-        afterEach: async function (store, ndx, artificer, utils) {
-            console.log("afterEach", store);
-            utils.writeFileSync("aftereachlog", store.toString());
-            const page = (await utils.browser.pages()).filter((x) => {
-                const parsedUrl = new URL(x.url());
-                parsedUrl.search = "";
-                const strippedUrl = parsedUrl.toString();
-                return (strippedUrl ===
-                    "file:///Users/adam/Code/kokomoBay/docs/web/src/ClassicalComponent/react-dom/client.web.test.html");
-                // return true;
-            })[0];
-            const x = await page.screenshot({
-                path: "afterEachLog.jpg",
-            });
-            console.log("x", x);
-            // debugger;
-            // const div_root = document.getElementById("root");
-            // store.domRoot && store.domRoot.unmount(); //React 18
-            //  store.remove();
-            // store.htmlElement.remove();
-            // store.htmlElement = document.createElement("root");
-            return store;
-        },
+        afterEach: (testInterface === null || testInterface === void 0 ? void 0 : testInterface.afterEach) ||
+            async function (store, ndx, artificer, utils) {
+                return store;
+            },
         afterAll: async (store, artificer, utils) => {
             // setTimeout(() => {
             //   console.log("This will run after 1 second");

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

@@ -0,0 +1,89 @@
+import React, { useEffect, useRef } from "react";
+import { createElement } from "react";
+import ReactDom from "react-dom/client";
+import Testeranto from "../../../Web.js";
+const TesterantoComponent = ({ done, innerComp, }) => {
+    const myContainer = useRef(null);
+    useEffect(() => {
+        console.log("useEffect called!", myContainer.current);
+        done(myContainer.current);
+    }, []);
+    return React.createElement("div", { ref: myContainer }, innerComp());
+};
+export default (testImplementations, testSpecifications, testInput) => {
+    const t = Testeranto(testInput, testSpecifications, testImplementations, {
+        beforeAll: async (reactElement, itr) => {
+            return await new Promise((resolve, rej) => {
+                const htmlElement = document.getElementById("root");
+                if (htmlElement) {
+                    const domRoot = ReactDom.createRoot(htmlElement);
+                    domRoot.render(createElement(TesterantoComponent, {
+                        // ...initialProps,
+                        innerComp: reactElement,
+                        done: (reactElement) => {
+                            resolve({
+                                htmlElement,
+                                reactElement,
+                                domRoot,
+                            });
+                        },
+                    }, []));
+                    // resolve({ htmlElement });
+                }
+            });
+        },
+        beforeEach: async (subject, initializer, artificer, testResource, pm) => {
+            return new Promise((resolve, rej) => {
+                resolve(subject);
+                // const tc = TesterantoComponent({
+                //   innerComp: () =>
+                //     testInput({
+                //       port: 3003,
+                //       address: "some-address",
+                //       secretKey: "someSecretKey",
+                //       abi: "foo",
+                //     }),
+                //   done: (reactElement: any) => {
+                //     console.log("mark9");
+                //     resolve(reactElement);
+                //     // process.nextTick(() => {
+                //     //   resolve(reactElement);
+                //     // });
+                //   },
+                // });
+                // console.log("mark9", tc);
+                // createPortal(tc, subject.domRoot);
+            });
+        },
+        andWhen: function (s, whenCB, tr, utils) {
+            return new Promise((resolve, rej) => {
+                console.log("mark9", s, whenCB);
+                resolve(whenCB(s, utils));
+                // process.nextTick(() => {
+                //   resolve(whenCB()(s));
+                // });
+            });
+        },
+        butThen: async function (s, thenCB) {
+            return new Promise((resolve, rej) => {
+                resolve(thenCB(s));
+            });
+        },
+        afterEach: async function (store, ndx, artificer) {
+            return new Promise((resolve, rej) => {
+                resolve({});
+            });
+        },
+        afterAll: (store, artificer) => {
+            return new Promise((resolve, rej) => {
+                resolve({});
+            });
+        },
+    });
+    document.addEventListener("DOMContentLoaded", function () {
+        const rootElement = document.getElementById("root");
+        if (rootElement) {
+        }
+    });
+    return t;
+};

package/dist/module/{SubPackages/react-test-renderer/component/index.js → src/SubPackages/react-test-renderer/component/interface.js}

@@ -1,25 +1,5 @@
 import React from "react";
 import renderer, { act } from "react-test-renderer";
-// export const testInterface = {
-//   beforeEach: function (CComponent, props): Promise<renderer.ReactTestRenderer> {
-//     return new Promise((res, rej) => {
-//       let component: renderer.ReactTestRenderer;
-//       act(() => {
-//         component = renderer.create(
-//           CComponent(props)
-//         );
-//         res(component);
-//       });
-//     });
-//   },
-//   andWhen: async function (
-//     renderer: renderer.ReactTestRenderer,
-//     whenCB: () => (any) => any
-//   ): Promise<renderer.ReactTestRenderer> {
-//     await act(() => whenCB()(renderer));
-//     return renderer
-//   }
-// }
 export const testInterface = {
     beforeEach: function (CComponent, propsAndChildren) {
         function Link(props) {

package/dist/module/{SubPackages → src/SubPackages}/react-test-renderer/component/node.js

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

package/dist/module/{SubPackages → src/SubPackages}/react-test-renderer/component/web.js

@@ -1,3 +1,3 @@
 import Testeranto from "../../../Web.js";
-import { testInterface } from "./index.js";
+import { testInterface } from "./interface";
 export default (testImplementations, testSpecifications, testInput) => Testeranto(testInput, testSpecifications, testImplementations, testInterface);

package/dist/module/{esbuildConfigs → src/esbuildConfigs}/index.js

@@ -1,5 +1,6 @@
 export default (config) => {
     return {
+        // packages: "external",
         target: "esnext",
         format: "esm",
         splitting: true,

package/dist/module/src/esbuildConfigs/inputFilesPlugin.js

@@ -0,0 +1,47 @@
+import fs from "fs";
+import path from "path";
+export default (platform, entryPoints) => {
+    console.log("mark3", platform);
+    return {
+        name: "metafileWriter",
+        setup(build) {
+            build.onEnd((result) => {
+                if (result.errors.length === 0) {
+                    entryPoints.forEach((entryPoint) => {
+                        console.log("mark1", entryPoint);
+                        const filePath = path.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `inputFiles.json`);
+                        const dirName = path.dirname(filePath);
+                        if (!fs.existsSync(dirName)) {
+                            fs.mkdirSync(dirName, { recursive: true });
+                        }
+                        const jsonContent = JSON.stringify(Object.keys(Object.keys(result.metafile.outputs)
+                            .filter((s) => {
+                            if (!result.metafile.outputs[s].entryPoint) {
+                                return false;
+                            }
+                            return (path.resolve(result.metafile.outputs[s].entryPoint) ===
+                                path.resolve(entryPoint));
+                        })
+                            .reduce((mm, el) => {
+                            mm.push(result.metafile.outputs[el].inputs);
+                            return mm;
+                        }, [])[0])
+                            .filter((f) => {
+                            const regex = /^src\/.*/g;
+                            const matches = f.match(regex);
+                            const passes = (matches === null || matches === void 0 ? void 0 : matches.length) === 1;
+                            return passes;
+                        })
+                            .filter((f) => {
+                            const regex = /.*\.test\..*/g;
+                            const matches = f.match(regex);
+                            const passes = (matches === null || matches === void 0 ? void 0 : matches.length) === 1;
+                            return !passes;
+                        }));
+                        fs.writeFileSync(filePath, jsonContent);
+                    });
+                }
+            });
+        },
+    };
+};

package/dist/module/{esbuildConfigs → src/esbuildConfigs}/node.js

@@ -1,6 +1,9 @@
 import baseEsBuildConfig from "./index.js";
+import inputFilesPlugin from "./inputFilesPlugin.js";
 export default (config, entryPoints) => {
-    return Object.assign(Object.assign({}, baseEsBuildConfig(config)), { splitting: true, outdir: config.outdir + "/node", inject: [`./node_modules/testeranto/dist/cjs-shim.js`], supported: {
+    return Object.assign(Object.assign({}, baseEsBuildConfig(config)), { splitting: true, outdir: config.outdir + "/node", 
+        // inject: [`./node_modules/testeranto/dist/cjs-shim.js`],
+        metafile: true, supported: {
             "dynamic-import": true,
         }, define: {
             "process.env.FLUENTFFMPEG_COV": "0",
@@ -15,6 +18,7 @@ export default (config, entryPoints) => {
             ...config.externals,
         ], entryPoints: [...entryPoints], plugins: [
             ...(config.nodePlugins || []),
+            inputFilesPlugin("node", entryPoints),
             {
                 name: "rebuild-notify",
                 setup(build) {

package/dist/module/src/esbuildConfigs/report.js

@@ -0,0 +1,14 @@
+"use strict";
+// import { BuildOptions } from "esbuild";
+// import { IBaseConfig } from "../lib/types";
+// export default (config: IBaseConfig): BuildOptions => {
+//   return {
+//     bundle: true,
+//     entryPoints: ["./node_modules/testeranto/dist/module/report.js"],
+//     minify: config.minify === true,
+//     outbase: config.outbase,
+//     write: true,
+//     outfile: `${config.outdir}/report.js`,
+//     external: ["tests.json", "features.test.js"],
+//   };
+// };

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

@@ -1,5 +1,6 @@
 import path from "path";
 import baseEsBuildConfig from "./index.js";
+import inputFilesPlugin from "./inputFilesPlugin.js";
 export default (config, entryPoints) => {
     return Object.assign(Object.assign({}, baseEsBuildConfig(config)), { 
         // inject: ["./node_modules/testeranto/dist/cjs-shim.js"],
@@ -9,7 +10,7 @@ export default (config, entryPoints) => {
         // splitting: true,
         outdir: config.outdir + "/web", alias: {
             react: path.resolve("./node_modules/react"),
-        }, external: [
+        }, metafile: true, external: [
             "testeranto.json",
             "features.test.ts",
             // "url",
@@ -33,6 +34,7 @@ export default (config, entryPoints) => {
             "dns",
         ], platform: "browser", entryPoints: [...entryPoints], plugins: [
             ...(config.webPlugins || []),
+            inputFilesPlugin("web", entryPoints),
             {
                 name: "rebuild-notify",
                 setup(build) {