testeranto 0.100.0 → 0.111.0

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

@@ -1,121 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { PM } from "./index.js";
-const fPaths = [];
-export class PM_Node extends PM {
-    constructor(t) {
-        super();
-        this.server = {};
-        this.testResourceConfiguration = t;
-    }
-    waitForSelector(p, s) {
-        return globalThis["waitForSelector"](p, s);
-    }
-    closePage(p) {
-        return globalThis["closePage"](p);
-    }
-    goto(cdpPage, url) {
-        return globalThis["goto"](cdpPage.mainFrame()._id, url);
-    }
-    newPage() {
-        return globalThis["newPage"]();
-    }
-    $(selector) {
-        throw new Error("Method not implemented.");
-    }
-    isDisabled(selector) {
-        throw new Error("Method not implemented.");
-    }
-    getAttribute(selector, attribute) {
-        throw new Error("Method not implemented.");
-    }
-    getValue(selector) {
-        throw new Error("Method not implemented.");
-    }
-    focusOn(selector) {
-        throw new Error("Method not implemented.");
-    }
-    typeInto(value) {
-        throw new Error("Method not implemented.");
-    }
-    page() {
-        return globalThis["page"]();
-    }
-    click(selector) {
-        return globalThis["click"](selector);
-    }
-    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);
-    }
-    mkdirSync() {
-        return globalThis["mkdirSync"](this.testResourceConfiguration.fs + "/");
-    }
-    write(writeObject, contents) {
-        return globalThis["write"](writeObject.uid, contents);
-    }
-    writeFileSync(filepath, contents) {
-        return globalThis["writeFileSync"](this.testResourceConfiguration.fs + "/" + filepath, contents, this.testResourceConfiguration.name);
-    }
-    createWriteStream(filepath) {
-        return globalThis["createWriteStream"](this.testResourceConfiguration.fs + "/" + filepath, this.testResourceConfiguration.name);
-    }
-    end(writeObject) {
-        return globalThis["end"](writeObject.uid);
-    }
-    customclose() {
-        globalThis["customclose"](this.testResourceConfiguration.fs, this.testResourceConfiguration.name);
-    }
-    testArtiFactoryfileWriter(tLog, callback) {
-        return (fPath, value) => {
-            callback(new Promise((res, rej) => {
-                tLog("testArtiFactory =>", fPath);
-                const cleanPath = path.resolve(fPath);
-                fPaths.push(cleanPath.replace(process.cwd(), ``));
-                const targetDir = cleanPath.split("/").slice(0, -1).join("/");
-                fs.mkdir(targetDir, { recursive: true }, async (error) => {
-                    if (error) {
-                        console.error(`❗️testArtiFactory failed`, targetDir, error);
-                    }
-                    fs.writeFileSync(path.resolve(targetDir.split("/").slice(0, -1).join("/"), "manifest"), fPaths.join(`\n`), {
-                        encoding: "utf-8",
-                    });
-                    if (Buffer.isBuffer(value)) {
-                        fs.writeFileSync(fPath, value, "binary");
-                        res();
-                    }
-                    else if (`string` === typeof value) {
-                        fs.writeFileSync(fPath, value.toString(), {
-                            encoding: "utf-8",
-                        });
-                        res();
-                    }
-                    else {
-                        /* @ts-ignore:next-line */
-                        const pipeStream = value;
-                        const myFile = fs.createWriteStream(fPath);
-                        pipeStream.pipe(myFile);
-                        pipeStream.on("close", () => {
-                            myFile.close();
-                            res();
-                        });
-                    }
-                });
-            }));
-        };
-    }
-    // launch(options?: PuppeteerLaunchOptions): Promise<Browser>;
-    startPuppeteer(options) {
-        // return puppeteer.connect(options).then((b) => {
-        //   this.browser = b;
-        // });
-    }
-}

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

@@ -1,117 +0,0 @@
-import { PM } from "./index.js";
-export class PM_Web extends PM {
-    constructor(t) {
-        super();
-        this.server = {};
-        this.testResourceConfiguration = t;
-    }
-    waitForSelector(p, s) {
-        return window["waitForSelector"](p, s);
-    }
-    screencast(opts) {
-        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);
-    }
-    getAttribute(selector, attribute) {
-        return window["getValue"](selector, attribute);
-    }
-    getValue(selector) {
-        return window["getValue"](selector);
-    }
-    focusOn(selector) {
-        return window["focusOn"](selector);
-    }
-    typeInto(value) {
-        return window["typeInto"](value);
-    }
-    page() {
-        return window["page"]();
-    }
-    click(selector) {
-        return window["click"](selector);
-    }
-    customScreenShot(opts) {
-        return window["customScreenShot"](Object.assign(Object.assign({}, opts), { path: this.testResourceConfiguration.fs + "/" + opts.path }), this.testResourceConfiguration.name);
-    }
-    existsSync(destFolder) {
-        return window["existsSync"](destFolder);
-    }
-    mkdirSync(x) {
-        return window["mkdirSync"](this.testResourceConfiguration.fs + "/");
-    }
-    write(writeObject, contents) {
-        return window["write"](writeObject.uid, contents);
-    }
-    writeFileSync(filepath, contents) {
-        return window["writeFileSync"](this.testResourceConfiguration.fs + "/" + filepath, contents, this.testResourceConfiguration.name);
-    }
-    createWriteStream(filepath) {
-        return window["createWriteStream"](this.testResourceConfiguration.fs + "/" + filepath, this.testResourceConfiguration.name);
-    }
-    end(writeObject) {
-        return window["end"](writeObject.uid);
-    }
-    customclose() {
-        window["customclose"](this.testResourceConfiguration.fs, this.testResourceConfiguration.name);
-    }
-    testArtiFactoryfileWriter(tLog, callback) {
-        return (fPath, value) => {
-            callback(new Promise((res, rej) => {
-                tLog("testArtiFactory =>", fPath);
-                // const cleanPath = path.resolve(fPath);
-                // fPaths.push(cleanPath.replace(process.cwd(), ``));
-                // const targetDir = cleanPath.split("/").slice(0, -1).join("/");
-                // fs.mkdir(targetDir, { recursive: true }, async (error) => {
-                //   if (error) {
-                //     console.error(`❗️testArtiFactory failed`, targetDir, error);
-                //   }
-                //   fs.writeFileSync(
-                //     path.resolve(
-                //       targetDir.split("/").slice(0, -1).join("/"),
-                //       "manifest"
-                //     ),
-                //     fPaths.join(`\n`),
-                //     {
-                //       encoding: "utf-8",
-                //     }
-                //   );
-                //   if (Buffer.isBuffer(value)) {
-                //     fs.writeFileSync(fPath, value, "binary");
-                //     res();
-                //   } else if (`string` === typeof value) {
-                //     fs.writeFileSync(fPath, value.toString(), {
-                //       encoding: "utf-8",
-                //     });
-                //     res();
-                //   } else {
-                //     /* @ts-ignore:next-line */
-                //     const pipeStream: PassThrough = value;
-                //     const myFile = fs.createWriteStream(fPath);
-                //     pipeStream.pipe(myFile);
-                //     pipeStream.on("close", () => {
-                //       myFile.close();
-                //       res();
-                //     });
-                //   }
-                // });
-            }));
-        };
-    }
-}

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

@@ -1,16 +0,0 @@
-import React from "react";
-import Testeranto from "../Node.js";
-export default (testInput, testSpecifications, testImplementations, testInterface) => {
-    return Testeranto(testInput, testSpecifications, testImplementations, Object.assign({ beforeAll: (x) => {
-            // process.parentPort.postMessage(
-            //   `/docs/web/src/ClassicalComponent/test.html`
-            // );
-            return x;
-        }, beforeEach: async () => {
-            return new Promise((resolve, rej) => {
-                resolve(React.createElement(testInput, {}, []));
-            });
-        }, andWhen: function (s, whenCB) {
-            return whenCB()(s);
-        } }, testInterface));
-};

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

@@ -1,14 +0,0 @@
-import React from "react";
-import Testeranto from "../../../Node.js";
-export default (testImplementations, testSpecifications, testInput) => {
-    return Testeranto(testInput, testSpecifications, testImplementations, {
-        beforeEach: async () => {
-            return new Promise((resolve, rej) => {
-                resolve(React.createElement(testInput, {}, []));
-            });
-        },
-        andWhen: function (s, whenCB) {
-            return whenCB()(s);
-        },
-    });
-};

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

@@ -1,14 +0,0 @@
-import React from "react";
-import Testeranto from "../../../Web.js";
-export default (testImplementations, testSpecifications, testInput) => {
-    return Testeranto(testInput, testSpecifications, testImplementations, {
-        beforeEach: async () => {
-            return new Promise((resolve, rej) => {
-                resolve(React.createElement(testInput, {}, []));
-            });
-        },
-        andWhen: function (s, whenCB) {
-            return whenCB()(s);
-        },
-    });
-};

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

@@ -1,27 +0,0 @@
-import React from "react";
-export const testInterface = {
-    // beforeAll: async (proto, testResource, artificer, pm): Promise<IStore> => {
-    //   return React.createElement(proto);
-    //   // return new Promise((resolve, rej) => {
-    //   //   resolve(x());
-    //   // });
-    // },
-    // 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) => {
-            resolve(React.createElement(s));
-        });
-        // 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 +0,0 @@
-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);
-};

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

@@ -1,5 +0,0 @@
-import Testeranto from "../../../Web.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));
-};

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

@@ -1,93 +0,0 @@
-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, {
-        // 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) => {
-            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) {
-            return {};
-        },
-        afterAll: (store, artificer) => {
-            return;
-        },
-    });
-};
-// type IInput = typeof React.Component;
-// type InitialState = unknown;
-// type IWhenShape = any;
-// type IThenShape = any;
-// type ISelection = string;
-// type IStore = string;
-// type ISubject = string
-// export default <ITestShape extends ITTestShape>(
-//   testImplementations: ITestImplementation<
-//     InitialState,
-//     ISelection,
-//     IWhenShape,
-//     IThenShape,
-//     ITestShape
-//   >,
-//   testSpecifications: ITestSpecification<
-//     ITestShape,
-//     ISubject,
-//     IStore,
-//     ISelection,
-//     IThenShape
-//   >,
-//   testInput: IInput
-// ) => {
-//   return Testeranto<
-//     ITestShape,
-//     IInput,
-//     ISubject,
-//     IStore,
-//     ISelection,
-//     IThenShape,
-//     IWhenShape,
-//     InitialState
-//   >(
-//     testInput,
-//     testSpecifications,
-//     testImplementations,
-//     {
-//       beforeEach: async (
-//         element,
-//         ndx,
-//         testResource,
-//         artificer
-//       ): Promise<IStore> => {
-//         return new Promise((resolve, rej) => {
-//           resolve(ReactDOMServer.renderToStaticMarkup(element));
-//         });
-//       },
-//       andWhen: function (s: IStore, whenCB): Promise<ISelection> {
-//         throw new Error(`"andWhens" are not permitted`);
-//       }
-//     },
-//   )
-// };

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

@@ -1,62 +0,0 @@
-import { createElement } from "react";
-import ReactDom from "react-dom/client";
-import Testeranto from "../../../Web.js";
-export default (testInput, testSpecifications, testImplementations, testInterface) => {
-    class TesterantoComponent extends testInput {
-        constructor(props) {
-            super(props);
-            this.done = props.done;
-        }
-        componentDidMount() {
-            super.componentDidMount && super.componentDidMount();
-            return this.done(this);
-        }
-    }
-    const t = Testeranto(testInput, testSpecifications, testImplementations, {
-        beforeAll: async (subject, artificer) => {
-            return await new Promise((resolve, rej) => {
-                const htmlElement = document.getElementById("root");
-                if (htmlElement) {
-                    const domRoot = ReactDom.createRoot(htmlElement);
-                    resolve({ domRoot, htmlElement });
-                }
-            });
-        },
-        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);
-        },
-        butThen: async function (s, thenCB) {
-            return thenCB(s);
-        },
-        afterEach: (testInterface === null || testInterface === void 0 ? void 0 : testInterface.afterEach) ||
-            async function (store, ndx, artificer, utils) {
-                return store;
-            },
-        afterAll: async (store, artificer, utils) => {
-            // setTimeout(() => {
-            //   console.log("This will run after 1 second");
-            // }, 1000); // 1000 milliseconds = 1 second
-            // store.htmlElement.remove();
-            // store.htmlElement = document.createElement("root");
-            return store;
-        },
-    });
-    document.addEventListener("DOMContentLoaded", function () {
-        const elem = document.getElementById("root");
-        if (elem) {
-            return t;
-        }
-    });
-    return t;
-};

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

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

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

@@ -1,31 +0,0 @@
-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, {
-        beforeAll: async (prototype, artificer) => {
-            return await new Promise((resolve, rej) => {
-                resolve(null);
-            });
-        },
-        beforeEach: async (reactComponent, ndx, testRsource, artificer) => {
-            return new Promise((resolve, rej) => {
-                resolve(createElement(testInput));
-            });
-        },
-        andWhen: async function (s, whenCB) {
-            return s;
-        },
-        butThen: async function (s) {
-            return s;
-        },
-        afterEach: async function (store, ndx, artificer) {
-            return {};
-        },
-        afterAll: (store, artificer) => {
-            return;
-        },
-    });
-};

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

@@ -1,89 +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, initializer, artificer, testResource, pm) => {
-            return new Promise((resolve, rej) => {
-                resolve(subject);
-                // const tc = TesterantoComponent({
-                //   innerComp: () =>
-                //     testInput({
-                //       port: 3003,
-                //       address: "some-address",
-                //       secretKey: "someSecretKey",
-                //       abi: "foo",
-                //     }),
-                //   done: (reactElement: any) => {
-                //     console.log("mark9");
-                //     resolve(reactElement);
-                //     // process.nextTick(() => {
-                //     //   resolve(reactElement);
-                //     // });
-                //   },
-                // });
-                // console.log("mark9", tc);
-                // createPortal(tc, subject.domRoot);
-            });
-        },
-        andWhen: function (s, whenCB, tr, utils) {
-            return 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/src/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/src/SubPackages/react-test-renderer/component/index.js

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

package/dist/module/src/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/src/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/src/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);