testeranto 0.74.0 → 0.79.3

package/dist/common/utils.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.destinationOfRuntime = void 0;
+// import { configs } from "eslint-plugin-react";
+const path_1 = __importDefault(require("path"));
+const destinationOfRuntime = (f, r, configs) => {
+    return path_1.default
+        .normalize(`${configs.buildDir}/${r}/${f}`)
+        .split(".")
+        .slice(0, -1)
+        .join(".");
+};
+exports.destinationOfRuntime = destinationOfRuntime;

package/dist/module/ExampleTab.js

@@ -0,0 +1,112 @@
+import React, { useEffect, useState } from "react";
+import Col from 'react-bootstrap/Col';
+import Nav from 'react-bootstrap/Nav';
+import Row from 'react-bootstrap/Row';
+import Tab from 'react-bootstrap/Tab';
+import Tabs from 'react-bootstrap/Tabs';
+import 'bootstrap/dist/css/bootstrap.min.css';
+const queryString = window.location.search;
+// Create a URLSearchParams object
+const urlParams = new URLSearchParams(queryString);
+console.log("urlParams", urlParams.has("local"));
+// Get the value of a specific parameter
+const isLocal = urlParams.get("local");
+const urlFixer = (url) => {
+    if (isLocal) {
+        return `file:///Users/adam/Code/kokomoBay/${url}`;
+    }
+    else {
+        return `https://chromapdx.github.io/kokomoBay/${url}`;
+    }
+};
+const TextTab = (props) => {
+    const [text, setText] = useState('');
+    useEffect(() => {
+        fetch(props.url) // Replace with your API endpoint
+            .then(response => response.text())
+            .then(data => setText(data))
+            .catch(error => console.error('Error fetching text:', error));
+    }, []);
+    return React.createElement("code", null,
+        React.createElement("pre", null, text));
+};
+export default () => {
+    return (React.createElement(Tab.Container, { id: "left-tabs-example5", defaultActiveKey: "examples-0" },
+        React.createElement(Row, null,
+            React.createElement(Col, { sm: 3, lg: 2 },
+                React.createElement(Nav, { variant: "pills", className: "flex-column" },
+                    React.createElement(Nav.Link, { eventKey: `manual-example-rectangle` }, "RECTANGLE"),
+                    React.createElement(Nav.Link, { eventKey: `manual-example-ClassicalComponent` }, "ClassicalComponent"),
+                    React.createElement(Nav.Link, { eventKey: `manual-example-react+sol` }, "React and solidity"))),
+            React.createElement(Col, { sm: 3, lg: 2 },
+                React.createElement(Tab.Content, null,
+                    React.createElement(Tab.Pane, { eventKey: `manual-example-rectangle`, key: `manual-example-rectangle` },
+                        React.createElement("pre", null, "In this contrived example, we are testing the Rectangle class. Node that because it uses no web-specific, nor node-specific language features, it can be run in either runtime, thought it more efficient and reasonable to test in node.")),
+                    React.createElement(Tab.Pane, { eventKey: `manual-example-ClassicalComponent`, key: `manual-example-ClassicalComponent` },
+                        React.createElement("pre", null, "Testing a react component with the react-test-renderer package.")),
+                    React.createElement(Tab.Pane, { eventKey: `manual-example-react+sol`, key: `manual-example-react+sol` },
+                        React.createElement("pre", null, "Testing a react component which is backed by a solidity contract. This test is performed _on_ the server but but _through_ the browser. The react element is renderer into an chromium window and accessed by puppeteer.")))),
+            React.createElement(Col, null,
+                React.createElement(Tab.Content, null,
+                    React.createElement(Tab.Pane, { eventKey: `manual-example-rectangle`, key: `manual-example-rectangle` },
+                        React.createElement(Tabs, { defaultActiveKey: "profile", id: "uncontrolled-tab-example", className: "mb-3" },
+                            React.createElement(Tab, { eventKey: "Rectangle.ts", title: "Rectangle.ts" },
+                                React.createElement(TextTab, { url: urlFixer("src/Rectangle.ts") })),
+                            React.createElement(Tab, { eventKey: "Rectangle.test.specification.ts", title: "Rectangle.test.specification.ts" },
+                                React.createElement(TextTab, { url: urlFixer("src/Rectangle.test.specification.ts") })),
+                            React.createElement(Tab, { eventKey: "Rectangle.test.shape.ts", title: "Rectangle.test.shape.ts" },
+                                React.createElement(TextTab, { url: urlFixer("src/Rectangle.test.shape.ts") })),
+                            React.createElement(Tab, { eventKey: "Rectangle.test.implementation.ts", title: "Rectangle.test.implementation.ts" },
+                                React.createElement(TextTab, { url: urlFixer("src/Rectangle.test.implementation.ts") })),
+                            React.createElement(Tab, { eventKey: "Rectangle.test.interface.ts", title: "Rectangle.test.interface.ts" },
+                                React.createElement(TextTab, { url: urlFixer("src/Rectangle.test.interface.ts") })),
+                            React.createElement(Tab, { eventKey: "Rectangle.config", title: "Rectangle.config" },
+                                React.createElement("code", null,
+                                    React.createElement("pre", null, `
+...
+
+// Run the test in node
+"./src/Rectangle/Rectangle.test.node.ts",
+"node",
+{ ports: 0 },
+[],
+],
+
+// Run the same test in chromium too!
+"./src/Rectangle/Rectangle.test.web.ts",
+"web",
+{ ports: 0 },
+[],
+],
+
+...
+              `))))),
+                    React.createElement(Tab.Pane, { eventKey: `manual-example-ClassicalComponent`, key: `manual-example-ClassicalComponent` },
+                        React.createElement(Tabs, { defaultActiveKey: "profile", id: "uncontrolled-tab-example", className: "mb-3" },
+                            React.createElement(Tab, { eventKey: "ClassicalComponent/index.tsx", title: "ClassicalComponent/index.tsx" },
+                                React.createElement(TextTab, { url: urlFixer("src/ClassicalComponent/index.tsx") })),
+                            React.createElement(Tab, { eventKey: "ClassicalComponent/test.specification.ts", title: "ClassicalComponent/test.specification.ts" },
+                                React.createElement(TextTab, { url: urlFixer("src/ClassicalComponent/test.specification.ts") })),
+                            React.createElement(Tab, { eventKey: "ClassicalComponent/test.shape.ts", title: "ClassicalComponent/test.shape.ts" },
+                                React.createElement(TextTab, { url: urlFixer("src/ClassicalComponent/test.shape.ts") })),
+                            React.createElement(Tab, { eventKey: "ClassicalComponent/react-test-renderer/test.implementation.ts", title: "ClassicalComponent/react-test-renderer/test.implementation.ts" },
+                                React.createElement(TextTab, { url: urlFixer("src/ClassicalComponent/react-test-renderer/test.implementation.ts") })),
+                            React.createElement(Tab, { eventKey: "react-test-renderer/test.interface.ts", title: "react-test-renderer/test.interface.ts" },
+                                React.createElement(TextTab, { url: "https://raw.githubusercontent.com/adamwong246/testeranto/master/src/subPackages/react-test-renderer/component/interface.ts" })))),
+                    React.createElement(Tab.Pane, { eventKey: `manual-example-react+sol`, key: `manual-example-react+sol` },
+                        React.createElement(Tabs, { defaultActiveKey: "profile", id: "uncontrolled-tab-example", className: "mb-3" },
+                            React.createElement(Tab, { eventKey: "contracts/MyBaseContract.sol", title: "MyBaseContract.sol" },
+                                React.createElement(TextTab, { url: urlFixer("contracts/MyBaseContract.sol") })),
+                            React.createElement(Tab, { eventKey: "src/MyFirstContractUI.tsx", title: "MyFirstContractUI.tsx" },
+                                React.createElement(TextTab, { url: urlFixer("src/MyFirstContractUI.tsx") })),
+                            React.createElement(Tab, { eventKey: "src/MyFirstContract.specification.test.ts", title: "MyFirstContract.specification.test.ts" },
+                                React.createElement(TextTab, { url: urlFixer("src/MyFirstContract.specification.test.ts") })),
+                            React.createElement(Tab, { eventKey: "src/MyFirstContract.solidity-react.interface.test.ts", title: "MyFirstContract.solidity-react.interface.test.ts" },
+                                React.createElement(TextTab, { url: urlFixer("src/MyFirstContract.solidity-react.interface.test.ts") })),
+                            React.createElement(Tab, { eventKey: "src/MyFirstContract.solidity-react.implementation.test.ts", title: "MyFirstContract.solidity-react.implementation.test.ts" },
+                                React.createElement(TextTab, { url: urlFixer("src/MyFirstContract.solidity-react.implementation.test.ts") })),
+                            React.createElement(Tab, { eventKey: "src/MyFirstContract.solidity-react.shape.test.ts", title: "MyFirstContract.solidity-react.shape.test.ts" },
+                                React.createElement(TextTab, { url: urlFixer("src/MyFirstContract.solidity-react.shape.test.ts") })),
+                            React.createElement(Tab, { eventKey: "MyFirstContract.solidity-react-example-jpg", title: "screenshot" },
+                                React.createElement("img", { src: urlFixer("docs/node/src/MyFirstContract.solidity-react.testeranto/suite-0/given-test1/when/0/afterEach/andWhen.jpg") })))))))));
+};

package/dist/module/Node.js

@@ -7,6 +7,7 @@ class NodeTesteranto extends Testeranto {
     }
     async receiveTestResourceConfig(partialTestResource) {
         const t = JSON.parse(partialTestResource);
+        console.log("receiveTestResourceConfig", t);
         const pm = new PM_Node(t);
         const { failed, artifacts, logPromise } = await this.testJobs[0].receiveTestResourceConfig(pm);
         pm.customclose();

package/dist/module/PM/index.js

@@ -1,67 +1,3 @@
-// import {
-//   Browser,
-//   BrowserContext,
-//   BrowserContextOptions,
-//   DebugInfo,
-//   Page,
-//   PuppeteerNode,
-//   Target,
-// } from "puppeteer-core";
 const fPaths = [];
 export class PM {
 }
-// export class PuppetMasterBrowser extends Browser {
-//   process(): ChildProcess | null {
-//     return super.process();
-//   }
-//   createBrowserContext(
-//     options?: BrowserContextOptions
-//   ): Promise<BrowserContext> {
-//     throw new Error("Method not implemented.");
-//   }
-//   browserContexts(): BrowserContext[] {
-//     throw new Error("Method not implemented.");
-//   }
-//   defaultBrowserContext(): BrowserContext {
-//     throw new Error("Method not implemented.");
-//   }
-//   wsEndpoint(): string {
-//     throw new Error("Method not implemented.");
-//   }
-//   newPage(): Promise<Page> {
-//     throw new Error("Method not implemented.");
-//   }
-//   targets(): Target[] {
-//     throw new Error("Method not implemented.");
-//   }
-//   target(): Target {
-//     throw new Error("Method not implemented.");
-//   }
-//   version(): Promise<string> {
-//     throw new Error("Method not implemented.");
-//   }
-//   userAgent(): Promise<string> {
-//     throw new Error("Method not implemented.");
-//   }
-//   close(): Promise<void> {
-//     throw new Error("Method not implemented.");
-//   }
-//   disconnect(): Promise<void> {
-//     throw new Error("Method not implemented.");
-//   }
-//   get connected(): boolean {
-//     throw new Error("Method not implemented.");
-//   }
-//   get debugInfo(): DebugInfo {
-//     throw new Error("Method not implemented.");
-//   }
-//   constructor(...z: []) {
-//     super(...z);
-//   }
-//   // pages(): Promise<Page[]>;
-//   pages(): Promise<Page[]> {
-//     return new Promise<Page[]>((res, rej) => {
-//       res(super.pages());
-//     });
-//   }
-// }

package/dist/module/PM/main.js

@@ -2,6 +2,7 @@ import fs from "fs";
 import path from "path";
 import puppeteer from "puppeteer-core";
 import { PM } from "./index.js";
+import { destinationOfRuntime } from "../utils.js";
 const fPaths = [];
 const fileStreams3 = [];
 const files = {}; // = new Set<string>();
@@ -33,6 +34,7 @@ export class PM_Main extends PM {
             }
             else if (testConfigResource.ports > 0) {
                 const openPorts = Object.entries(this.ports).filter(([portnumber, portopen]) => portopen);
+                console.log("openPorts", openPorts);
                 if (openPorts.length >= testConfigResource.ports) {
                     for (let i = 0; i < testConfigResource.ports; i++) {
                         portsToUse.push(openPorts[i][0]);
@@ -43,7 +45,7 @@ export class PM_Main extends PM {
                         name: src,
                         // ports: [3333],
                         ports: portsToUse,
-                        fs: ".",
+                        fs: destFolder,
                         browserWSEndpoint: this.browser.wsEndpoint(),
                     });
                 }
@@ -57,6 +59,14 @@ export class PM_Main extends PM {
                 process.exit(-1);
             }
             const builtfile = dest + ".mjs";
+            await Promise.all(testConfig[3].map((sidecar) => {
+                if (sidecar[1] === "web") {
+                    return this.launchWebSideCar(sidecar[0], destinationOfRuntime(sidecar[0], "web", this.configs), sidecar);
+                }
+                if (sidecar[1] === "node") {
+                    return this.launchNodeSideCar(sidecar[0], destinationOfRuntime(sidecar[0], "node", this.configs), sidecar);
+                }
+            }));
             this.server[builtfile] = await import(`${builtfile}?cacheBust=${Date.now()}`).then((module) => {
                 return module.default.then((defaultModule) => {
                     defaultModule
@@ -70,12 +80,231 @@ export class PM_Main extends PM {
                     });
                 });
             });
+            console.log("portsToUse", portsToUse);
+            for (let i = 0; i <= portsToUse.length; i++) {
+                if (portsToUse[i]) {
+                    this.ports[portsToUse[i]] = "true"; //port is open again
+                }
+            }
+        };
+        this.launchWebSideCar = async (src, dest, testConfig) => {
+            const d = dest + ".mjs";
+            console.log("launchWebSideCar", src, dest, d);
+            const destFolder = dest.replace(".mjs", "");
+            const webArgz = JSON.stringify({
+                name: dest,
+                ports: [].toString(),
+                fs: destFolder,
+                browserWSEndpoint: this.browser.wsEndpoint(),
+            });
+            const evaluation = `
+    console.log("importing ${dest}.mjs");
+    import('${dest}.mjs').then(async (x) => {
+      console.log("imported", x.default);
+    })`;
+            const fileStreams2 = [];
+            const doneFileStream2 = [];
+            return new Promise((res, rej) => {
+                this.browser
+                    .newPage()
+                    .then((page) => {
+                    page.on("console", (msg) => {
+                        console.log("web > ", msg.args(), msg.text());
+                        // for (let i = 0; i < msg._args.length; ++i)
+                        //   console.log(`${i}: ${msg._args[i]}`);
+                    });
+                    page.exposeFunction("custom-screenshot", async (ssOpts, testName) => {
+                        console.log("main.ts browser custom-screenshot", testName);
+                        const p = ssOpts.path;
+                        const dir = path.dirname(p);
+                        fs.mkdirSync(dir, {
+                            recursive: true,
+                        });
+                        files[testName].add(ssOpts.path);
+                        const sPromise = page.screenshot(Object.assign(Object.assign({}, ssOpts), { path: p }));
+                        if (!screenshots[testName]) {
+                            screenshots[testName] = [];
+                        }
+                        screenshots[testName].push(sPromise);
+                        // sPromise.then(())
+                        await sPromise;
+                        return sPromise;
+                        // page.evaluate(`window["screenshot done"]`);
+                    });
+                    page.exposeFunction("writeFileSync", (fp, contents, testName) => {
+                        const dir = path.dirname(fp);
+                        fs.mkdirSync(dir, {
+                            recursive: true,
+                        });
+                        const p = new Promise(async (res, rej) => {
+                            fs.writeFileSync(fp, contents);
+                            res(fp);
+                        });
+                        doneFileStream2.push(p);
+                        if (!files[testName]) {
+                            files[testName] = new Set();
+                        }
+                        files[testName].add(fp);
+                        return p;
+                    });
+                    page.exposeFunction("existsSync", (fp, contents) => {
+                        return fs.existsSync(fp);
+                    });
+                    page.exposeFunction("mkdirSync", (fp) => {
+                        if (!fs.existsSync(fp)) {
+                            return fs.mkdirSync(fp, {
+                                recursive: true,
+                            });
+                        }
+                        return false;
+                    });
+                    page.exposeFunction("createWriteStream", (fp, testName) => {
+                        const f = fs.createWriteStream(fp);
+                        if (!files[testName]) {
+                            files[testName] = new Set();
+                        }
+                        files[testName].add(fp);
+                        const p = new Promise((res, rej) => {
+                            res(fp);
+                        });
+                        doneFileStream2.push(p);
+                        f.on("close", async () => {
+                            await p;
+                        });
+                        fileStreams2.push(f);
+                        return Object.assign(Object.assign({}, JSON.parse(JSON.stringify(f))), { uid: fileStreams2.length - 1 });
+                    });
+                    page.exposeFunction("write", async (uid, contents) => {
+                        return fileStreams2[uid].write(contents);
+                    });
+                    page.exposeFunction("end", async (uid) => {
+                        return fileStreams2[uid].end();
+                    });
+                    page.exposeFunction("customclose", (p, testName) => {
+                        fs.writeFileSync(p + "/manifest.json", JSON.stringify(Array.from(files[testName])));
+                        delete files[testName];
+                        Promise.all(screenshots[testName] || []).then(() => {
+                            delete screenshots[testName];
+                            page.close();
+                        });
+                        // globalThis["writeFileSync"](
+                        //   p + "/manifest.json",
+                        //   // files.entries()
+                        //   JSON.stringify(Array.from(files[testName]))
+                        // );
+                        // console.log("closing doneFileStream2", doneFileStream2);
+                        // console.log("closing doneFileStream2", doneFileStream2);
+                        // Promise.all([...doneFileStream2, ...screenshots2]).then(() => {
+                        //   page.close();
+                        // });
+                        // Promise.all(screenshots).then(() => {
+                        //   page.close();
+                        // });
+                        // setTimeout(() => {
+                        //   console.log("Delayed for 1 second.");
+                        //   page.close();
+                        // }, 5000);
+                        // return page.close();
+                    });
+                    return page;
+                })
+                    .then(async (page) => {
+                    page.on("console", (log) => console.debug(`Log from client: [${log.text()}] `));
+                    await page.goto(`file://${`${dest}.html`}`, {});
+                    res(page);
+                    // page.evaluate(evaluation).finally(() => {
+                    //   console.log("evaluation failed.", dest);
+                    // });
+                    // return page;
+                });
+            });
+        };
+        // launchNodeSideCar = async (src: string, dest: string) => {};
+        this.launchNodeSideCar = async (src, dest, testConfig) => {
+            const d = dest + ".mjs";
+            console.log("launchNodeSideCar", src, dest, d);
+            const destFolder = dest.replace(".mjs", "");
+            let argz = "";
+            // const testConfig = this.configs.tests.find((t) => {
+            //   return t[0] === src;
+            // });
+            // if (!testConfig) {
+            //   console.error("missing test config");
+            //   process.exit(-1);
+            // }
+            const testConfigResource = testConfig[2];
+            let portsToUse = [];
+            if (testConfigResource.ports === 0) {
+                argz = JSON.stringify({
+                    scheduled: true,
+                    name: src,
+                    ports: portsToUse,
+                    fs: destFolder,
+                    browserWSEndpoint: this.browser.wsEndpoint(),
+                });
+            }
+            else if (testConfigResource.ports > 0) {
+                const openPorts = Object.entries(this.ports).filter(([portnumber, portopen]) => portopen);
+                console.log("openPorts", openPorts);
+                if (openPorts.length >= testConfigResource.ports) {
+                    for (let i = 0; i < testConfigResource.ports; i++) {
+                        portsToUse.push(openPorts[i][0]);
+                        this.ports[openPorts[i][0]] = false; // port is now closed
+                    }
+                    argz = JSON.stringify({
+                        scheduled: true,
+                        name: src,
+                        // ports: [3333],
+                        ports: portsToUse,
+                        fs: ".",
+                        browserWSEndpoint: this.browser.wsEndpoint(),
+                    });
+                }
+                else {
+                    this.queue.push(src);
+                    return;
+                }
+            }
+            else {
+                console.error("negative port makes no sense", src);
+                process.exit(-1);
+            }
+            const builtfile = dest + ".mjs";
+            // console.log(
+            //   "node builtfile",
+            //   (await import(`${builtfile}?cacheBust=${Date.now()}`)).default
+            // );
+            this.server[builtfile] = await import(`${builtfile}?cacheBust=${Date.now()}`).then((module) => {
+                return module.default.then((defaultModule) => {
+                    console.log("defaultModule", defaultModule);
+                    const s = new defaultModule();
+                    s.receiveTestResourceConfig(argz);
+                    // Object.create(defaultModule);
+                    // defaultModule
+                    //   .receiveTestResourceConfig(argz)
+                    //   .then((x) => {
+                    //     console.log("then", x);
+                    //     return x;
+                    //   })
+                    //   .catch((e) => {
+                    //     console.log("catch", e);
+                    //   });
+                });
+            });
+            console.log("portsToUse", portsToUse);
             for (let i = 0; i <= portsToUse.length; i++) {
-                this.ports[i] = true; //port is open again
+                if (portsToUse[i]) {
+                    this.ports[portsToUse[i]] = "true"; //port is open again
+                }
             }
         };
-        this.launchWeb = (t, dest) => {
+        this.launchWeb = (t, dest, sidecars) => {
             console.log("launchWeb", t, dest);
+            sidecars.map((sidecar) => {
+                if (sidecar[1] === "node") {
+                    return this.launchNodeSideCar(sidecar[0], destinationOfRuntime(sidecar[0], "node", this.configs), sidecar);
+                }
+            });
             const destFolder = dest.replace(".mjs", "");
             const webArgz = JSON.stringify({
                 name: dest,
@@ -83,8 +312,10 @@ export class PM_Main extends PM {
                 fs: destFolder,
                 browserWSEndpoint: this.browser.wsEndpoint(),
             });
-            const evaluation = `import('${dest}.mjs').then(async (x) => {
-      console.log("imported", x, (x.default));
+            const evaluation = `
+    console.log("importing ${dest}.mjs");
+    import('${dest}.mjs').then(async (x) => {
+      console.log("imported", x.default);
       try {
         await (await x.default).receiveTestResourceConfig(${webArgz})
       } catch (e) {
@@ -92,18 +323,25 @@ export class PM_Main extends PM {
       }
     })`;
             const fileStreams2 = [];
-            // const screenshots2: Promise<any>[] = [];
             const doneFileStream2 = [];
             this.browser
                 .newPage()
                 .then((page) => {
-                page.exposeFunction("custom-screenshot", async (ssOpts, testName) => {
+                page.on("console", (msg) => {
+                    console.log("web > ", msg.args(), msg.text());
+                    // for (let i = 0; i < msg._args.length; ++i)
+                    //   console.log(`${i}: ${msg._args[i]}`);
+                });
+                page.exposeFunction("customScreenShot", async (ssOpts, testName) => {
                     console.log("main.ts browser custom-screenshot", testName);
                     const p = ssOpts.path;
                     const dir = path.dirname(p);
                     fs.mkdirSync(dir, {
                         recursive: true,
                     });
+                    if (!files[testName]) {
+                        files[testName] = new Set();
+                    }
                     files[testName].add(ssOpts.path);
                     const sPromise = page.screenshot(Object.assign(Object.assign({}, ssOpts), { path: p }));
                     if (!screenshots[testName]) {
@@ -165,6 +403,7 @@ export class PM_Main extends PM {
                     return fileStreams2[uid].end();
                 });
                 page.exposeFunction("customclose", (p, testName) => {
+                    console.log("\t closing", p);
                     fs.writeFileSync(p + "/manifest.json", JSON.stringify(Array.from(files[testName])));
                     delete files[testName];
                     Promise.all(screenshots[testName] || []).then(() => {
@@ -193,6 +432,7 @@ export class PM_Main extends PM {
                 return page;
             })
                 .then(async (page) => {
+                page.on("console", (log) => console.debug(`Log from client: [${log.text()}] `));
                 await page.goto(`file://${`${dest}.html`}`, {});
                 page.evaluate(evaluation).finally(() => {
                     console.log("evaluation failed.", dest);
@@ -215,6 +455,7 @@ export class PM_Main extends PM {
             return false;
         };
         globalThis["writeFileSync"] = (filepath, contents, testName) => {
+            console.log("globalThis-writeFileSync", filepath);
             // Create directories if they don't exist
             const dir = path.dirname(filepath.split("/").slice(0, -1).join("/"));
             fs.mkdirSync(dir, {
@@ -242,6 +483,33 @@ export class PM_Main extends PM {
         globalThis["end"] = (uid) => {
             fileStreams3[uid].end();
         };
+        globalThis["customScreenShot"] = async (opts, page) => {
+            // // fileStreams3[uid].write(contents);
+            // // console.log("asd", opts.path.split("/").slice(0, -1).join("/"));
+            // // const dir = path.dirname(opts.path.split("/").slice(0, -1).join("/"));
+            // // console.log("dir", dir);
+            // fs.mkdirSync(opts.path.split("/").slice(0, -1).join("/"), {
+            //   recursive: true,
+            // });
+            // return page.screenshot(opts);
+            console.log("main.ts node custom-screenshot", page);
+            const p = opts.path;
+            const dir = path.dirname(p);
+            fs.mkdirSync(dir, {
+                recursive: true,
+            });
+            if (!files[opts.path]) {
+                files[opts.path] = new Set();
+            }
+            files[opts.path].add(opts.path);
+            const sPromise = page.screenshot(Object.assign(Object.assign({}, opts), { path: p }));
+            if (!screenshots[opts.path]) {
+                screenshots[opts.path] = [];
+            }
+            screenshots[opts.path].push(sPromise);
+            await sPromise;
+            return sPromise;
+        };
         globalThis["customclose"] = (p, testName) => {
             if (!files[testName]) {
                 files[testName] = new Set();
@@ -272,6 +540,9 @@ export class PM_Main extends PM {
         //   // return page.close();
         // });
     }
+    customScreenShot(opts) {
+        throw new Error("Method not implemented.");
+    }
     async startPuppeteer(options, destfolder) {
         this.browser = await puppeteer.launch(options);
         return this.browser;

package/dist/module/PM/node.js

@@ -9,6 +9,9 @@ export class PM_Node extends PM {
         this.server = {};
         this.testResourceConfiguration = t;
     }
+    customScreenShot(opts, page) {
+        return globalThis["customScreenShot"](opts, page);
+    }
     existsSync(destFolder) {
         return globalThis["existsSync"](this.testResourceConfiguration.fs + "/" + destFolder);
     }
@@ -19,6 +22,7 @@ export class PM_Node extends PM {
         return globalThis["write"](writeObject.uid, contents);
     }
     writeFileSync(filepath, contents) {
+        console.log("pm_node-writeFileSync", this.testResourceConfiguration);
         return globalThis["writeFileSync"](this.testResourceConfiguration.fs + "/" + filepath, contents, this.testResourceConfiguration.name);
     }
     createWriteStream(filepath) {

package/dist/module/PM/web.js

@@ -6,6 +6,9 @@ export class PM_Web extends PM {
         this.server = {};
         this.testResourceConfiguration = t;
     }
+    customScreenShot(opts) {
+        window["customScreenShot"](opts);
+    }
     existsSync(destFolder) {
         return window["existsSync"](destFolder);
     }

package/dist/module/Project.js

@@ -70,6 +70,9 @@ export class ITProject {
                 .then((x) => fs.writeFileSync(htmlFilePath, webHtmlFrame(jsfilePath, htmlFilePath)));
         })));
         const [nodeEntryPoints, webEntryPoints] = getRunnables(this.config.tests);
+        console.log(`this.getSecondaryEndpointsPoints("web")`, this.getSecondaryEndpointsPoints("web"));
+        // console.log("nodeEntryPoints", nodeEntryPoints);
+        // console.log("webEntryPoints", webEntryPoints);
         // nodeEntryPoints.forEach((nep) => {
         //   const f = `${process.cwd()}/${nep}`;
         //   console.log("nep", f);
@@ -147,11 +150,12 @@ export class ITProject {
     getSecondaryEndpointsPoints(runtime) {
         const meta = (ts, st) => {
             ts.forEach((t) => {
+                console.log("getSecondaryEndpointsPoints", t);
                 if (t[1] === runtime) {
                     st.add(t[0]);
                 }
-                if (Array.isArray(t[2])) {
-                    meta(t[2], st);
+                if (Array.isArray(t[3])) {
+                    meta(t[3], st);
                 }
             });
             return st;