testeranto 0.90.0 → 0.100.0

package/dist/module/src/Node.js

@@ -3,14 +3,16 @@ import { defaultTestResourceRequirement, } from "./lib/index.js";
 import { PM_Node } from "./PM/node.js";
 export class NodeTesteranto extends Testeranto {
     constructor(input, testSpecification, testImplementation, testResourceRequirement, testInterface) {
-        super(input, testSpecification, testImplementation, testResourceRequirement, testInterface);
+        super(input, testSpecification, testImplementation, testResourceRequirement, testInterface, () => {
+            // no-op
+        });
     }
     async receiveTestResourceConfig(partialTestResource) {
         const t = JSON.parse(partialTestResource);
         const pm = new PM_Node(t);
         const { failed, artifacts, logPromise, features } = await this.testJobs[0].receiveTestResourceConfig(pm);
-        pm.customclose();
-        return features;
+        // pm.customclose();
+        return { features, failed };
     }
 }
 export default async (input, testSpecification, testImplementation, testInterface, testResourceRequirement = defaultTestResourceRequirement) => {

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

@@ -3,11 +3,22 @@ import path from "path";
 import puppeteer from "puppeteer-core";
 import crypto from "crypto";
 import { PM } from "./index.js";
-import { destinationOfRuntime } from "../utils.js";
 const fileStreams3 = [];
 const fPaths = [];
 const files = {};
+const recorders = {};
 const screenshots = {};
+const red = "\x1b[31m";
+const green = "\x1b[32m";
+const reset = "\x1b[0m"; // Resets to default color
+const statusMessagePretty = (failures, test) => {
+    if (failures === 0) {
+        console.log(green + `${test} completed successfully` + reset);
+    }
+    else {
+        console.log(red + `${test} failed ${failures} times` + reset);
+    }
+};
 export class PM_Main extends PM {
     constructor(configs) {
         super();
@@ -33,7 +44,7 @@ export class PM_Main extends PM {
             }
         };
         this.launchNode = async (src, dest) => {
-            console.log("launchNode", src);
+            console.log("! node", src);
             this.register(src);
             const destFolder = dest.replace(".mjs", "");
             let argz = "";
@@ -80,26 +91,42 @@ export class PM_Main extends PM {
                 console.error("negative port makes no sense", src);
                 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);
-                }
-            }));
+            const builtfile = dest;
+            const webSideCares = [];
+            // await Promise.all(
+            //   testConfig[3].map(async (sidecar) => {
+            //     if (sidecar[1] === "web") {
+            //       const s = await this.launchWebSideCar(
+            //         sidecar[0],
+            //         destinationOfRuntime(sidecar[0], "web", this.configs),
+            //         sidecar
+            //       );
+            //       webSideCares.push(s);
+            //       return s;
+            //     }
+            //     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
                         .receiveTestResourceConfig(argz)
-                        .then(async (features) => {
-                        this.receiveFeatures(features, destFolder);
+                        .then(async ({ features, failed }) => {
+                        this.receiveFeatures(features, destFolder, src);
+                        // console.log(`${src} completed with ${failed} errors`);
+                        statusMessagePretty(failed, src);
                     })
                         .catch((e) => {
-                        console.log("catch", e);
+                        console.log(`${src} errored with`, e);
                     })
                         .finally(() => {
+                        webSideCares.forEach((webSideCar) => webSideCar.close());
                         this.deregister(src);
                     });
                 });
@@ -115,18 +142,12 @@ export class PM_Main extends PM {
             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(),
-            });
-            // files[src] = new Set();
-            // const evaluation = `
-            // console.log("importing ${dest}.mjs");
-            // import('${dest}.mjs').then(async (x) => {
-            //   console.log("imported", x.default);
-            // })`;
+            // const webArgz = JSON.stringify({
+            //   name: dest,
+            //   ports: [].toString(),
+            //   fs: destFolder,
+            //   browserWSEndpoint: this.browser.wsEndpoint(),
+            // });
             const fileStreams2 = [];
             const doneFileStream2 = [];
             return new Promise((res, rej) => {
@@ -205,14 +226,17 @@ export class PM_Main extends PM {
                     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();
-                        });
-                    });
+                    // page.exposeFunction("customclose", (p: string, testName: string) => {
+                    //   fs.writeFileSync(
+                    //     p + "/manifest.json",
+                    //     JSON.stringify(Array.from(files[testName]))
+                    //   );
+                    //   delete files[testName];
+                    //   Promise.all(screenshots[testName] || []).then(() => {
+                    //     delete screenshots[testName];
+                    //     // page.close();
+                    //   });
+                    // });
                     return page;
                 })
                     .then(async (page) => {
@@ -292,14 +316,18 @@ export class PM_Main extends PM {
                 }
             }
         };
-        this.launchWeb = (t, dest, sidecars) => {
-            console.log("launchWeb", t, dest);
+        this.launchWeb = (t, dest) => {
+            console.log("! web", t);
             this.register(t);
-            sidecars.map((sidecar) => {
-                if (sidecar[1] === "node") {
-                    return this.launchNodeSideCar(sidecar[0], destinationOfRuntime(sidecar[0], "node", this.configs), sidecar);
-                }
-            });
+            // 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,
@@ -307,9 +335,10 @@ export class PM_Main extends PM {
                 fs: destFolder,
                 browserWSEndpoint: this.browser.wsEndpoint(),
             });
+            const d = `${dest}?cacheBust=${Date.now()}`;
             const evaluation = `
-    console.log("importing ${dest}.mjs");
-    import('${dest}.mjs').then(async (x) => {
+    console.log("importing ${d}");
+    import('${d}').then(async (x) => {
       console.log("imported", (await x.default));
       try {
         return await (await x.default).receiveTestResourceConfig(${webArgz})
@@ -319,8 +348,8 @@ export class PM_Main extends PM {
     })`;
             const fileStreams2 = [];
             const doneFileStream2 = [];
-            const stdoutStream = fs.createWriteStream(`${dest}/stdout.log`);
-            const stderrStream = fs.createWriteStream(`${dest}/stderr.log`);
+            const stdoutStream = fs.createWriteStream(`${destFolder}/stdout.log`);
+            const stderrStream = fs.createWriteStream(`${destFolder}/stderr.log`);
             this.browser
                 .newPage()
                 .then((page) => {
@@ -368,20 +397,21 @@ export class PM_Main extends PM {
                     // 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;
+                    return globalThis["writeFileSync"](fp, contents, testName);
+                    // const dir = path.dirname(fp);
+                    // fs.mkdirSync(dir, {
+                    //   recursive: true,
+                    // });
+                    // const p = new Promise<string>(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);
@@ -416,36 +446,37 @@ export class PM_Main extends PM {
                 page.exposeFunction("end", async (uid) => {
                     return fileStreams2[uid].end();
                 });
-                page.exposeFunction("customclose", (p, testName) => {
-                    // console.log("closing", p);
-                    fs.writeFileSync(p + "/manifest.json", JSON.stringify(Array.from(files[testName])));
-                    delete files[testName];
-                    // console.log("screenshots[testName]", screenshots[testName]);
-                    Promise.all(screenshots[testName] || []).then(() => {
-                        delete screenshots[testName];
-                        // page.close();
-                        // console.log("\t GOODBYE");
-                        // whyIsNodeRunning();
-                    });
-                    // 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();
-                });
+                // page.exposeFunction("customclose", (p: string, testName: string) => {
+                //   // console.log("closing", p);
+                //   console.log("\t GOODBYE customclose");
+                //   fs.writeFileSync(
+                //     p + "/manifest.json",
+                //     JSON.stringify(Array.from(files[testName]))
+                //   );
+                //   delete files[testName];
+                //   // console.log("screenshots[testName]", screenshots[testName]);
+                //   Promise.all(screenshots[testName] || []).then(() => {
+                //     delete screenshots[testName];
+                //   });
+                //   // 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();
+                // });
                 page.exposeFunction("page", () => {
                     return page.mainFrame()._id;
                 });
@@ -478,12 +509,19 @@ export class PM_Main extends PM {
             })
                 .then(async (page) => {
                 const close = () => {
-                    console.log("evaluation complete.", dest);
-                    page.off("pageerror");
-                    page.close();
-                    this.deregister(t);
-                    stderrStream.close();
-                    stdoutStream.close();
+                    if (!files[t]) {
+                        files[t] = new Set();
+                    }
+                    // files[t].add(filepath);
+                    fs.writeFileSync(destFolder + "/manifest.json", JSON.stringify(Array.from(files[t])));
+                    delete files[t];
+                    Promise.all(screenshots[t] || []).then(() => {
+                        delete screenshots[t];
+                        page.close();
+                        this.deregister(t);
+                        stderrStream.close();
+                        stdoutStream.close();
+                    });
                 };
                 page.on("pageerror", (err) => {
                     console.debug(`Error from ${t}: [${err.name}] `);
@@ -510,29 +548,25 @@ export class PM_Main extends PM {
                     stdoutStream.write(JSON.stringify(log.location()));
                     stdoutStream.write(JSON.stringify(log.stackTrace()));
                 });
-                await page.goto(`file://${`${dest}.html`}`, {});
+                await page.goto(`file://${`${destFolder}.html`}`, {});
                 await page
                     .evaluate(evaluation)
-                    .then(async (features) => {
-                    this.receiveFeatures(features, destFolder);
+                    .then(async ({ failed, features }) => {
+                    this.receiveFeatures(features, destFolder, t);
+                    // console.log(`${t} completed with ${failed} errors`);
+                    statusMessagePretty(failed, t);
                 })
                     .catch((e) => {
-                    console.log("evaluation failed.", dest);
-                    console.log(e);
+                    console.log(`${t} errored with`, e);
                 })
                     .finally(() => {
                     close();
-                    // console.log("evaluation complete.", dest);
-                    // page.close();
-                    // this.deregister(t);
-                    // stderrStream.close();
-                    // stdoutStream.close();
                 });
                 return page;
             });
         };
-        this.receiveFeatures = (features, destFolder) => {
-            console.log("this.receiveFeatures", features);
+        this.receiveFeatures = (features, destFolder, srcTest) => {
+            const featureDestination = path.resolve(process.cwd(), "docs", "features", "strings", srcTest.split(".").slice(0, -1).join(".") + ".features.txt");
             features
                 .reduce(async (mm, featureStringKey) => {
                 const accum = await mm;
@@ -559,24 +593,33 @@ export class PM_Main extends PM {
                                 // console.log("Symlink created successfully");
                             }
                         });
-                        accum.push(newPath);
+                        accum.files.push(newPath);
                     }
                     else if (u.protocol === "http:" || u.protocol === "https:") {
                         const newPath = `${process.cwd()}/docs/features/external${u.hostname}${u.pathname}`;
                         const body = await this.configs.featureIngestor(featureStringKey);
                         writeFileAndCreateDir(newPath, body);
-                        accum.push(newPath);
+                        accum.files.push(newPath);
                     }
                 }
                 else {
-                    const newPath = `${process.cwd()}/docs/features/plain/${await sha256(featureStringKey)}`;
-                    writeFileAndCreateDir(newPath, featureStringKey);
-                    accum.push(newPath);
+                    await fs.promises.mkdir(path.dirname(featureDestination), {
+                        recursive: true,
+                    });
+                    // const newPath = `${process.cwd()}/docs/features/plain/${await sha256(
+                    //   featureStringKey
+                    // )}`;
+                    // writeFileAndCreateDir(
+                    //   `${featureDestination}/${await sha256(featureStringKey)}`,
+                    //   featureStringKey
+                    // );
+                    accum.strings.push(featureStringKey);
                 }
                 return accum;
-            }, Promise.resolve([]))
-                .then((features) => {
-                fs.writeFileSync(`${destFolder}/featurePrompt.txt`, features
+            }, Promise.resolve({ files: [], strings: [] }))
+                .then(({ files, strings }) => {
+                // writeFileAndCreateDir(`${featureDestination}`, JSON.stringify(strings));
+                fs.writeFileSync(`${destFolder}/featurePrompt.txt`, files
                     .map((f) => {
                     return `/read ${f}`;
                 })
@@ -590,6 +633,33 @@ export class PM_Main extends PM {
         this.configs.ports.forEach((element) => {
             this.ports[element] = "true"; // set ports as open
         });
+        globalThis["waitForSelector"] = async (pageKey, sel) => {
+            console.log("waitForSelector", pageKey, sel);
+            const page = (await this.browser.pages()).find((p) => p.mainFrame()._id === pageKey);
+            await (page === null || page === void 0 ? void 0 : page.waitForSelector(sel));
+        };
+        globalThis["screencastStop"] = async (path) => {
+            return recorders[path].stop();
+        };
+        globalThis["closePage"] = async (pageKey) => {
+            const page = (await this.browser.pages()).find((p) => p.mainFrame()._id === pageKey);
+            return page.close();
+        };
+        // globalThis["closePage"] = (p) => {
+        //   console.log("closePage", p);
+        //   return p.close();
+        // };
+        globalThis["goto"] = async (pageKey, url) => {
+            const page = (await this.browser.pages()).find((p) => p.mainFrame()._id === pageKey);
+            await (page === null || page === void 0 ? void 0 : page.goto(url));
+            return;
+        };
+        globalThis["newPage"] = () => {
+            return this.browser.newPage();
+        };
+        globalThis["pages"] = () => {
+            return this.browser.pages();
+        };
         globalThis["mkdirSync"] = (fp) => {
             if (!fs.existsSync(fp)) {
                 return fs.mkdirSync(fp, {
@@ -599,12 +669,14 @@ export class PM_Main extends PM {
             return false;
         };
         globalThis["writeFileSync"] = (filepath, contents, testName) => {
-            // console.log("globalThis-writeFileSync", filepath);
+            // console.log(testName, "writeFileSync", filepath, testName);
             // Create directories if they don't exist
-            const dir = path.dirname(filepath.split("/").slice(0, -1).join("/"));
+            const dir = path.dirname(filepath);
+            // console.log(testName, "mkdirSync", dir);
             fs.mkdirSync(dir, {
                 recursive: true,
             });
+            // console.log(testName, "mkdirSync2");
             if (!files[testName]) {
                 files[testName] = new Set();
             }
@@ -627,7 +699,31 @@ export class PM_Main extends PM {
         globalThis["end"] = (uid) => {
             fileStreams3[uid].end();
         };
-        globalThis["customScreenShot"] = async (opts, page) => {
+        // async (ssOpts: ScreenshotOptions, testName: string) => {
+        //   const p = ssOpts.path as string;
+        //   const dir = path.dirname(p);
+        //   fs.mkdirSync(dir, {
+        //     recursive: true,
+        //   });
+        //   if (!files[testName]) {
+        //     files[testName] = new Set();
+        //   }
+        //   files[testName].add(ssOpts.path as string);
+        //   const sPromise = page.screenshot({
+        //     ...ssOpts,
+        //     path: p,
+        //   });
+        //   if (!screenshots[testName]) {
+        //     screenshots[testName] = [];
+        //   }
+        //   screenshots[testName].push(sPromise);
+        //   // sPromise.then(())
+        //   await sPromise;
+        //   return sPromise;
+        //   // page.evaluate(`window["screenshot done"]`);
+        // };
+        globalThis["customScreenShot"] = async (opts, pageKey, testName) => {
+            const page = (await this.browser.pages()).find((p) => p.mainFrame()._id === pageKey);
             const p = opts.path;
             const dir = path.dirname(p);
             fs.mkdirSync(dir, {
@@ -645,13 +741,42 @@ export class PM_Main extends PM {
             await sPromise;
             return sPromise;
         };
-        globalThis["customclose"] = (p, testName) => {
-            if (!files[testName]) {
-                files[testName] = new Set();
-            }
-            fs.writeFileSync(p + "/manifest.json", JSON.stringify(Array.from(files[testName])));
-            delete files[testName];
+        globalThis["screencast"] = async (opts, pageKey) => {
+            const page = (await this.browser.pages()).find((p) => p.mainFrame()._id === pageKey);
+            const p = opts.path;
+            const dir = path.dirname(p);
+            fs.mkdirSync(dir, {
+                recursive: true,
+            });
+            const recorder = await (page === null || page === void 0 ? void 0 : page.screencast(Object.assign(Object.assign({}, opts), { path: p })));
+            recorders[opts.path] = recorder;
+            return opts.path;
         };
+        // globalThis["customclose"] = (p: string, testName: string) => {
+        //   if (!files[testName]) {
+        //     files[testName] = new Set();
+        //   }
+        //   fs.writeFileSync(
+        //     p + "/manifest.json",
+        //     JSON.stringify(Array.from(files[testName]))
+        //   );
+        //   delete files[testName];
+        // };
+    }
+    customclose() {
+        throw new Error("Method not implemented.");
+    }
+    waitForSelector(p, s) {
+        throw new Error("Method not implemented.");
+    }
+    closePage(p) {
+        throw new Error("Method not implemented.");
+    }
+    newPage() {
+        throw new Error("Method not implemented.");
+    }
+    goto(p, url) {
+        throw new Error("Method not implemented.");
     }
     $(selector) {
         throw new Error("Method not implemented.");
@@ -659,7 +784,7 @@ export class PM_Main extends PM {
     screencast(opts) {
         throw new Error("Method not implemented.");
     }
-    customScreenShot(opts) {
+    customScreenShot(opts, cdpPage) {
         throw new Error("Method not implemented.");
     }
     end(accessObject) {
@@ -744,6 +869,9 @@ export class PM_Main extends PM {
     isDisabled(selector) {
         throw new Error("Method not implemented.");
     }
+    screencastStop(s) {
+        throw new Error("Method not implemented.");
+    }
     ////////////////////////////////////////////////////////////////////////////////
     async startPuppeteer(options, destfolder) {
         this.browser = (await puppeteer.launch(options));
@@ -759,7 +887,7 @@ async function writeFileAndCreateDir(filePath, data) {
     const dirPath = path.dirname(filePath);
     try {
         await fs.promises.mkdir(dirPath, { recursive: true });
-        await fs.promises.writeFile(filePath, data);
+        await fs.appendFileSync(filePath, data);
     }
     catch (error) {
         console.error(`Error writing file: ${error}`);

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

@@ -8,10 +8,19 @@ export class PM_Node extends PM {
         this.server = {};
         this.testResourceConfiguration = t;
     }
-    $(selector) {
-        throw new Error("Method not implemented.");
+    waitForSelector(p, s) {
+        return globalThis["waitForSelector"](p, s);
+    }
+    closePage(p) {
+        return globalThis["closePage"](p);
+    }
+    goto(cdpPage, url) {
+        return globalThis["goto"](cdpPage.mainFrame()._id, url);
     }
-    screencast(opts) {
+    newPage() {
+        return globalThis["newPage"]();
+    }
+    $(selector) {
         throw new Error("Method not implemented.");
     }
     isDisabled(selector) {
@@ -35,8 +44,14 @@ export class PM_Node extends PM {
     click(selector) {
         return globalThis["click"](selector);
     }
-    customScreenShot(opts) {
-        return globalThis["customScreenShot"](opts);
+    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);

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

@@ -5,11 +5,26 @@ export class PM_Web extends PM {
         this.server = {};
         this.testResourceConfiguration = t;
     }
-    $(selector) {
-        return window["$"](selector);
+    waitForSelector(p, s) {
+        return window["waitForSelector"](p, s);
     }
     screencast(opts) {
-        throw new Error("Method not implemented.");
+        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);
@@ -38,7 +53,7 @@ export class PM_Web extends PM {
     existsSync(destFolder) {
         return window["existsSync"](destFolder);
     }
-    mkdirSync() {
+    mkdirSync(x) {
         return window["mkdirSync"](this.testResourceConfiguration.fs + "/");
     }
     write(writeObject, contents) {