testeranto 0.94.0 → 0.110.0

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

@@ -8,10 +8,19 @@ export class PM_Node extends PM {
         this.server = {};
         this.testResourceConfiguration = t;
     }
-    $(selector) {
-        throw new Error("Method not implemented.");
+    waitForSelector(p, s) {
+        return globalThis["waitForSelector"](p, s);
+    }
+    closePage(p) {
+        return globalThis["closePage"](p);
+    }
+    goto(cdpPage, url) {
+        return globalThis["goto"](cdpPage.mainFrame()._id, url);
     }
-    screencast(opts) {
+    newPage() {
+        return globalThis["newPage"]();
+    }
+    $(selector) {
         throw new Error("Method not implemented.");
     }
     isDisabled(selector) {
@@ -35,8 +44,14 @@ export class PM_Node extends PM {
     click(selector) {
         return globalThis["click"](selector);
     }
-    customScreenShot(opts) {
-        return globalThis["customScreenShot"](opts);
+    screencast(opts, page) {
+        return globalThis["screencast"](Object.assign(Object.assign({}, opts), { path: this.testResourceConfiguration.fs + "/" + opts.path }), page.mainFrame()._id, 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);
     }
     existsSync(destFolder) {
         return globalThis["existsSync"](this.testResourceConfiguration.fs + "/" + destFolder);

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

@@ -5,11 +5,26 @@ export class PM_Web extends PM {
         this.server = {};
         this.testResourceConfiguration = t;
     }
-    $(selector) {
-        return window["$"](selector);
+    waitForSelector(p, s) {
+        return window["waitForSelector"](p, s);
     }
     screencast(opts) {
-        throw new Error("Method not implemented.");
+        return window["screencast"](Object.assign(Object.assign({}, opts), { path: this.testResourceConfiguration.fs + "/" + opts.path }), this.testResourceConfiguration.name);
+    }
+    screencastStop(recorder) {
+        return window["screencastStop"](recorder);
+    }
+    closePage(p) {
+        return window["closePage"](p);
+    }
+    goto(p, url) {
+        return window["goto"](p, url);
+    }
+    newPage() {
+        return window["newPage"]();
+    }
+    $(selector) {
+        return window["$"](selector);
     }
     isDisabled(selector) {
         return window["isDisabled"](selector);
@@ -38,7 +53,7 @@ export class PM_Web extends PM {
     existsSync(destFolder) {
         return window["existsSync"](destFolder);
     }
-    mkdirSync() {
+    mkdirSync(x) {
         return window["mkdirSync"](this.testResourceConfiguration.fs + "/");
     }
     write(writeObject, contents) {

package/dist/module/ReportClient.js

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

package/dist/module/ReportServer.js

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

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

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

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

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

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

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

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

@@ -33,17 +33,17 @@ export default (testInput, testSpecifications, testImplementations, testInterfac
                     } }), []));
             });
         },
-        andWhen: function (s, whenCB) {
+        andWhen: async function (s, whenCB) {
             return whenCB(s);
         },
         butThen: async function (s, thenCB) {
             return thenCB(s);
         },
         afterEach: (testInterface === null || testInterface === void 0 ? void 0 : testInterface.afterEach) ||
-            async function (store, ndx, artificer, utils) {
+            async function (store, ndx, utils) {
                 return store;
             },
-        afterAll: async (store, artificer, utils) => {
+        afterAll: async (store, utils) => {
             // setTimeout(() => {
             //   console.log("This will run after 1 second");
             // }, 1000); // 1000 milliseconds = 1 second

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

@@ -1,6 +1,6 @@
 import { createElement } from "react";
-import { renderToStaticMarkup, renderToStaticNodeStream } from "react-dom/server";
-import Stream from 'stream';
+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) => {
@@ -10,7 +10,7 @@ export default (testImplementations, testSpecifications, testInput) => {
                 resolve(null);
             });
         },
-        beforeEach: async (reactComponent, ndx, testRsource, artificer) => {
+        beforeEach: async () => {
             return new Promise((resolve, rej) => {
                 resolve(createElement(testInput));
             });

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

@@ -32,30 +32,31 @@ export default (testImplementations, testSpecifications, testInput) => {
                 }
             });
         },
-        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);
-            });
+        beforeEach: async (subject) => {
+            return subject;
+            // 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) {
+        andWhen: async function (s, whenCB, tr, utils) {
             return whenCB(s, utils);
             // return new Promise(async (resolve, rej) => {
             //   // resolve(await whenCB(s, utils));

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

@@ -1,13 +1,7 @@
 import React from "react";
 import renderer, { act } from "react-test-renderer";
-const Context = React.createContext({});
-const AppContext = React.createContext({});
-const contextValue = {
-    ingredients: ["flour", "sugar", "eggs"],
-    temperature: "200",
-};
 export const testInterface = {
-    butThen: async function (s, thenCB, tr) {
+    butThen: async function (s, thenCB) {
         // console.log("butThen", thenCB.toString());
         return thenCB(s);
     },

package/dist/module/TestReport.js

@@ -0,0 +1,91 @@
+import ReactDom from "react-dom/client";
+import React, { useEffect, useState } from "react";
+import { Col, Nav, Row, Tab } from "react-bootstrap";
+import 'bootstrap/dist/css/bootstrap.min.css';
+import "./style.css";
+import { Footer } from "./Footer";
+const StepPane = ({ step }) => {
+    return React.createElement("div", null,
+        React.createElement("pre", null,
+            React.createElement("code", null, JSON.stringify(step, null, 2))));
+};
+const TestPane = ({ given }) => {
+    return React.createElement("div", null,
+        "    ",
+        React.createElement(Tab.Container, { id: "TestPane-tabs", defaultActiveKey: "first" },
+            React.createElement(Row, null,
+                React.createElement(Col, { sm: 3 },
+                    React.createElement(Nav, { variant: "pills", className: "flex-column" },
+                        React.createElement(Nav.Item, null,
+                            React.createElement(Nav.Link, { eventKey: `bdd-features` }, "features"),
+                            ...given.whens.map((w, ndx) => React.createElement(Nav.Link, { eventKey: `bdd-when-${ndx}` },
+                                "When ",
+                                w.name,
+                                " ",
+                                w.error && "!")),
+                            ...given.thens.map((t, ndx) => React.createElement(Nav.Link, { eventKey: `bdd-then-${ndx}` },
+                                "Then ",
+                                t.name,
+                                " ",
+                                t.error && "!")),
+                            React.createElement(Nav.Link, { eventKey: `bdd-errors` }, "errors")))),
+                React.createElement(Col, { sm: 9 },
+                    React.createElement(Tab.Content, null,
+                        React.createElement(Tab.Pane, { eventKey: `bdd-features` },
+                            React.createElement("pre", null,
+                                React.createElement("code", null, JSON.stringify(given.features, null, 2)))),
+                        ...given.whens.map((w, ndx) => React.createElement(Tab.Pane, { eventKey: `bdd-when-${ndx}` },
+                            React.createElement(StepPane, { step: w }))),
+                        ...given.thens.map((t, ndx) => React.createElement(Tab.Pane, { eventKey: `bdd-then-${ndx}` },
+                            React.createElement(StepPane, { step: t }))),
+                        React.createElement(Tab.Pane, { eventKey: `bdd-errors` },
+                            React.createElement("pre", null,
+                                React.createElement("code", null, JSON.stringify(given.error, null, 2)))))))));
+};
+const BddPage = () => {
+    const [configs, setConfigs] = useState();
+    useEffect(() => {
+        (async () => {
+            fetch('/kokomoBay/docs/testeranto.json')
+                .then(response => response.json())
+                .then(json => {
+                setConfigs(json);
+            })
+                .catch(error => console.error(error));
+        })();
+    }, []);
+    const [bddErrors, setBddErrors] = useState();
+    useEffect(() => {
+        (async () => {
+            setBddErrors(await (await fetch(`tests.json`)).json());
+        })();
+    }, [configs]);
+    if (!configs || !bddErrors) {
+        return React.createElement("div", null, "loading...");
+    }
+    return React.createElement("div", null,
+        "  ",
+        React.createElement(Row, null,
+            React.createElement(Col, { sm: 12 },
+                React.createElement("h2", null, bddErrors.name))),
+        React.createElement(Row, null,
+            React.createElement(Tab.Container, { id: "root-tab-container", defaultActiveKey: "first" },
+                React.createElement(Row, null,
+                    React.createElement(Col, { sm: 3 },
+                        React.createElement(Nav, { variant: "pills", className: "flex-column" }, ...bddErrors.givens.map((g) => React.createElement(Nav.Item, null,
+                            React.createElement(Nav.Link, { eventKey: g.key },
+                                g.key,
+                                ": Given ",
+                                g.name))))),
+                    React.createElement(Col, { sm: 9 },
+                        React.createElement(Tab.Content, null, ...bddErrors.givens.map((g) => React.createElement(Tab.Pane, { eventKey: g.key },
+                            React.createElement(TestPane, { given: g })))))))),
+        React.createElement(Footer, null));
+};
+document.addEventListener("DOMContentLoaded", function () {
+    const elem = document.getElementById("root");
+    if (elem) {
+        ReactDom.createRoot(elem).render(React.createElement(BddPage, {}, []));
+    }
+});
+console.log("hello BddPage!");

package/dist/module/build.js

@@ -0,0 +1,184 @@
+import fs from "fs";
+import path from "path";
+import readline from "readline";
+import { glob } from "glob";
+import esbuild from "esbuild";
+import esbuildNodeConfiger from "./esbuildConfigs/node.js";
+import esbuildWebConfiger from "./esbuildConfigs/web.js";
+import webHtmlFrame from "./web.html.js";
+readline.emitKeypressEvents(process.stdin);
+if (process.stdin.isTTY)
+    process.stdin.setRawMode(true);
+const getRunnables = (tests, payload = {
+    nodeEntryPoints: {},
+    webEntryPoints: {},
+}) => {
+    return tests.reduce((pt, cv, cndx, cry) => {
+        if (cv[1] === "node") {
+            pt.nodeEntryPoints[cv[0]] = path.resolve(`./docs/node/${cv[0].split(".").slice(0, -1).concat("mjs").join(".")}`);
+        }
+        else if (cv[1] === "web") {
+            pt.webEntryPoints[cv[0]] = path.resolve(`./docs/web/${cv[0].split(".").slice(0, -1).concat("mjs").join(".")}`);
+        }
+        if (cv[3].length) {
+            getRunnables(cv[3], payload);
+        }
+        return pt;
+    }, payload);
+};
+import(process.cwd() + "/" + process.argv[2]).then(async (module) => {
+    const rawConfig = module.default;
+    const getSecondaryEndpointsPoints = (runtime) => {
+        const meta = (ts, st) => {
+            ts.forEach((t) => {
+                if (t[1] === runtime) {
+                    st.add(t[0]);
+                }
+                if (Array.isArray(t[3])) {
+                    meta(t[3], st);
+                }
+            });
+            return st;
+        };
+        return Array.from(meta(config.tests, new Set()));
+    };
+    const config = Object.assign(Object.assign({}, rawConfig), { buildDir: process.cwd() + "/" + rawConfig.outdir });
+    let nodeDone = false;
+    let webDone = false;
+    let mode = config.devMode ? "DEV" : "PROD";
+    let status = "build";
+    // let pm: PM_Main | undefined = new PM_Main(config);
+    // const fileHashes = {};
+    const { nodeEntryPoints, webEntryPoints } = getRunnables(config.tests);
+    const onNodeDone = () => {
+        nodeDone = true;
+        onDone();
+    };
+    const onWebDone = () => {
+        webDone = true;
+        onDone();
+    };
+    const onDone = async () => {
+        if (nodeDone && webDone) {
+            status = "built";
+        }
+        if (nodeDone && webDone && status === "built") {
+            // Object.entries(nodeEntryPoints).forEach(([k, outputFile]) => {
+            //   console.log("watching", outputFile);
+            //   try {
+            //     watch(outputFile, async (filename) => {
+            //       const hash = await fileHash(outputFile);
+            //       if (fileHashes[k] !== hash) {
+            //         fileHashes[k] = hash;
+            //         console.log(`< ${filename} `);
+            //         pm.launchNode(k, outputFile);
+            //       }
+            //     });
+            //   } catch (e) {
+            //     console.error(e);
+            //   }
+            // });
+            // Object.entries(webEntryPoints).forEach(([k, outputFile]) => {
+            //   console.log("watching", outputFile);
+            //   watch(outputFile, async (filename) => {
+            //     const hash = await fileHash(outputFile);
+            //     console.log(`< ${filename} ${hash}`);
+            //     if (fileHashes[k] !== hash) {
+            //       fileHashes[k] = hash;
+            //       pm.launchWeb(k, outputFile);
+            //     }
+            //   });
+            // });
+        }
+        if (nodeDone && webDone && mode === "PROD") {
+            console.log("Testeranto-EsBuild is all done. Goodbye!");
+            process.exit();
+        }
+        else {
+            if (mode === "PROD") {
+                console.log("waiting for tests to finish");
+                console.log(JSON.stringify({
+                    nodeDone: nodeDone,
+                    webDone: webDone,
+                    mode: mode,
+                }, null, 2));
+            }
+            else {
+                console.log("waiting for tests to change");
+            }
+            if (config.devMode) {
+                console.log("ready and watching for changes...");
+            }
+            else {
+                // pm.shutDown();
+            }
+            ////////////////////////////////////////////////////////////////////////////////
+        }
+    };
+    console.log(`Press 'q' to shutdown gracefully. Press 'x' to shutdown forcefully.`);
+    process.stdin.on("keypress", (str, key) => {
+        if (key.name === "q") {
+            console.log("Testeranto-Build is shutting down...");
+            mode = "PROD";
+            onDone();
+        }
+        if (key.name === "x") {
+            console.log("Testeranto-Build is shutting down forcefully...");
+            process.exit(-1);
+        }
+    });
+    fs.writeFileSync(`${config.outdir}/testeranto.json`, JSON.stringify(config, null, 2));
+    Promise.resolve(Promise.all([...getSecondaryEndpointsPoints("web")].map(async (sourceFilePath) => {
+        const sourceFileSplit = sourceFilePath.split("/");
+        const sourceDir = sourceFileSplit.slice(0, -1);
+        const sourceFileName = sourceFileSplit[sourceFileSplit.length - 1];
+        const sourceFileNameMinusJs = sourceFileName
+            .split(".")
+            .slice(0, -1)
+            .join(".");
+        const htmlFilePath = path.normalize(`${process.cwd()}/${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)));
+    })));
+    glob(`./${config.outdir}/chunk-*.mjs`, {
+        ignore: "node_modules/**",
+    }).then((chunks) => {
+        chunks.forEach((chunk) => {
+            fs.unlinkSync(chunk);
+        });
+    });
+    await Promise.all([
+        esbuild
+            .context(esbuildNodeConfiger(config, Object.keys(nodeEntryPoints)))
+            .then(async (nodeContext) => {
+            if (config.devMode) {
+                await nodeContext.watch().then((v) => {
+                    onNodeDone();
+                });
+            }
+            else {
+                nodeContext.rebuild().then((v) => {
+                    onNodeDone();
+                });
+            }
+            return nodeContext;
+        }),
+        esbuild
+            .context(esbuildWebConfiger(config, Object.keys(webEntryPoints)))
+            .then(async (webContext) => {
+            if (config.devMode) {
+                await webContext.watch().then((v) => {
+                    onWebDone();
+                });
+            }
+            else {
+                webContext.rebuild().then((v) => {
+                    onWebDone();
+                });
+            }
+            return webContext;
+        }),
+    ]);
+});

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

@@ -1,4 +1,5 @@
 const config = {
+    src: "src",
     outdir: "docs",
     tests: [],
     debugger: true,

package/dist/module/esbuildConfigs/eslint-formatter-testeranto.js

@@ -0,0 +1,3 @@
+export default function (results) {
+    return JSON.stringify(results, null, 2);
+}