npm - testeranto - Versions diffs - 0.94.0 → 0.110.0 - Mend

testeranto 0.94.0 → 0.110.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (308) hide show

package/dist/common/utils.js ADDED Viewed

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptPather = exports.bddExitCodePather = exports.bddPather = exports.lintExitCodePather = exports.lintPather = exports.tscExitCodePather = exports.tscPather = exports.destinationOfRuntime = void 0;
+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;
+const tscPather = (entryPoint, platform) => {
+    return path_1.default.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `type_errors.txt`);
+};
+exports.tscPather = tscPather;
+const tscExitCodePather = (entryPoint, platform) => {
+    return path_1.default.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `type_errors.txt`);
+};
+exports.tscExitCodePather = tscExitCodePather;
+const lintPather = (entryPoint, platform) => {
+    return path_1.default.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `lint_errors.json`);
+};
+exports.lintPather = lintPather;
+const lintExitCodePather = (entryPoint, platform) => {
+    return path_1.default.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `lint_errors.txt`);
+};
+exports.lintExitCodePather = lintExitCodePather;
+const bddPather = (entryPoint, platform) => {
+    return path_1.default.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `tests.json`);
+};
+exports.bddPather = bddPather;
+const bddExitCodePather = (entryPoint, platform) => {
+    return path_1.default.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `bdd_errors.txt`);
+};
+exports.bddExitCodePather = bddExitCodePather;
+const promptPather = (entryPoint, platform) => {
+    return path_1.default.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `prompt.txt`);
+};
+exports.promptPather = promptPather;

package/dist/module/Footer.js ADDED Viewed

@@ -0,0 +1,4 @@
+import React from "react";
+export const Footer = () => React.createElement("footer", null,
+    "made with \u2764\uFE0F and ",
+    React.createElement("a", { href: "https://www.npmjs.com/package/testeranto" }, "testeranto "));

package/dist/module/Init.js ADDED Viewed

@@ -0,0 +1,63 @@
+import fs from "fs";
+export default async (partialConfig) => {
+    const config = Object.assign(Object.assign({}, partialConfig), { buildDir: process.cwd() + "/" + partialConfig.outdir });
+    try {
+        fs.mkdirSync(`${process.cwd()}/${config.outdir}`);
+    }
+    catch (_a) {
+        // console.log()
+    }
+    fs.writeFileSync(`${config.outdir}/index.html`, `
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta name="description" content="Webpage description goes here" />
+  <meta charset="utf-8" />
+  <title>kokomoBay - testeranto</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <meta name="author" content="" />
+  <link rel="stylesheet" href="/kokomoBay/docs/ReportClient.css" />
+  <script type="module" src="/kokomoBay/docs/ReportClient.js"></script>
+</head>
+<body>
+  <div id="root">
+    react is loading
+  </div>
+</body>
+</html>
+    `);
+    fs.copyFileSync(`node_modules/testeranto/dist/prebuild/ReportClient.js`, `${config.outdir}/ReportClient.js`);
+    fs.copyFileSync(`node_modules/testeranto/dist/prebuild/ReportClient.css`, `${config.outdir}/ReportClient.css`);
+    fs.copyFileSync(`node_modules/testeranto/dist/prebuild/TestReport.js`, `${config.outdir}/TestReport.js`);
+    fs.copyFileSync(`node_modules/testeranto/dist/prebuild/TestReport.css`, `${config.outdir}/TestReport.css`);
+    fs.writeFileSync(`${config.outdir}/testeranto.json`, JSON.stringify(Object.assign(Object.assign({}, config), { buildDir: process.cwd() + "/" + config.outdir }), null, 2));
+    try {
+        fs.mkdirSync(`${process.cwd()}/${config.outdir}/node`);
+    }
+    catch (_b) {
+        // console.log()
+    }
+    try {
+        fs.mkdirSync(`${process.cwd()}/${config.outdir}/web`);
+    }
+    catch (_c) {
+        // console.log()
+    }
+    try {
+        fs.mkdirSync(`${process.cwd()}/${config.outdir}/features`);
+    }
+    catch (_d) {
+        // console.log()
+    }
+    try {
+        fs.mkdirSync(`${process.cwd()}/${config.outdir}/ts`);
+    }
+    catch (_e) {
+        // console.log()
+    }
+};

package/dist/module/{src/PM → PM}/main.js RENAMED Viewed

@@ -1,47 +1,100 @@
 import fs from "fs";
 import path from "path";
 import puppeteer from "puppeteer-core";
-import crypto from "crypto";
+import ansiC from "ansi-colors";
+import { bddExitCodePather, lintExitCodePather, tscExitCodePather, } from "../utils";
 import { PM } from "./index.js";
-import { destinationOfRuntime } from "../utils.js";
 const fileStreams3 = [];
 const fPaths = [];
 const files = {};
+const recorders = {};
 const screenshots = {};
+const statusMessagePretty = (failures, test) => {
+    if (failures === 0) {
+        console.log(ansiC.green(ansiC.inverse(`> ${test} completed successfully`)));
+    }
+    else {
+        console.log(ansiC.red(ansiC.inverse(`> ${test} failed ${failures} times`)));
+    }
+};
+async function writeFileAndCreateDir(filePath, data) {
+    const dirPath = path.dirname(filePath);
+    try {
+        await fs.promises.mkdir(dirPath, { recursive: true });
+        await fs.appendFileSync(filePath, data);
+    }
+    catch (error) {
+        console.error(`Error writing file: ${error}`);
+    }
+}
+function isValidUrl(string) {
+    try {
+        new URL(string);
+        return true;
+    }
+    catch (err) {
+        return false;
+    }
+}
 export class PM_Main extends PM {
     constructor(configs) {
         super();
         this.shutdownMode = false;
+        this.bigBoard = {};
         this.checkForShutdown = () => {
-            const anyRunning = Object.values(this.registry).filter((x) => x === false).length > 0;
+            const anyRunning = Object.values(this.bigBoard).filter((x) => x.status === "running")
+                .length > 0;
             if (anyRunning) {
             }
             else {
                 this.browser.disconnect().then(() => {
-                    console.log("Goodbye");
+                    const final = {
+                        timestamp: Date.now(),
+                        tests: this.configs.tests.reduce((mm, t) => {
+                            const bddErrors = fs
+                                .readFileSync(bddExitCodePather(t[0], t[1]))
+                                .toString();
+                            const lintErrors = fs
+                                .readFileSync(lintExitCodePather(t[0], t[1]))
+                                .toString();
+                            const typeErrors = fs
+                                .readFileSync(tscExitCodePather(t[0], t[1]))
+                                .toString();
+                            mm[t[0]] = {
+                                bddErrors,
+                                lintErrors,
+                                typeErrors,
+                            };
+                            return mm;
+                        }, {}),
+                    };
+                    const s = JSON.stringify(final, null, 2);
+                    fs.writeFileSync("docs/summary.json", s);
+                    console.log(ansiC.inverse("Goodbye"));
                     process.exit();
                 });
             }
         };
-        this.register = (src) => {
-            this.registry[src] = false;
+        this.testIsNowRunning = (src) => {
+            this.bigBoard[src].status = "running";
         };
-        this.deregister = (src) => {
-            this.registry[src] = true;
+        this.testIsNowDone = (src) => {
+            this.bigBoard[src].status = "waiting";
             if (this.shutdownMode) {
                 this.checkForShutdown();
             }
         };
         this.launchNode = async (src, dest) => {
-            console.log("launchNode", src);
-            this.register(src);
+            // console.log(ansiC.yellow(`! node, ${src}`));
+            console.log(ansiC.green(ansiC.inverse(`! node, ${src}`)));
+            this.testIsNowRunning(src);
             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");
+                console.log(ansiC.inverse("missing test config! Exiting ungracefully!"));
                 process.exit(-1);
             }
             const testConfigResource = testConfig[2];
@@ -80,32 +133,45 @@ export class PM_Main extends PM {
                 console.error("negative port makes no sense", src);
                 process.exit(-1);
             }
-            const builtfile = dest + ".mjs";
+            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);
-                }
-            }));
+            // 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, failed }) => {
-                        this.receiveFeatures(features, destFolder);
-                        console.log(`${src} completed with ${failed} errors`);
+                        this.receiveFeatures(features, destFolder, src);
+                        // console.log(`${src} completed with ${failed} errors`);
+                        statusMessagePretty(failed, src);
+                        this.receiveExitCode(src, failed);
                     })
                         .catch((e) => {
-                        console.log(`${src} errored with`, e);
+                        console.log(ansiC.red(ansiC.inverse(`${src} errored with: ${e}`)));
+                        // console.log(reset, `${src} errored with`, e);
                     })
                         .finally(() => {
                         webSideCares.forEach((webSideCar) => webSideCar.close());
-                        this.deregister(src);
+                        this.testIsNowDone(src);
                     });
                 });
             });
@@ -118,7 +184,8 @@ export class PM_Main extends PM {
         };
         this.launchWebSideCar = async (src, dest, testConfig) => {
             const d = dest + ".mjs";
-            console.log("launchWebSideCar", src, dest, d);
+            // console.log(green, "launchWebSideCar", src, dest, d);
+            console.log(ansiC.green(ansiC.inverse(`launchWebSideCar ${src}`)));
             const destFolder = dest.replace(".mjs", "");
             // const webArgz = JSON.stringify({
             //   name: dest,
@@ -225,7 +292,8 @@ export class PM_Main extends PM {
         };
         this.launchNodeSideCar = async (src, dest, testConfig) => {
             const d = dest + ".mjs";
-            console.log("launchNodeSideCar", src, dest, d);
+            // console.log(green, "launchNodeSideCar", src, dest, d);
+            console.log(ansiC.green(ansiC.inverse(`launchNodeSideCar ${src}`)));
             const destFolder = dest.replace(".mjs", "");
             let argz = "";
             const testConfigResource = testConfig[2];
@@ -294,14 +362,19 @@ export class PM_Main extends PM {
                 }
             }
         };
-        this.launchWeb = (t, dest, sidecars) => {
-            console.log("launchWeb", t, dest);
-            this.register(t);
-            sidecars.map((sidecar) => {
-                if (sidecar[1] === "node") {
-                    return this.launchNodeSideCar(sidecar[0], destinationOfRuntime(sidecar[0], "node", this.configs), sidecar);
-                }
-            });
+        this.launchWeb = (t, dest) => {
+            // console.log(green, "! web", t);
+            console.log(ansiC.green(ansiC.inverse(`! web ${t}`)));
+            this.testIsNowRunning(t);
+            // 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,
@@ -309,10 +382,11 @@ 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("imported", (await x.default));
+    import('${d}').then(async (x) => {
       try {
         return await (await x.default).receiveTestResourceConfig(${webArgz})
       } catch (e) {
@@ -321,8 +395,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) => {
@@ -486,12 +560,12 @@ export class PM_Main extends PM {
                         files[t] = new Set();
                     }
                     // files[t].add(filepath);
-                    fs.writeFileSync(dest + "/manifest.json", JSON.stringify(Array.from(files[t])));
+                    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);
+                        this.testIsNowDone(t);
                         stderrStream.close();
                         stdoutStream.close();
                     });
@@ -509,7 +583,7 @@ export class PM_Main extends PM {
                     }
                     console.debug(`Error from message ${t}: [${err.message}] `);
                     stderrStream.write(err.message);
-                    // close();
+                    close();
                 });
                 page.on("console", (log) => {
                     // console.debug(`Log from ${t}: [${log.text()}] `);
@@ -521,23 +595,28 @@ 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 ({ failed, features }) => {
-                    this.receiveFeatures(features, destFolder);
-                    console.log(`${t} completed with ${failed} errors`);
+                    this.receiveFeatures(features, destFolder, t);
+                    // console.log(`${t} completed with ${failed} errors`);
+                    statusMessagePretty(failed, t);
+                    this.receiveExitCode(t, failed);
                 })
                     .catch((e) => {
-                    console.log(`${t} errored with`, e);
+                    // console.log(red, `${t} errored with`, e);
+                    console.log(ansiC.red(ansiC.inverse(`${t} errored with: ${e}`)));
                 })
                     .finally(() => {
+                    // this.testIsNowDone(t);
                     close();
                 });
                 return page;
             });
         };
-        this.receiveFeatures = (features, destFolder) => {
+        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;
@@ -556,45 +635,87 @@ export class PM_Main extends PM {
                                 // throw error;
                             }
                         }
-                        fs.symlink(u.pathname, newPath, (err) => {
-                            if (err) {
-                                // console.error("Error creating symlink:", err);
-                            }
-                            else {
-                                // console.log("Symlink created successfully");
-                            }
-                        });
-                        accum.push(newPath);
+                        // fs.symlink(u.pathname, newPath, (err) => {
+                        //   if (err) {
+                        //     // console.error("Error creating symlink:", err);
+                        //   } else {
+                        //     // console.log("Symlink created successfully");
+                        //   }
+                        // });
+                        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,
+                    });
+                    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}`;
                 })
                     .join("\n"));
             });
+            this.writeBigBoard();
+        };
+        this.receiveExitCode = (srcTest, failures) => {
+            this.bigBoard[srcTest].runTimeError = failures;
+            this.writeBigBoard();
+        };
+        this.writeBigBoard = () => {
+            fs.writeFileSync("./docs/bigBoard.json", JSON.stringify(this.bigBoard, null, 2));
         };
         this.server = {};
         this.configs = configs;
         this.ports = {};
-        this.registry = {};
+        this.configs.tests.forEach(([t]) => {
+            this.bigBoard[t] = {
+                status: "?",
+            };
+        });
         this.configs.ports.forEach((element) => {
             this.ports[element] = "true"; // set ports as open
         });
+        globalThis["waitForSelector"] = async (pageKey, sel) => {
+            const page = (await this.browser.pages()).find(
+            /* @ts-ignore:next-line */
+            (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(
+            /* @ts-ignore:next-line */
+            (p) => p.mainFrame()._id === pageKey);
+            /* @ts-ignore:next-line */
+            return page.close();
+        };
+        globalThis["goto"] = async (pageKey, url) => {
+            const page = (await this.browser.pages()).find(
+            /* @ts-ignore:next-line */
+            (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, {
@@ -604,14 +725,9 @@ export class PM_Main extends PM {
             return false;
         };
         globalThis["writeFileSync"] = (filepath, contents, testName) => {
-            // console.log(testName, "writeFileSync", filepath, testName);
-            // Create directories if they don't exist
-            const dir = path.dirname(filepath);
-            // console.log(testName, "mkdirSync", dir);
-            fs.mkdirSync(dir, {
+            fs.mkdirSync(path.dirname(filepath), {
                 recursive: true,
             });
-            // console.log(testName, "mkdirSync2");
             if (!files[testName]) {
                 files[testName] = new Set();
             }
@@ -634,7 +750,33 @@ 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(
+            /* @ts-ignore:next-line */
+            (p) => p.mainFrame()._id === pageKey);
             const p = opts.path;
             const dir = path.dirname(p);
             fs.mkdirSync(dir, {
@@ -652,6 +794,19 @@ export class PM_Main extends PM {
             await sPromise;
             return sPromise;
         };
+        globalThis["screencast"] = async (opts, pageKey) => {
+            const page = (await this.browser.pages()).find(
+            /* @ts-ignore:next-line */
+            (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();
@@ -663,13 +818,28 @@ export class PM_Main extends PM {
         //   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.");
     }
     screencast(opts) {
         throw new Error("Method not implemented.");
     }
-    customScreenShot(opts) {
+    customScreenShot(opts, cdpPage) {
         throw new Error("Method not implemented.");
     }
     end(accessObject) {
@@ -754,40 +924,21 @@ 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));
     }
-    ////////////////////////////////////////////////////////////////////////////////
+    // goodbye = () => {
+    //   this.browser.disconnect().then(() => {
+    //     console.log("Goodbye");
+    //     process.exit();
+    //   });
+    // };
     shutDown() {
-        console.log("shutting down...");
         this.shutdownMode = true;
         this.checkForShutdown();
     }
 }
-async function writeFileAndCreateDir(filePath, data) {
-    const dirPath = path.dirname(filePath);
-    try {
-        await fs.promises.mkdir(dirPath, { recursive: true });
-        await fs.promises.writeFile(filePath, data);
-    }
-    catch (error) {
-        console.error(`Error writing file: ${error}`);
-    }
-}
-async function sha256(rawData) {
-    const data = typeof rawData === "object" ? JSON.stringify(rawData) : String(rawData);
-    const msgBuffer = new TextEncoder().encode(data);
-    const hashBuffer = await crypto.subtle.digest("SHA-256", msgBuffer);
-    const hashArray = Array.from(new Uint8Array(hashBuffer));
-    return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
-}
-function isValidUrl(string) {
-    try {
-        new URL(string);
-        return true;
-    }
-    catch (err) {
-        return false;
-    }
-}