testeranto 0.110.0 → 0.111.0

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

@@ -1,90 +0,0 @@
-import React, { useEffect, useRef } from "react";
-import { createElement } from "react";
-import ReactDom from "react-dom";
-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) => {
-            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: async function (s, whenCB, tr, utils) {
-            return whenCB(s, utils);
-            // return new Promise(async (resolve, rej) => {
-            //   // resolve(await whenCB(s, utils));
-            //   // process.nextTick(() => {
-            //   //   resolve(whenCB()(s));
-            //   // });
-            // });
-        },
-        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({});
-            });
-        },
-    });
-    document.addEventListener("DOMContentLoaded", function () {
-        const rootElement = document.getElementById("root");
-        if (rootElement) {
-        }
-    });
-    return t;
-};

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

@@ -1,16 +0,0 @@
-import React from "react";
-import renderer, { act } from "react-test-renderer";
-import test from "../../../Node";
-export default (testImplementations, testSpecifications, testInput) => test(testInput, testSpecifications, testImplementations, {
-    beforeEach: function (CComponent, props) {
-        let component;
-        act(() => {
-            component = renderer.create(React.createElement(CComponent, props, []));
-        });
-        return component;
-    },
-    andWhen: async function (renderer, whenCB) {
-        await act(() => whenCB()(renderer));
-        return renderer;
-    },
-});

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

@@ -1 +0,0 @@
-export {};

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

@@ -1,31 +0,0 @@
-import React from "react";
-import renderer, { act } from "react-test-renderer";
-export const testInterface = {
-    beforeEach: function (CComponent, propsAndChildren) {
-        function Link(proper) {
-            return React.createElement(CComponent, proper(), []);
-        }
-        return new Promise((res, rej) => {
-            act(async () => {
-                const testRenderer = await renderer.create(Link(propsAndChildren));
-                res(testRenderer);
-            });
-        });
-    },
-    andWhen: async function (renderer, whenCB) {
-        await act(() => whenCB(renderer));
-        return renderer;
-    },
-    // andWhen: function (s: Store, whenCB): Promise<Selection> {
-    //   return whenCB()(s);
-    // },
-    butThen: async function (s, thenCB, tr) {
-        return thenCB(s);
-    },
-    afterEach: async function (store, ndx, artificer) {
-        return {};
-    },
-    afterAll: (store, artificer) => {
-        return;
-    },
-};

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

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

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

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

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

@@ -1,22 +0,0 @@
-import React from "react";
-import renderer, { act } from "react-test-renderer";
-import test from "../../../Node.js";
-export default (testImplementations, testSpecifications, testInput) => test(testInput, testSpecifications, testImplementations, {
-    beforeEach: function (CComponent, props) {
-        return new Promise((res, rej) => {
-            let component;
-            act(() => {
-                component = renderer.create(React.createElement(CComponent, props, []));
-                res(component);
-            });
-        });
-    },
-    andWhen: async function (renderer, whenCB) {
-        await act(() => whenCB()(renderer));
-        return renderer;
-    },
-    afterEach: async (store, key, artificer) => {
-        console.log("afterall");
-        store.unmount();
-    },
-});

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

@@ -1,22 +0,0 @@
-import React from "react";
-import renderer, { act } from "react-test-renderer";
-import test from "../../../Web.js";
-export default (testImplementations, testSpecifications, testInput) => test(testInput, testSpecifications, testImplementations, {
-    beforeEach: function (CComponent, props) {
-        return new Promise((res, rej) => {
-            let component;
-            act(() => {
-                component = renderer.create(React.createElement(CComponent, props, []));
-                res(component);
-            });
-        });
-    },
-    andWhen: async function (renderer, whenCB) {
-        await act(() => whenCB()(renderer));
-        return renderer;
-    },
-    afterEach: async (store, key, artificer) => {
-        console.log("afterall");
-        store.unmount();
-    },
-});

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

@@ -1,28 +0,0 @@
-import React from "react";
-import renderer, { act } from "react-test-renderer";
-export const testInterface = {
-    butThen: async function (s, thenCB) {
-        // console.log("butThen", thenCB.toString());
-        return thenCB(s);
-    },
-    beforeEach: function (CComponent, props) {
-        let component;
-        act(() => {
-            // component = renderer.create(
-            //   React.createElement(
-            //     AppContext.Provider,
-            //     { value: contextValue },
-            //     React.createElement(AppContext.Consumer, null, (context) =>
-            //       React.createElement(CComponent, Object.assign({}, context, {}))
-            //     )
-            //   )
-            // );
-            component = renderer.create(React.createElement(CComponent, props, React.createElement(CComponent, props, [])));
-        });
-        return component;
-    },
-    andWhen: async function (renderer, whenCB) {
-        await act(() => whenCB(renderer));
-        return renderer;
-    },
-};

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

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

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

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

package/dist/module/SubPackages/react-test-renderer/jsx-promised/index.js

@@ -1,16 +0,0 @@
-import renderer, { act } from "react-test-renderer";
-export const testInterface = {
-    beforeEach: async (CComponent) => {
-        return new Promise((res, rej) => {
-            let component;
-            act(async () => {
-                component = renderer.create(CComponent);
-            });
-            res(component);
-        });
-    },
-    andWhen: async function (renderer, whenCB) {
-        await act(() => whenCB()(renderer));
-        return renderer;
-    },
-};

package/dist/module/SubPackages/react-test-renderer/jsx-promised/node.js

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

package/dist/module/SubPackages/react-test-renderer/jsx-promised/web.js

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

package/dist/module/TestReport.js

@@ -1,91 +0,0 @@
-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/Types.js

@@ -1 +0,0 @@
-export {};

package/dist/module/Web.js

@@ -1,42 +0,0 @@
-import { PM_Web } from "./PM/web";
-import Testeranto from "./lib/core.js";
-import { defaultTestResourceRequirement, } from "./lib/index.js";
-let errorCallback = (e) => { };
-let unhandledrejectionCallback = (event) => {
-    console.log("window.addEventListener unhandledrejection", event);
-    // cb({ error: event.reason.message });
-    // throw event;
-};
-export class WebTesteranto extends Testeranto {
-    constructor(input, testSpecification, testImplementation, testResourceRequirement, testInterface) {
-        super(input, testSpecification, testImplementation, testResourceRequirement, testInterface, (cb) => {
-            window.removeEventListener("error", errorCallback);
-            errorCallback = (e) => {
-                console.log("window.addEventListener error", e);
-                cb(e);
-                // throw e;
-            };
-            window.addEventListener("error", errorCallback);
-            window.removeEventListener("unhandledrejection", unhandledrejectionCallback);
-            /////////////////////
-            window.removeEventListener("unhandledrejection", unhandledrejectionCallback);
-            unhandledrejectionCallback = (event) => {
-                console.log("window.addEventListener unhandledrejection", event);
-                cb({ error: event.reason.message });
-                // throw event;
-            };
-            window.addEventListener("unhandledrejection", unhandledrejectionCallback);
-        });
-    }
-    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 });
-        });
-    }
-}
-export default async (input, testSpecification, testImplementation, testInterface, testResourceRequirement = defaultTestResourceRequirement) => {
-    return new WebTesteranto(input, testSpecification, testImplementation, testResourceRequirement, testInterface);
-};

package/dist/module/build.js

@@ -1,184 +0,0 @@
-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/defaultConfig.js

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

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

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

package/dist/module/esbuildConfigs/featuresPlugin.js

@@ -1,34 +0,0 @@
-import path from "path";
-export default {
-    name: "feature-markdown",
-    setup(build) {
-        build.onResolve({ filter: /\.md$/ }, (args) => {
-            if (args.resolveDir === "")
-                return;
-            return {
-                path: path.isAbsolute(args.path)
-                    ? args.path
-                    : path.join(args.resolveDir, args.path),
-                namespace: "feature-markdown",
-            };
-        });
-        build.onLoad({ filter: /.*/, namespace: "feature-markdown" }, async (args) => {
-            // const markdownContent = new TextDecoder().decode(
-            //   await fs.readFileSync(args.path)
-            // );
-            // markdownHTML = marked(markdownContent, options?.markedOptions);
-            return {
-                contents: `file://${args.path}`,
-                loader: "text",
-                // contents: JSON.stringify({ path: args.path }),
-                // loader: "json",
-                // contents: JSON.stringify({
-                //   // html: markdownHTML,
-                //   raw: markdownContent,
-                //   filename: args.path, //path.basename(args.path),
-                // }),
-                // loader: "json",
-            };
-        });
-    },
-};