testeranto 0.85.0 → 0.94.0

package/dist/module/src/Init.js

@@ -1,5 +1,35 @@
 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}/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/Node.js

@@ -3,14 +3,16 @@ import { defaultTestResourceRequirement, } from "./lib/index.js";
 import { PM_Node } from "./PM/node.js";
 export class NodeTesteranto extends Testeranto {
     constructor(input, testSpecification, testImplementation, testResourceRequirement, testInterface) {
-        super(input, testSpecification, testImplementation, testResourceRequirement, testInterface);
+        super(input, testSpecification, testImplementation, testResourceRequirement, testInterface, () => {
+            // no-op
+        });
     }
     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;
+        // pm.customclose();
+        return { features, failed };
     }
 }
 export default async (input, testSpecification, testImplementation, testInterface, testResourceRequirement = defaultTestResourceRequirement) => {

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

@@ -4,8 +4,8 @@ import puppeteer from "puppeteer-core";
 import crypto from "crypto";
 import { PM } from "./index.js";
 import { destinationOfRuntime } from "../utils.js";
-const fPaths = [];
 const fileStreams3 = [];
+const fPaths = [];
 const files = {};
 const screenshots = {};
 export class PM_Main extends PM {
@@ -81,9 +81,12 @@ export class PM_Main extends PM {
                 process.exit(-1);
             }
             const builtfile = dest + ".mjs";
-            await Promise.all(testConfig[3].map((sidecar) => {
+            const webSideCares = [];
+            await Promise.all(testConfig[3].map(async (sidecar) => {
                 if (sidecar[1] === "web") {
-                    return this.launchWebSideCar(sidecar[0], destinationOfRuntime(sidecar[0], "web", this.configs), sidecar);
+                    const s = await this.launchWebSideCar(sidecar[0], destinationOfRuntime(sidecar[0], "web", this.configs), sidecar);
+                    webSideCares.push(s);
+                    return s;
                 }
                 if (sidecar[1] === "node") {
                     return this.launchNodeSideCar(sidecar[0], destinationOfRuntime(sidecar[0], "node", this.configs), sidecar);
@@ -93,13 +96,15 @@ export class PM_Main extends PM {
                 return module.default.then((defaultModule) => {
                     defaultModule
                         .receiveTestResourceConfig(argz)
-                        .then(async (features) => {
+                        .then(async ({ features, failed }) => {
                         this.receiveFeatures(features, destFolder);
+                        console.log(`${src} completed with ${failed} errors`);
                     })
                         .catch((e) => {
-                        console.log("catch", e);
+                        console.log(`${src} errored with`, e);
                     })
                         .finally(() => {
+                        webSideCares.forEach((webSideCar) => webSideCar.close());
                         this.deregister(src);
                     });
                 });
@@ -115,17 +120,12 @@ export class PM_Main extends PM {
             const d = dest + ".mjs";
             console.log("launchWebSideCar", src, dest, d);
             const destFolder = dest.replace(".mjs", "");
-            const webArgz = JSON.stringify({
-                name: dest,
-                ports: [].toString(),
-                fs: destFolder,
-                browserWSEndpoint: this.browser.wsEndpoint(),
-            });
-            // const evaluation = `
-            // console.log("importing ${dest}.mjs");
-            // import('${dest}.mjs').then(async (x) => {
-            //   console.log("imported", x.default);
-            // })`;
+            // const webArgz = JSON.stringify({
+            //   name: dest,
+            //   ports: [].toString(),
+            //   fs: destFolder,
+            //   browserWSEndpoint: this.browser.wsEndpoint(),
+            // });
             const fileStreams2 = [];
             const doneFileStream2 = [];
             return new Promise((res, rej) => {
@@ -184,9 +184,9 @@ export class PM_Main extends PM {
                     });
                     page.exposeFunction("createWriteStream", (fp, testName) => {
                         const f = fs.createWriteStream(fp);
-                        if (!files[testName]) {
-                            files[testName] = new Set();
-                        }
+                        // if (!files[testName]) {
+                        //   files[testName] = new Set();
+                        // }
                         files[testName].add(fp);
                         const p = new Promise((res, rej) => {
                             res(fp);
@@ -204,14 +204,17 @@ export class PM_Main extends PM {
                     page.exposeFunction("end", async (uid) => {
                         return fileStreams2[uid].end();
                     });
-                    page.exposeFunction("customclose", (p, testName) => {
-                        fs.writeFileSync(p + "/manifest.json", JSON.stringify(Array.from(files[testName])));
-                        delete files[testName];
-                        Promise.all(screenshots[testName] || []).then(() => {
-                            delete screenshots[testName];
-                            // page.close();
-                        });
-                    });
+                    // page.exposeFunction("customclose", (p: string, testName: string) => {
+                    //   fs.writeFileSync(
+                    //     p + "/manifest.json",
+                    //     JSON.stringify(Array.from(files[testName]))
+                    //   );
+                    //   delete files[testName];
+                    //   Promise.all(screenshots[testName] || []).then(() => {
+                    //     delete screenshots[testName];
+                    //     // page.close();
+                    //   });
+                    // });
                     return page;
                 })
                     .then(async (page) => {
@@ -318,6 +321,8 @@ export class PM_Main extends PM {
     })`;
             const fileStreams2 = [];
             const doneFileStream2 = [];
+            const stdoutStream = fs.createWriteStream(`${dest}/stdout.log`);
+            const stderrStream = fs.createWriteStream(`${dest}/stderr.log`);
             this.browser
                 .newPage()
                 .then((page) => {
@@ -365,20 +370,21 @@ export class PM_Main extends PM {
                     // page.evaluate(`window["screenshot done"]`);
                 });
                 page.exposeFunction("writeFileSync", (fp, contents, testName) => {
-                    const dir = path.dirname(fp);
-                    fs.mkdirSync(dir, {
-                        recursive: true,
-                    });
-                    const p = new Promise(async (res, rej) => {
-                        fs.writeFileSync(fp, contents);
-                        res(fp);
-                    });
-                    doneFileStream2.push(p);
-                    if (!files[testName]) {
-                        files[testName] = new Set();
-                    }
-                    files[testName].add(fp);
-                    return p;
+                    return globalThis["writeFileSync"](fp, contents, testName);
+                    // const dir = path.dirname(fp);
+                    // fs.mkdirSync(dir, {
+                    //   recursive: true,
+                    // });
+                    // const p = new Promise<string>(async (res, rej) => {
+                    //   fs.writeFileSync(fp, contents);
+                    //   res(fp);
+                    // });
+                    // doneFileStream2.push(p);
+                    // if (!files[testName]) {
+                    //   files[testName] = new Set();
+                    // }
+                    // files[testName].add(fp);
+                    // return p;
                 });
                 page.exposeFunction("existsSync", (fp, contents) => {
                     return fs.existsSync(fp);
@@ -413,36 +419,37 @@ export class PM_Main extends PM {
                 page.exposeFunction("end", async (uid) => {
                     return fileStreams2[uid].end();
                 });
-                page.exposeFunction("customclose", (p, testName) => {
-                    // console.log("closing", p);
-                    fs.writeFileSync(p + "/manifest.json", JSON.stringify(Array.from(files[testName])));
-                    delete files[testName];
-                    // console.log("screenshots[testName]", screenshots[testName]);
-                    Promise.all(screenshots[testName] || []).then(() => {
-                        delete screenshots[testName];
-                        // page.close();
-                        // console.log("\t GOODBYE");
-                        // whyIsNodeRunning();
-                    });
-                    // globalThis["writeFileSync"](
-                    //   p + "/manifest.json",
-                    //   // files.entries()
-                    //   JSON.stringify(Array.from(files[testName]))
-                    // );
-                    // console.log("closing doneFileStream2", doneFileStream2);
-                    // console.log("closing doneFileStream2", doneFileStream2);
-                    // Promise.all([...doneFileStream2, ...screenshots2]).then(() => {
-                    //   page.close();
-                    // });
-                    // Promise.all(screenshots).then(() => {
-                    //   page.close();
-                    // });
-                    // setTimeout(() => {
-                    //   console.log("Delayed for 1 second.");
-                    //   page.close();
-                    // }, 5000);
-                    // return page.close();
-                });
+                // page.exposeFunction("customclose", (p: string, testName: string) => {
+                //   // console.log("closing", p);
+                //   console.log("\t GOODBYE customclose");
+                //   fs.writeFileSync(
+                //     p + "/manifest.json",
+                //     JSON.stringify(Array.from(files[testName]))
+                //   );
+                //   delete files[testName];
+                //   // console.log("screenshots[testName]", screenshots[testName]);
+                //   Promise.all(screenshots[testName] || []).then(() => {
+                //     delete screenshots[testName];
+                //   });
+                //   // globalThis["writeFileSync"](
+                //   //   p + "/manifest.json",
+                //   //   // files.entries()
+                //   //   JSON.stringify(Array.from(files[testName]))
+                //   // );
+                //   // console.log("closing doneFileStream2", doneFileStream2);
+                //   // console.log("closing doneFileStream2", doneFileStream2);
+                //   // Promise.all([...doneFileStream2, ...screenshots2]).then(() => {
+                //   //   page.close();
+                //   // });
+                //   // Promise.all(screenshots).then(() => {
+                //   //   page.close();
+                //   // });
+                //   // setTimeout(() => {
+                //   //   console.log("Delayed for 1 second.");
+                //   //   page.close();
+                //   // }, 5000);
+                //   // return page.close();
+                // });
                 page.exposeFunction("page", () => {
                     return page.mainFrame()._id;
                 });
@@ -474,29 +481,63 @@ export class PM_Main extends PM {
                 return page;
             })
                 .then(async (page) => {
-                // page.on("console", (log) =>
-                //   console.debug(`Log from client: [${log.text()}] `)
-                // );
+                const close = () => {
+                    if (!files[t]) {
+                        files[t] = new Set();
+                    }
+                    // files[t].add(filepath);
+                    fs.writeFileSync(dest + "/manifest.json", JSON.stringify(Array.from(files[t])));
+                    delete files[t];
+                    Promise.all(screenshots[t] || []).then(() => {
+                        delete screenshots[t];
+                        page.close();
+                        this.deregister(t);
+                        stderrStream.close();
+                        stdoutStream.close();
+                    });
+                };
+                page.on("pageerror", (err) => {
+                    console.debug(`Error from ${t}: [${err.name}] `);
+                    stderrStream.write(err.name);
+                    if (err.cause) {
+                        console.debug(`Error from ${t} cause: [${err.cause}] `);
+                        stderrStream.write(err.cause);
+                    }
+                    if (err.stack) {
+                        console.debug(`Error from stack ${t}: [${err.stack}] `);
+                        stderrStream.write(err.stack);
+                    }
+                    console.debug(`Error from message ${t}: [${err.message}] `);
+                    stderrStream.write(err.message);
+                    // close();
+                });
+                page.on("console", (log) => {
+                    // console.debug(`Log from ${t}: [${log.text()}] `);
+                    // console.debug(`Log from ${t}: [${JSON.stringify(log.location())}] `);
+                    // console.debug(
+                    //   `Log from ${t}: [${JSON.stringify(log.stackTrace())}] `
+                    // );
+                    stdoutStream.write(log.text());
+                    stdoutStream.write(JSON.stringify(log.location()));
+                    stdoutStream.write(JSON.stringify(log.stackTrace()));
+                });
                 await page.goto(`file://${`${dest}.html`}`, {});
                 await page
                     .evaluate(evaluation)
-                    .then(async (features) => {
+                    .then(async ({ failed, features }) => {
                     this.receiveFeatures(features, destFolder);
+                    console.log(`${t} completed with ${failed} errors`);
                 })
                     .catch((e) => {
-                    console.log("evaluation failed.", dest);
-                    console.log(e);
+                    console.log(`${t} errored with`, e);
                 })
                     .finally(() => {
-                    console.log("evaluation complete.", dest);
-                    // page.close();
-                    this.deregister(t);
+                    close();
                 });
                 return page;
             });
         };
         this.receiveFeatures = (features, destFolder) => {
-            console.log("this.receiveFeatures", features);
             features
                 .reduce(async (mm, featureStringKey) => {
                 const accum = await mm;
@@ -563,12 +604,14 @@ export class PM_Main extends PM {
             return false;
         };
         globalThis["writeFileSync"] = (filepath, contents, testName) => {
-            // console.log("globalThis-writeFileSync", filepath);
+            // console.log(testName, "writeFileSync", filepath, testName);
             // Create directories if they don't exist
-            const dir = path.dirname(filepath.split("/").slice(0, -1).join("/"));
+            const dir = path.dirname(filepath);
+            // console.log(testName, "mkdirSync", dir);
             fs.mkdirSync(dir, {
                 recursive: true,
             });
+            // console.log(testName, "mkdirSync2");
             if (!files[testName]) {
                 files[testName] = new Set();
             }
@@ -609,13 +652,16 @@ export class PM_Main extends PM {
             await sPromise;
             return sPromise;
         };
-        globalThis["customclose"] = (p, testName) => {
-            if (!files[testName]) {
-                files[testName] = new Set();
-            }
-            fs.writeFileSync(p + "/manifest.json", JSON.stringify(Array.from(files[testName])));
-            delete files[testName];
-        };
+        // globalThis["customclose"] = (p: string, testName: string) => {
+        //   if (!files[testName]) {
+        //     files[testName] = new Set();
+        //   }
+        //   fs.writeFileSync(
+        //     p + "/manifest.json",
+        //     JSON.stringify(Array.from(files[testName]))
+        //   );
+        //   delete files[testName];
+        // };
     }
     $(selector) {
         throw new Error("Method not implemented.");

package/dist/module/src/Project.js

@@ -1,3 +1,4 @@
+import { spawn } from "child_process";
 import esbuild from "esbuild";
 import fs from "fs";
 import path from "path";
@@ -9,6 +10,86 @@ import webHtmlFrame from "./web.html.js";
 readline.emitKeypressEvents(process.stdin);
 if (process.stdin.isTTY)
     process.stdin.setRawMode(true);
+const logContent = [];
+function parseTsErrors() {
+    try {
+        // const logContent = fs.readFileSync(logPath, "utf-8").split("\n");
+        const regex = /(^src(.*?))\(\d*,\d*\): error/gm;
+        const brokenFilesToLines = {};
+        for (let i = 0; i < logContent.length - 1; i++) {
+            let m;
+            while ((m = regex.exec(logContent[i])) !== null) {
+                // This is necessary to avoid infinite loops with zero-width matches
+                if (m.index === regex.lastIndex) {
+                    regex.lastIndex++;
+                }
+                if (!brokenFilesToLines[m[1]]) {
+                    brokenFilesToLines[m[1]] = new Set();
+                }
+                brokenFilesToLines[m[1]].add(i);
+            }
+        }
+        const final = Object.keys(brokenFilesToLines).reduce((mm, lm, ndx) => {
+            mm[lm] = Array.from(brokenFilesToLines[lm]).map((l, ndx3) => {
+                const a = Array.from(brokenFilesToLines[lm]);
+                return Object.keys(a).reduce((mm2, lm2, ndx2) => {
+                    const acc = [];
+                    let j = a[lm2] + 1;
+                    let working = true;
+                    while (j < logContent.length - 1 && working) {
+                        if (!logContent[j].match(regex) &&
+                            working &&
+                            !logContent[j].match(/^..\/(.*?)\(\d*,\d*\)/)) {
+                            acc.push(logContent[j]);
+                        }
+                        else {
+                            working = false;
+                        }
+                        j++;
+                    }
+                    mm2[lm] = [logContent[l], ...acc];
+                    return mm2;
+                }, {})[lm];
+            });
+            return mm;
+        }, {});
+        Object.keys(final).forEach((k) => {
+            fs.mkdirSync(`./docs/types/${k.split("/").slice(0, -1).join("/")}`, {
+                recursive: true,
+            });
+            fs.writeFileSync(`./docs/types/${k}.type_errors.txt`, final[k].flat().flat().join("\r\n"));
+        });
+    }
+    catch (error) {
+        console.error("Error reading or parsing the log file:", error);
+        process.exit(1);
+    }
+}
+const compile = () => {
+    return new Promise((resolve, reject) => {
+        const tsc = spawn("tsc", ["-noEmit"]);
+        tsc.stdout.on("data", (data) => {
+            // console.log(`tsc stdout: ${data}`);
+            const lines = data.toString().split("\n");
+            logContent.push(...lines);
+        });
+        tsc.stderr.on("data", (data) => {
+            console.error(`stderr: ${data}`);
+            process.exit(-1);
+        });
+        tsc.on("close", (code) => {
+            parseTsErrors();
+            console.log("tsc done");
+            resolve(`tsc process exited with code ${code}`);
+            // if (code !== 0) {
+            //   resolve(`tsc process exited with code ${code}`);
+            //   // reject(`tsc process exited with code ${code}`);
+            // } else {
+            //   resolve({});
+            // }
+        });
+    });
+};
 export class ITProject {
     constructor(configs) {
         this.nodeDone = false;
@@ -75,6 +156,7 @@ export class ITProject {
             });
         });
         Promise.all([
+            compile(),
             esbuild
                 .context(esbuildNodeConfiger(this.config, nodeEntryPoints))
                 .then(async (nodeContext) => {

package/dist/module/src/Puppeteer.js

@@ -55,10 +55,8 @@ export default async (partialConfig) => {
     process.stdin.on("keypress", (str, key) => {
         if (key.name === "q") {
             pm.shutDown();
-            // process.exit();
         }
         if (key.name === "x") {
-            // pm.shutDown();
             process.exit(-1);
         }
     });

package/dist/module/src/SubPackages/puppeteer.js

@@ -1,7 +1,7 @@
 import React from "react";
 import Testeranto from "../Node.js";
 export default (testInput, testSpecifications, testImplementations, testInterface) => {
-    return Testeranto(testInput, testSpecifications, testImplementations, Object.assign({ beforeAll(x) {
+    return Testeranto(testInput, testSpecifications, testImplementations, Object.assign({ beforeAll: (x) => {
             // process.parentPort.postMessage(
             //   `/docs/web/src/ClassicalComponent/test.html`
             // );

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

@@ -6,14 +6,22 @@ export const testInterface = {
     //   //   resolve(x());
     //   // });
     // },
-    beforeEach: async (subject, initializer, artificer) => {
+    // beforeEach: async (subject, initializer, artificer): Promise<IStore> => {
+    //   return new Promise((resolve, rej) => {
+    //     resolve(React.createElement(subject));
+    //   });
+    // },
+    andWhen: async (s, whenCB) => {
+        await whenCB(s());
         return new Promise((resolve, rej) => {
-            const x = React.createElement(subject);
-            console.log("react-element", x);
-            resolve(x);
+            resolve(React.createElement(s));
         });
+        // return whenCB(s);
     },
-    andWhen: function (s, whenCB) {
-        return whenCB(s);
+    butThen: async (subject, thenCB) => {
+        await thenCB(subject());
+        return new Promise((resolve, rej) => {
+            resolve(React.createElement(subject));
+        });
     },
 };

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

@@ -1,5 +1,10 @@
 import Testeranto from "../../../Node.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));
+export default (testImplementations, testSpecifications, testInput, testInterface = baseInterface) => {
+    return Testeranto(testInput, testSpecifications, testImplementations, testInterface
+    // {
+    //   ...baseInterface,
+    //   ...testInterface,
+    // }
+    );
 };

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

@@ -13,52 +13,26 @@ export default (testInput, testSpecifications, testImplementations, testInterfac
         }
     }
     const t = Testeranto(testInput, testSpecifications, testImplementations, {
-        beforeAll: async (initialProps, artificer) => {
+        beforeAll: async (subject, artificer) => {
             return await new Promise((resolve, rej) => {
                 const htmlElement = document.getElementById("root");
                 if (htmlElement) {
                     const domRoot = ReactDom.createRoot(htmlElement);
-                    // Ignore these type errors
-                    domRoot.render(createElement(TesterantoComponent, Object.assign(Object.assign({}, initialProps), { done: (reactElement) => {
-                            resolve({
-                                htmlElement,
-                                reactElement,
-                                domRoot,
-                            });
-                        } }), []));
-                    // resolve({ htmlElement });
+                    resolve({ domRoot, htmlElement });
                 }
             });
         },
-        // beforeEach: async (
-        //   s,
-        //   initializer,
-        //   testResource,
-        //   artificer,
-        //   initialValues
-        // ): Promise<IStore> => {
-        //   return new Promise((resolve, rej) => {
-        //     console.log("beforeEach" + TesterantoComponent);
-        //     // const domRoot = ReactDom.createRoot(htmlElement);
-        //     // // Ignore these type errors
-        //     // domRoot.render(
-        //     //   createElement(
-        //     //     TesterantoComponent,
-        //     //     {
-        //     //       ...initializer,
-        //     //       done: (reactElement) => {
-        //     //         resolve({
-        //     //           htmlElement,
-        //     //           reactElement,
-        //     //           domRoot,
-        //     //         });
-        //     //       },
-        //     //     },
-        //     //     []
-        //     //   )
-        //     // );
-        //   });
-        // },
+        beforeEach: async ({ domRoot, htmlElement }, initialValues, testResource, artificer) => {
+            return new Promise(async (resolve, rej) => {
+                domRoot.render(createElement(TesterantoComponent, Object.assign(Object.assign({}, initialValues), { done: (reactElement) => {
+                        resolve({
+                            htmlElement,
+                            reactElement,
+                            domRoot,
+                        });
+                    } }), []));
+            });
+        },
         andWhen: function (s, whenCB) {
             return whenCB(s);
         },