testeranto 0.114.1 → 0.125.0

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);
+};

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

@@ -0,0 +1,53 @@
+import { createElement, useEffect, useRef } from "react";
+import React from "react";
+import ReactDom from "react-dom/client";
+const TesterantoComponent = ({ done, innerComp, }) => {
+    const myContainer = useRef(null);
+    useEffect(() => {
+        done(myContainer.current);
+    }, []);
+    return React.createElement("div", { ref: myContainer }, innerComp());
+};
+export const testInterface = {
+    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) => {
+        return subject;
+    },
+    andWhen: async function (s, whenCB, tr, utils) {
+        return whenCB(s, utils);
+    },
+    butThen: async function (s, thenCB, tr, utils) {
+        return new Promise((resolve, rej) => {
+            resolve(thenCB(s, utils));
+        });
+    },
+    afterEach: async function (store, ndx, artificer) {
+        return new Promise((resolve, rej) => {
+            resolve({});
+        });
+    },
+    afterAll: (store, artificer) => {
+        return new Promise((resolve, rej) => {
+            resolve({});
+        });
+    },
+};

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

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

package/dist/module/src/SubPackages/react-test-renderer/component/index.js

@@ -0,0 +1,14 @@
+export {};
+// export type ISuper<T> = T extends infer U ? U : object;
+// export type InitialState = unknown;
+// export type IWhenShape = any;
+// export type IThenShape = any;
+// export type ISelection = renderer.ReactTestRenderer;
+// export type IStore = renderer.ReactTestRenderer;
+// export type ISubject = renderer.ReactTestRenderer;
+// export type IImpl<I extends IT, O extends OT, M> = ITestImplementation<I, O>;
+// export type ITestSpecification<
+//   I extends IT,
+//   O extends OT,
+//   M
+// > = ITestSpecification<I, O>;

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

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

package/dist/module/src/SubPackages/react-test-renderer/component/test/implementation.js

@@ -0,0 +1,54 @@
+// import { ITestImplementation } from "testeranto/src/Types";
+// import { I } from "testeranto/src/SubPackages/react-test-renderer/component";
+import { assert } from "chai";
+export const testImplementation = {
+    suites: {
+        Default: "default",
+    },
+    givens: {
+        AnEmptyState: () => {
+            return { foo: "bar" };
+        },
+    },
+    whens: {
+        IClickTheButton: () => async (component) => {
+            const button = component.root.findByType("button");
+            button.props.onClick();
+            return component;
+        },
+        IClickTheHeader: () => async (component) => {
+            try {
+                const header = component.root.findByType("h1");
+                header.props.onClick();
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            }
+            catch (error) {
+                // Expected error - header click fails
+            }
+            return component;
+        },
+    },
+    thens: {
+        ThePropsIs: (expectation) => (component) => {
+            const propsElement = component.root.findByProps({ id: "theProps" });
+            return assert.deepEqual(JSON.parse(propsElement.props.children), expectation);
+        },
+        TheStatusIs: (expectation) => (component) => {
+            try {
+                const statElement = component.root.findByProps({ id: "theStat" });
+                const actual = JSON.parse(statElement.props.children);
+                assert.deepEqual(actual, expectation, "the status was not as expected");
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            }
+            catch (error) {
+                assert.fail(`Element with id "theStat" not found`);
+            }
+            return component;
+        },
+    },
+    checks: {
+        AnEmptyState: () => {
+            return { foo: "bar" };
+        },
+    },
+};

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

@@ -0,0 +1,5 @@
+import test from "../node";
+import component from "../../../../examples/react/component/index";
+import { specification } from "../../../../examples/react/component/test";
+import { testImplementation } from "./implementation";
+export default test(testImplementation, specification, component);

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

@@ -0,0 +1,5 @@
+import test from "../pure";
+import component from "../../../../examples/react/component/index";
+import { specification } from "../../../../examples/react/component/test";
+import { testImplementation } from "./implementation";
+export default test(testImplementation, specification, component);

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

@@ -0,0 +1,5 @@
+import test from "../web";
+import component from "../../../../examples/react/component/index";
+import { specification } from "../../../../examples/react/component/test";
+import { testImplementation } from "./implementation";
+export default test(testImplementation, specification, component);

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

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

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

@@ -29,7 +29,7 @@ const TestPane = ({ given }) => {
                                 " ",
                                 t.error && "!")),
                             React.createElement(Nav.Link, { eventKey: `bdd-errors` }, "errors")))),
-                React.createElement(Col, { sm: 9 },
+                React.createElement(Col, { sm: 6 },
                     React.createElement(Tab.Content, null,
                         React.createElement(Tab.Pane, { eventKey: `bdd-features` },
                             React.createElement("pre", null,
@@ -43,24 +43,30 @@ const TestPane = ({ given }) => {
                                 React.createElement("code", null, JSON.stringify(given.error, null, 2)))))))));
 };
 const BddPage = () => {
-    const [configs, setConfigs] = useState();
+    // const [configs, setConfigs] = useState<IBuiltConfig>();
+    // useEffect(() => {
+    //   (async () => {
+    //     fetch('../config.json')
+    //       .then(response => response.json())
+    //       .then(json => {
+    //         setConfigs(json)
+    //       })
+    //       .catch(error => console.error(error));
+    //   })();
+    // }, []);
+    const [bddErrors, setBddErrors] = useState();
     useEffect(() => {
         (async () => {
-            fetch('/kokomoBay/docs/testeranto.json')
-                .then(response => response.json())
-                .then(json => {
-                setConfigs(json);
-            })
-                .catch(error => console.error(error));
+            setBddErrors(await (await fetch(`tests.json`)).json());
         })();
     }, []);
-    const [bddErrors, setBddErrors] = useState();
+    const [log, setLog] = useState();
     useEffect(() => {
         (async () => {
-            setBddErrors(await (await fetch(`tests.json`)).json());
+            setLog(await (await fetch(`log.txt`)).text());
         })();
-    }, [configs]);
-    if (!configs || !bddErrors) {
+    }, []);
+    if (!bddErrors || !log) {
         return React.createElement("div", null, "loading...");
     }
     return React.createElement("div", null,
@@ -71,13 +77,16 @@ const BddPage = () => {
         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("pre", null,
+                            React.createElement("code", null, log))),
                     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(Col, { sm: 6 },
                         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));
@@ -85,7 +94,10 @@ const BddPage = () => {
 document.addEventListener("DOMContentLoaded", function () {
     const elem = document.getElementById("root");
     if (elem) {
-        ReactDom.createRoot(elem).render(React.createElement(BddPage, {}, []));
+        if (elem) {
+            const root = ReactDom.createRoot(elem);
+            root.render(React.createElement(BddPage, {}));
+        }
     }
 });
 console.log("hello BddPage!");

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

@@ -31,10 +31,7 @@ export class WebTesteranto extends Testeranto {
     async receiveTestResourceConfig(partialTestResource) {
         const t = partialTestResource; //JSON.parse(partialTestResource);
         const pm = new PM_Web(t);
-        const { failed, artifacts, logPromise, features } = await this.testJobs[0].receiveTestResourceConfig(pm);
-        return new Promise((res, rej) => {
-            res({ features, failed });
-        });
+        return await this.testJobs[0].receiveTestResourceConfig(pm);
     }
 }
 export default async (input, testSpecification, testImplementation, testInterface, testResourceRequirement = defaultTestResourceRequirement) => {

package/dist/module/src/build.js

@@ -0,0 +1,185 @@
+import ansiC from "ansi-colors";
+import fs from "fs";
+import path from "path";
+import readline from "readline";
+import esbuild from "esbuild";
+import esbuildNodeConfiger from "./esbuildConfigs/node.js";
+import esbuildWebConfiger from "./esbuildConfigs/web.js";
+import esbuildImportConfiger from "./esbuildConfigs/pure.js";
+import webHtmlFrame from "./web.html.js";
+import { getRunnables } from "./utils.js";
+readline.emitKeypressEvents(process.stdin);
+if (process.stdin.isTTY)
+    process.stdin.setRawMode(true);
+let testName = process.argv[2];
+let mode = process.argv[3];
+if (mode !== "once" && mode !== "dev") {
+    console.error(`The 4th argument should be 'dev' or 'once', not '${mode}'.`);
+    process.exit(-1);
+}
+console.log("testeranto is building", testName, mode);
+import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
+    const bigConfig = module.default;
+    const project = bigConfig.projects[testName];
+    if (!project) {
+        console.error("no project found for", testName, "in testeranto.config.ts");
+        process.exit(-1);
+    }
+    const rawConfig = bigConfig.projects[testName];
+    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() + "/testeranto/bundles/" + testName });
+    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 = "once";
+            onDone();
+        }
+        else if (key.name === "x") {
+            console.log("Testeranto-Build is shutting down forcefully...");
+            process.exit(-1);
+        }
+        else {
+            console.log(`Press 'q' to shutdown gracefully. Press 'x' to shutdown forcefully.`);
+        }
+    });
+    let nodeDone = false;
+    let webDone = false;
+    let importDone = false;
+    let status = "build";
+    const { nodeEntryPoints, webEntryPoints, importEntryPoints } = getRunnables(config.tests, testName);
+    const onNodeDone = () => {
+        nodeDone = true;
+        onDone();
+    };
+    const onWebDone = () => {
+        webDone = true;
+        onDone();
+    };
+    const onImportDone = () => {
+        importDone = true;
+        onDone();
+    };
+    const onDone = async () => {
+        if (nodeDone && webDone && importDone) {
+            status = "built";
+        }
+        if (nodeDone && webDone && importDone && mode === "once") {
+            console.log(ansiC.inverse(`${testName} has been built. Goodbye.`));
+            process.exit();
+        }
+    };
+    if (!fs.existsSync(`testeranto/reports/${testName}`)) {
+        fs.mkdirSync(`testeranto/reports/${testName}`);
+    }
+    fs.writeFileSync(`${process.cwd()}/testeranto/reports/${testName}/index.html`, `
+    <!DOCTYPE html>
+    <html lang="en">
+  
+    <head>
+      <meta name="description" content="Webpage description goes here" />
+      <meta charset="utf-8" />
+      <title>kokomoBay - testeranto</title>
+      <meta name="viewport" content="width=device-width, initial-scale=1" />
+      <meta name="author" content="" />
+  
+      <link rel="stylesheet" href="/kokomoBay/testeranto/ReportClient.css" />
+      <script type="module" src="/kokomoBay/testeranto/ReportClient.js"></script>
+  
+    </head>
+  
+    <body>
+      <div id="root">
+        react is loading
+      </div>
+    </body>
+  
+    </html>
+        `);
+    fs.writeFileSync(`testeranto/reports/${testName}/config.json`, JSON.stringify(config, null, 2));
+    fs.writeFileSync(`${process.cwd()}/testeranto/index.html`, `
+  <!DOCTYPE html>
+  <html lang="en">
+
+  <head>
+    <meta name="description" content="Webpage description goes here" />
+    <meta charset="utf-8" />
+    <title>kokomoBay - testeranto</title>
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <meta name="author" content="" />
+
+    <script type="application/json" id="bigConfig">
+      ${JSON.stringify(Object.keys(bigConfig.projects))}
+    </script>
+
+    <link rel="stylesheet" href="/kokomoBay/testeranto/Project.css" />
+    <script type="module" src="/kokomoBay/testeranto/Project.js"></script>
+
+  </head>
+
+  <body>
+    <div id="root">
+      react is loading
+    </div>
+  </body>
+
+  </html>
+      `);
+    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()}/testeranto/bundles/web/${testName}/${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(`${process.cwd()}/testeranto/bundles/${testName}/chunk-*.mjs`, {
+    //   ignore: "node_modules/**",
+    // }).then((chunks) => {
+    //   chunks.forEach((chunk) => {
+    //     fs.unlinkSync(chunk);
+    //   });
+    // });
+    await Promise.all([
+        ...[
+            [esbuildImportConfiger, importEntryPoints, onImportDone],
+            [esbuildNodeConfiger, nodeEntryPoints, onNodeDone],
+            [esbuildWebConfiger, webEntryPoints, onWebDone],
+        ].map(([configer, entryPoints, done]) => {
+            esbuild
+                .context(configer(config, Object.keys(entryPoints), testName))
+                .then(async (ctx) => {
+                if (mode === "dev") {
+                    await ctx.watch().then((v) => {
+                        done();
+                    });
+                }
+                else {
+                    ctx.rebuild().then((v) => {
+                        done();
+                    });
+                }
+                return ctx;
+            });
+        }),
+    ]);
+});

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

@@ -1,16 +1,14 @@
 const config = {
     src: "src",
-    outdir: "docs",
     tests: [],
     debugger: true,
     clearScreen: false,
-    devMode: true,
     minify: false,
-    outbase: ".",
     ports: ["3001"],
     externals: [],
     nodePlugins: [],
     webPlugins: [],
+    importPlugins: [],
     featureIngestor: function (s) {
         throw new Error("Function not implemented.");
     },

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

@@ -5,7 +5,7 @@ export default (config) => {
         format: "esm",
         splitting: true,
         outExtension: { ".js": ".mjs" },
-        outbase: config.outbase,
+        outbase: ".",
         jsx: "transform",
         bundle: true,
         minify: config.minify === true,

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

@@ -6,15 +6,19 @@ const register = (entrypoint, sources) => {
     }
     sources.forEach((s) => otherInputs[entrypoint].add(s));
 };
-export default (platform, entryPoints) => {
+export default (platform, testName) => {
+    const d = `testeranto/bundles/${platform}/${testName}/`;
+    const f = `testeranto/bundles/${platform}/${testName}/metafile.json`;
+    if (!fs.existsSync(d)) {
+        fs.mkdirSync(d);
+    }
     return {
         register,
         inputFilesPluginFactory: {
             name: "metafileWriter",
             setup(build) {
                 build.onEnd((result) => {
-                    // console.log("build.onEnd", entryPoints);
-                    fs.writeFileSync(`docs/${platform}/metafile.json`, JSON.stringify(result, null, 2));
+                    fs.writeFileSync(f, JSON.stringify(result, null, 2));
                 });
             },
         },

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

@@ -1,9 +1,9 @@
 import baseEsBuildConfig from "./index.js";
 import inputFilesPlugin from "./inputFilesPlugin.js";
 import featuresPlugin from "./featuresPlugin";
-export default (config, entryPoints) => {
-    const { inputFilesPluginFactory, register } = inputFilesPlugin("node", entryPoints);
-    return Object.assign(Object.assign({}, baseEsBuildConfig(config)), { splitting: true, outdir: config.outdir + "/node", 
+export default (config, entryPoints, testName) => {
+    const { inputFilesPluginFactory, register } = inputFilesPlugin("node", testName);
+    return Object.assign(Object.assign({}, baseEsBuildConfig(config)), { splitting: true, outdir: `testeranto/bundles/node/${testName}/`, 
         // inject: [`./node_modules/testeranto/dist/cjs-shim.js`],
         metafile: true, supported: {
             "dynamic-import": true,
@@ -16,7 +16,10 @@ export default (config, entryPoints) => {
             inputFilesPluginFactory,
             {
                 name: "rebuild-notify",
-                setup(build) {
+                setup: (build) => {
+                    build.onStart(() => {
+                        console.log(`> node build starting...`);
+                    });
                     build.onEnd((result) => {
                         console.log(`> node build ended with ${result.errors.length} errors`);
                         if (result.errors.length > 0) {

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

@@ -0,0 +1,36 @@
+import baseEsBuildConfig from "./index.js";
+import inputFilesPlugin from "./inputFilesPlugin.js";
+import featuresPlugin from "./featuresPlugin.js";
+export default (config, entryPoints, testName) => {
+    const { inputFilesPluginFactory, register } = inputFilesPlugin("pure", testName);
+    return Object.assign(Object.assign({}, baseEsBuildConfig(config)), { drop: ["console", "debugger"], splitting: true, outdir: `testeranto/bundles/pure/${testName}/`, 
+        // inject: [`./node_modules/testeranto/dist/cjs-shim.js`],
+        metafile: true, supported: {
+            "dynamic-import": true,
+        }, define: {
+            "process.env.FLUENTFFMPEG_COV": "0",
+        }, absWorkingDir: process.cwd(), banner: {
+            js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`,
+        }, platform: "node", external: ["react", ...config.externals], entryPoints: [...entryPoints], plugins: [
+            featuresPlugin,
+            inputFilesPluginFactory,
+            {
+                name: "rebuild-notify",
+                setup: (build) => {
+                    build.onStart(() => {
+                        console.log(`> pure build starting...`);
+                    });
+                    build.onEnd((result) => {
+                        console.log(`> pure build ended with ${result.errors.length} errors`);
+                        if (result.errors.length > 0) {
+                            console.log(result);
+                        }
+                        // console.log(result);
+                        // result.errors.length !== 0 && process.exit(-1);
+                    });
+                },
+            },
+            ...((config.nodePlugins || []).map((p) => p(register, entryPoints)) ||
+                []),
+        ] });
+};