testeranto 0.85.0 → 0.90.0

package/README.md

@@ -12,9 +12,7 @@ example repo: [kokomo bay](https://github.com/ChromaPDX/kokomoBay)
 
 ## Demo
 
-<div align="center">
-  <a href="https://www.youtube.com/watch?v=WvU5xMqGi6Q"><img src="https://img.youtube.com/vi/WvU5xMqGi6Q/0.jpg" alt="IMAGE ALT TEXT"></a>
-</div>
+<iframe width="560" height="315" src="https://www.youtube.com/embed/WvU5xMqGi6Q" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
 
 ## What is testeranto?
 

package/bin/init-docs.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import fs from "fs";
+import Init from "../dist/module/src/Init";
+console.log("Initializing a testeranto project");
+
+
+
+if (!process.argv[2]) {
+    console.log("You didn't pass a config file, so I will create one for you.")
+
+
+    fs.writeFileSync("testeranto.mts", fs.readFileSync("node_modules/testeranto/src/defaultConfig.ts"))
+    import(process.cwd() + "/" + "testeranto.mts").then((module) => {
+        Init(module.default);
+    });
+
+
+}
+else {
+    import(process.cwd() + "/" + process.argv[2]).then((module) => {
+        Init(module.default);
+    });
+
+}

package/bundle.js

@@ -0,0 +1,53 @@
+import * as esbuild from 'esbuild'
+
+await esbuild.build({
+  entryPoints: ['src/init-docs.ts'],
+  bundle: true,
+  format: "esm",
+  platform: "node",
+  // format: "node",
+  outfile: 'dist/prebuild/init-docs.mjs',
+  // external: ['crypto', 'os'],
+  supported: {
+    "dynamic-import": true,
+  },
+
+  banner: {
+    js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`,
+  },
+})
+
+await esbuild.build({
+  entryPoints: ['src/build-tests.ts'],
+  bundle: true,
+  format: "esm",
+  platform: "node",
+  // format: "node",
+  outfile: 'dist/prebuild/build-tests.mjs',
+  // external: ['crypto', 'os'],
+  packages: "external",
+  supported: {
+    "dynamic-import": true,
+  },
+
+  banner: {
+    js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`,
+  },
+})
+
+await esbuild.build({
+  entryPoints: ['src/run-tests.ts'],
+  bundle: true,
+  format: "esm",
+  platform: "node",
+  // format: "node",
+  outfile: 'dist/prebuild/run-tests.mjs',
+  packages: "external",
+  supported: {
+    "dynamic-import": true,
+  },
+
+  banner: {
+    js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`,
+  },
+})

package/dist/common/dist/module/src/Init.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+exports.default = async (partialConfig) => {
+    const config = Object.assign(Object.assign({}, partialConfig), { buildDir: process.cwd() + "/" + partialConfig.outdir });
+    try {
+        fs_1.default.mkdirSync(`${process.cwd()}/${config.outdir}`);
+    }
+    catch (_a) {
+        // console.log()
+    }
+    fs_1.default.writeFileSync(`${config.outdir}/testeranto.json`, JSON.stringify(Object.assign(Object.assign({}, config), { buildDir: process.cwd() + "/" + config.outdir }), null, 2));
+    try {
+        fs_1.default.mkdirSync(`${process.cwd()}/${config.outdir}/node`);
+    }
+    catch (_b) {
+        // console.log()
+    }
+    try {
+        fs_1.default.mkdirSync(`${process.cwd()}/${config.outdir}/web`);
+    }
+    catch (_c) {
+        // console.log()
+    }
+    try {
+        fs_1.default.mkdirSync(`${process.cwd()}/${config.outdir}/features`);
+    }
+    catch (_d) {
+        // console.log()
+    }
+    try {
+        fs_1.default.mkdirSync(`${process.cwd()}/${config.outdir}/ts`);
+    }
+    catch (_e) {
+        // console.log()
+    }
+};

package/dist/common/src/Init.js

@@ -6,5 +6,35 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const fs_1 = __importDefault(require("fs"));
 exports.default = async (partialConfig) => {
     const config = Object.assign(Object.assign({}, partialConfig), { buildDir: process.cwd() + "/" + partialConfig.outdir });
+    try {
+        fs_1.default.mkdirSync(`${process.cwd()}/${config.outdir}`);
+    }
+    catch (_a) {
+        // console.log()
+    }
     fs_1.default.writeFileSync(`${config.outdir}/testeranto.json`, JSON.stringify(Object.assign(Object.assign({}, config), { buildDir: process.cwd() + "/" + config.outdir }), null, 2));
+    try {
+        fs_1.default.mkdirSync(`${process.cwd()}/${config.outdir}/node`);
+    }
+    catch (_b) {
+        // console.log()
+    }
+    try {
+        fs_1.default.mkdirSync(`${process.cwd()}/${config.outdir}/web`);
+    }
+    catch (_c) {
+        // console.log()
+    }
+    try {
+        fs_1.default.mkdirSync(`${process.cwd()}/${config.outdir}/features`);
+    }
+    catch (_d) {
+        // console.log()
+    }
+    try {
+        fs_1.default.mkdirSync(`${process.cwd()}/${config.outdir}/ts`);
+    }
+    catch (_e) {
+        // console.log()
+    }
 };

package/dist/common/src/PM/main.js

@@ -33,8 +33,8 @@ const puppeteer_core_1 = __importDefault(require("puppeteer-core"));
 const crypto_1 = __importDefault(require("crypto"));
 const index_js_1 = require("./index.js");
 const utils_js_1 = require("../utils.js");
-const fPaths = [];
 const fileStreams3 = [];
+const fPaths = [];
 const files = {};
 const screenshots = {};
 class PM_Main extends index_js_1.PM {
@@ -150,6 +150,7 @@ class PM_Main extends index_js_1.PM {
                 fs: destFolder,
                 browserWSEndpoint: this.browser.wsEndpoint(),
             });
+            // files[src] = new Set();
             // const evaluation = `
             // console.log("importing ${dest}.mjs");
             // import('${dest}.mjs').then(async (x) => {
@@ -213,9 +214,9 @@ class PM_Main extends index_js_1.PM {
                     });
                     page.exposeFunction("createWriteStream", (fp, testName) => {
                         const f = fs_1.default.createWriteStream(fp);
-                        if (!files[testName]) {
-                            files[testName] = new Set();
-                        }
+                        // if (!files[testName]) {
+                        //   files[testName] = new Set();
+                        // }
                         files[testName].add(fp);
                         const p = new Promise((res, rej) => {
                             res(fp);
@@ -347,6 +348,8 @@ class PM_Main extends index_js_1.PM {
     })`;
             const fileStreams2 = [];
             const doneFileStream2 = [];
+            const stdoutStream = fs_1.default.createWriteStream(`${dest}/stdout.log`);
+            const stderrStream = fs_1.default.createWriteStream(`${dest}/stderr.log`);
             this.browser
                 .newPage()
                 .then((page) => {
@@ -503,9 +506,39 @@ class PM_Main extends index_js_1.PM {
                 return page;
             })
                 .then(async (page) => {
-                // page.on("console", (log) =>
-                //   console.debug(`Log from client: [${log.text()}] `)
-                // );
+                const close = () => {
+                    console.log("evaluation complete.", dest);
+                    page.off("pageerror");
+                    page.close();
+                    this.deregister(t);
+                    stderrStream.close();
+                    stdoutStream.close();
+                };
+                page.on("pageerror", (err) => {
+                    console.debug(`Error from ${t}: [${err.name}] `);
+                    stderrStream.write(err.name);
+                    if (err.cause) {
+                        console.debug(`Error from ${t} cause: [${err.cause}] `);
+                        stderrStream.write(err.cause);
+                    }
+                    if (err.stack) {
+                        console.debug(`Error from stack ${t}: [${err.stack}] `);
+                        stderrStream.write(err.stack);
+                    }
+                    console.debug(`Error from message ${t}: [${err.message}] `);
+                    stderrStream.write(err.message);
+                    // close();
+                });
+                page.on("console", (log) => {
+                    // console.debug(`Log from ${t}: [${log.text()}] `);
+                    // console.debug(`Log from ${t}: [${JSON.stringify(log.location())}] `);
+                    // console.debug(
+                    //   `Log from ${t}: [${JSON.stringify(log.stackTrace())}] `
+                    // );
+                    stdoutStream.write(log.text());
+                    stdoutStream.write(JSON.stringify(log.location()));
+                    stdoutStream.write(JSON.stringify(log.stackTrace()));
+                });
                 await page.goto(`file://${`${dest}.html`}`, {});
                 await page
                     .evaluate(evaluation)
@@ -517,9 +550,12 @@ class PM_Main extends index_js_1.PM {
                     console.log(e);
                 })
                     .finally(() => {
-                    console.log("evaluation complete.", dest);
+                    close();
+                    // console.log("evaluation complete.", dest);
                     // page.close();
-                    this.deregister(t);
+                    // this.deregister(t);
+                    // stderrStream.close();
+                    // stdoutStream.close();
                 });
                 return page;
             });

package/dist/common/src/Project.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ITProject = void 0;
+const child_process_1 = require("child_process");
 const esbuild_1 = __importDefault(require("esbuild"));
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
@@ -15,6 +16,84 @@ const web_html_js_1 = __importDefault(require("./web.html.js"));
 readline_1.default.emitKeypressEvents(process.stdin);
 if (process.stdin.isTTY)
     process.stdin.setRawMode(true);
+const logContent = [];
+function parseTsErrors() {
+    try {
+        // const logContent = fs.readFileSync(logPath, "utf-8").split("\n");
+        const regex = /(^src(.*?))\(\d*,\d*\): error/gm;
+        const brokenFilesToLines = {};
+        for (let i = 0; i < logContent.length - 1; i++) {
+            let m;
+            while ((m = regex.exec(logContent[i])) !== null) {
+                // This is necessary to avoid infinite loops with zero-width matches
+                if (m.index === regex.lastIndex) {
+                    regex.lastIndex++;
+                }
+                if (!brokenFilesToLines[m[1]]) {
+                    brokenFilesToLines[m[1]] = new Set();
+                }
+                brokenFilesToLines[m[1]].add(i);
+            }
+        }
+        const final = Object.keys(brokenFilesToLines).reduce((mm, lm, ndx) => {
+            mm[lm] = Array.from(brokenFilesToLines[lm]).map((l, ndx3) => {
+                const a = Array.from(brokenFilesToLines[lm]);
+                return Object.keys(a).reduce((mm2, lm2, ndx2) => {
+                    const acc = [];
+                    let j = a[lm2] + 1;
+                    let working = true;
+                    while (j < logContent.length - 1 && working) {
+                        if (!logContent[j].match(regex) &&
+                            working &&
+                            !logContent[j].match(/^..\/(.*?)\(\d*,\d*\)/)) {
+                            acc.push(logContent[j]);
+                        }
+                        else {
+                            working = false;
+                        }
+                        j++;
+                    }
+                    mm2[lm] = [logContent[l], ...acc];
+                    return mm2;
+                }, {})[lm];
+            });
+            return mm;
+        }, {});
+        Object.keys(final).forEach((k) => {
+            fs_1.default.mkdirSync(`./docs/types/${k.split("/").slice(0, -1).join("/")}`, {
+                recursive: true,
+            });
+            fs_1.default.writeFileSync(`./docs/types/${k}.type_errors.txt`, final[k].flat().flat().join("\r\n"));
+        });
+    }
+    catch (error) {
+        console.error("Error reading or parsing the log file:", error);
+        process.exit(1);
+    }
+}
+const compile = () => {
+    return new Promise((resolve, reject) => {
+        const tsc = (0, child_process_1.spawn)("tsc", ["-noEmit"]);
+        tsc.stdout.on("data", (data) => {
+            // console.log(`stdout: ${data}`);
+            const lines = data.toString().split("\n");
+            logContent.push(...lines);
+        });
+        tsc.stderr.on("data", (data) => {
+            // console.error(`stderr: ${data}`);
+        });
+        tsc.on("close", (code) => {
+            parseTsErrors();
+            resolve(`tsc process exited with code ${code}`);
+            // if (code !== 0) {
+            //   resolve(`tsc process exited with code ${code}`);
+            //   // reject(`tsc process exited with code ${code}`);
+            // } else {
+            //   resolve({});
+            // }
+        });
+    });
+};
 class ITProject {
     constructor(configs) {
         this.nodeDone = false;
@@ -58,6 +137,7 @@ class ITProject {
             }
         });
         fs_1.default.writeFileSync(`${this.config.outdir}/testeranto.json`, JSON.stringify(Object.assign(Object.assign({}, this.config), { buildDir: process.cwd() + "/" + this.config.outdir }), null, 2));
+        compile();
         Promise.resolve(Promise.all([...this.getSecondaryEndpointsPoints("web")].map(async (sourceFilePath) => {
             const sourceFileSplit = sourceFilePath.split("/");
             const sourceDir = sourceFileSplit.slice(0, -1);

package/dist/common/src/Puppeteer.js

@@ -21,7 +21,7 @@ exports.default = async (partialConfig) => {
         executablePath: 
         // process.env.CHROMIUM_PATH || "/opt/homebrew/bin/chromium",
         "/opt/homebrew/bin/chromium",
-        headless: true,
+        headless: false,
         dumpio: true,
         // timeout: 0,
         devtools: true,

package/dist/common/{run-tests.js → src/build-tests.js}

@@ -27,8 +27,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const process_1 = __importDefault(require("process"));
-process_1.default.chdir(__dirname);
-const Puppeteer_js_1 = __importDefault(require("./src/Puppeteer.js"));
-console.log(process_1.default.argv);
-const Project = await Promise.resolve().then(() => __importStar(require(process_1.default.argv[2])));
-exports.default = (0, Puppeteer_js_1.default)(Project);
+const Project_1 = require("./Project");
+if (!process_1.default.argv[2]) {
+    console.log("You didn't pass a config file");
+    process_1.default.exit(-1);
+}
+else {
+    Promise.resolve().then(() => __importStar(require(process_1.default.cwd() + "/" + process_1.default.argv[2]))).then((module) => {
+        new Project_1.ITProject(module.default);
+    });
+}

package/dist/common/src/defaultConfig.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config = {
+    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.");
+    },
+};
+exports.default = config;

package/dist/common/src/esbuildConfigs/inputFilesPlugin.js

@@ -14,13 +14,15 @@ const register = (entrypoint, sources) => {
     sources.forEach((s) => otherInputs[entrypoint].add(s));
 };
 function tree(meta, key) {
-    return [
-        key,
-        ...meta.inputs[key].imports
-            .filter((x) => x.external !== true)
-            .filter((x) => x.path.split("/")[0] !== "node_modules")
-            .map((f) => f.path),
-    ];
+    console.log("searching metafile for", key);
+    const outputKey = Object.keys(meta.outputs).find((k) => {
+        return meta.outputs[k].entryPoint === key;
+    });
+    if (!outputKey) {
+        console.error("No outputkey found");
+        process.exit(-1);
+    }
+    return Object.keys(meta.outputs[outputKey].inputs).filter((k) => k.startsWith("src"));
 }
 exports.default = (platform, entryPoints) => {
     return {
@@ -39,7 +41,9 @@ exports.default = (platform, entryPoints) => {
                             }
                             const promptPath = path_1.default.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `prompt.txt`);
                             const testPaths = path_1.default.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `tests.json`);
-                            const featuresPath = path_1.default.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `featurePrompt.txt`); // /read ${featuresPath}
+                            const featuresPath = path_1.default.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `featurePrompt.txt`);
+                            const stderrPath = path_1.default.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `stderr.log`);
+                            const stdoutPath = path_1.default.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `stdout.log`);
                             if (result.metafile) {
                                 const addableFiles = tree(result.metafile, entryPoint.split("/").slice(1).join("/"))
                                     .map((y) => {
@@ -49,23 +53,31 @@ exports.default = (platform, entryPoints) => {
                                     return y;
                                 })
                                     .flat();
+                                const typeErrorFiles = addableFiles.map((t) => `docs/types/${t}.type_errors.txt`);
                                 fs_1.default.writeFileSync(promptPath, `
-${[...addableFiles]
+${addableFiles
                                     .map((x) => {
                                     return `/add ${x}`;
                                 })
                                     .join("\n")}
-${[...addableFiles]
+  
+${typeErrorFiles
                                     .map((x) => {
-                                    const f = `docs/ts/${x}.type_errors.txt`;
-                                    if (fs_1.default.existsSync(f)) {
-                                        return `/read ${f}`;
-                                    }
+                                    // const f = `docs/types/${x}.type_errors.txt`;
+                                    return `/read ${x}`;
+                                    // if (fs.existsSync(f)) {
+                                    //   return `/read ${f}`;
+                                    // }
                                 })
                                     .join("\n")}
+  
 /read ${testPaths}
+/read ${stdoutPath}
+/read ${stderrPath}
+
 /load ${featuresPath}
-/code Fix the failing tests described in ${testPaths}. Correct any type signature errors. Implement any method which throws "Function not implemented."
+
+/code Fix the failing tests described in ${testPaths}. Correct any type signature errors described in the files [${typeErrorFiles.join(", ")}]. Implement any method which throws "Function not implemented."
 `);
                             }
                         });

package/dist/common/src/init-docs.js

@@ -0,0 +1,43 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const Init_1 = __importDefault(require("../dist/module/src/Init"));
+console.log("Initializing a testeranto project");
+if (!process.argv[2]) {
+    console.log("You didn't pass a config file, so I will create one for you.");
+    fs_1.default.writeFileSync("testeranto.mts", fs_1.default.readFileSync("node_modules/testeranto/src/defaultConfig.ts"));
+    Promise.resolve().then(() => __importStar(require(process.cwd() + "/" + "testeranto.mts"))).then((module) => {
+        (0, Init_1.default)(module.default);
+    });
+}
+else {
+    Promise.resolve().then(() => __importStar(require(process.cwd() + "/" + process.argv[2]))).then((module) => {
+        (0, Init_1.default)(module.default);
+    });
+}

package/dist/common/src/lib/abstractBase.js

@@ -290,70 +290,6 @@ class BaseGiven {
                         if (prop === "writeFileSync") {
                             return (fp, contents) => target[prop](`suite-${suiteNdx}/given-${key}/afterEach/${fp}`, contents);
                         }
-                        // if (prop === "browser") {
-                        //   return new Proxy(target[prop], {
-                        //     get(bTarget, bProp, bReceiver) {
-                        //       if (bProp === "pages") {
-                        //         return async () => {
-                        //           return bTarget.pages().then((pages) => {
-                        //             return pages.map((page) => {
-                        //               return new Proxy(page, {
-                        //                 get(pTarget, pProp, pReciever) {
-                        //                   if (pProp === "screenshot") {
-                        //                     return async (x) => {
-                        //                       // console.log(
-                        //                       //   "custom-screenshot-MARK-afterEachProxy",
-                        //                       //   window["custom-screenshot"].toString()
-                        //                       // );
-                        //                       return pm.customScreenShot(
-                        //                         {
-                        //                           ...x,
-                        //                           path:
-                        //                             `${testResourceConfiguration.fs}/suite-${suiteNdx}/given-${key}/afterEach` +
-                        //                             "/" +
-                        //                             x.path,
-                        //                         },
-                        //                         page
-                        //                       );
-                        //                       // return await pTarget[pProp]({
-                        //                       //   ...x,
-                        //                       //   path:
-                        //                       //     `${testResourceConfiguration.fs}/suite-${suiteNdx}/given-${key}/afterEach` +
-                        //                       //     "/" +
-                        //                       //     x.path,
-                        //                       // });
-                        //                     };
-                        //                   } else if (pProp === "mainFrame") {
-                        //                     return () => pTarget[pProp]();
-                        //                     // return target[pProp];
-                        //                     // return Reflect.get(...arguments);
-                        //                   } else if (pProp === "exposeFunction") {
-                        //                     // return Reflect.get(target, prop, receiver);
-                        //                     return (...a) => pTarget[pProp](...a);
-                        //                     // return target[pProp];
-                        //                   } else if (pProp === "removeExposedFunction") {
-                        //                     // return Reflect.get(target, prop, receiver);
-                        //                     return pTarget[pProp].bind(pTarget);
-                        //                     // return target[pProp];
-                        //                   }
-                        //                   // else if (pProp === "#frameManager") {
-                        //                   //   return () => target[pProp](...arguments);
-                        //                   // }
-                        //                   else {
-                        //                     return Reflect.get(...arguments);
-                        //                   }
-                        //                 },
-                        //               });
-                        //             });
-                        //           });
-                        //           // return (await target.pages()).map((page) => {
-                        //           //   return new Proxy(page, handler2);
-                        //           // });
-                        //         };
-                        //       }
-                        //     },
-                        //   });
-                        // }
                         return Reflect.get(...arguments);
                     },
                 });

package/dist/common/src/lib/core.js

@@ -39,9 +39,11 @@ class Testeranto extends classBuilder_js_1.ClassBuilder {
             }
         }, class Given extends abstractBase_js_1.BaseGiven {
             async givenThat(subject, testResource, artifactory, initializer, pm) {
-                return fullTestInterface.beforeEach(subject, initializer, (fPath, value) => 
-                // TODO does not work?
-                artifactory(`beforeEach/${fPath}`, value), testResource, this.initialValues, pm);
+                return fullTestInterface.beforeEach(subject, initializer, 
+                // (fPath: string, value: unknown) =>
+                //   // TODO does not work?
+                //   artifactory(`beforeEach/${fPath}`, value),
+                testResource, this.initialValues, pm);
             }
             afterEach(store, key, artifactory, pm) {
                 return new Promise((res) => res(fullTestInterface.afterEach(store, key, (fPath, value) => artifactory(`after/${fPath}`, value), pm)));

package/dist/common/{build-tests.js → src/run-tests.js}

@@ -1,5 +1,4 @@
 "use strict";
-// import { ITProject } from "./src/Project.js";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -27,12 +26,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-// import Project from "./testeranto.js";
+const Puppeteer_js_1 = __importDefault(require("./Puppeteer.js"));
 const process_1 = __importDefault(require("process"));
-const Project_1 = require("./src/Project");
-// import { ITProject } from "testeranto/src/Project";
-// process.chdir(__dirname);
-// import Puppeteer from "./src/Puppeteer.js";
-console.log(process_1.default.argv);
-const Project = await Promise.resolve().then(() => __importStar(require(process_1.default.argv[2])));
-exports.default = new Project_1.ITProject(Project);
+if (!process_1.default.argv[2]) {
+    console.log("You didn't pass a config file");
+    process_1.default.exit(-1);
+}
+else {
+    Promise.resolve().then(() => __importStar(require(process_1.default.cwd() + "/" + process_1.default.argv[2]))).then((module) => {
+        (0, Puppeteer_js_1.default)(module.default);
+    });
+}