testeranto 0.62.0 → 0.73.0

package/README.md

@@ -1,6 +1,6 @@
 # testeranto
 
-🚧 WARNING: Testeeranto is still under development and is not ready for production yet. 🚧
+🚧 WARNING: Testeranto is still under development and is not ready for production yet. 🚧
 
 home: [adamwong246.github.io/testeranto](https://adamwong246.github.io/testeranto/)
 
@@ -17,7 +17,6 @@ example repo: [kokomo bay](https://github.com/ChromaPDX/kokomoBay)
 - Do you like TDD/BDD?
 - Do you love Typescript?
 - Do you hate Jira?
-- Do you tolerate electron?
 
 If so, then testeranto might be the testing tool you have been looking for!
 
@@ -27,21 +26,20 @@ Testeranto.ts an Acceptance Test Driven Development ([ATDD](https://en.wikipedia
 
 ## Getting started
 
-1) Write some code.
-2) Write some tests of that code.
-3) Write some features of that code.
-1) Write a `testeranto.mts`, which acts as a config file. 
-3) Launch testeranto. The test runner is now rebuilding the docs folder.
-4) Commit the results of those tests.
-5) Your github pages now shows your report, showing your features, linked with your test results. 
-6) Optionally add testeranto to your CI.
+1. Write some code.
+2. Write some tests of that code.
+3. Write some features of that code.
+4. Write a `testeranto.mts`, which acts as a config file.
+5. Launch testeranto. The test runner is now rebuilding the docs folder.
+6. Commit the results of those tests.
+7. Your github pages now shows your report, showing your features, linked with your test results.
+8. Optionally add testeranto to your CI.
 
 ## tech of note
 
 - esm - Testeranto uses modern js.
 - typescript - tests are functions with type parameters
-- electron - provides both a node and chrome runtime
-- puppeteer - provides node-style tests with a handle to the browser
+- puppeteer - provides access to both node and chrome runtimes
 - esbuild - used to quickly generate test bundles
 - graphology - used to store features within a semantic network
 
@@ -55,9 +53,9 @@ Testeranto.ts an Acceptance Test Driven Development ([ATDD](https://en.wikipedia
 
 ## the good parts
 
-Your tests can be run in node, chromium, or both! For example, for a single react component, you could create 3 tests- 1 that runs with react-test-renderer on node, another on chromium which renders the component to the dom, and a 3rd node style test which invokes the component in the browser before interacting with it via puppeteer.
+Your tests can be run in node, chromium, or both.
 
-Testeranto includes a test runner which bundles and executes your tests, taking care to only run the tests which have changed. It is designed to run most tests in parallel, though it has support for tests which require a shared resource, like a port.
+Testeranto includes a test runner which bundles and executes your tests, taking care to only run the tests which have changed.
 
 Testeranto includes a test reporter which displays the state of your code in a web app. ([see example](https://chromapdx.github.io/kokomoBay/report.html)) This reporter can also be run locally for the developer's convenience.
 
@@ -67,25 +65,24 @@ Rather than the traditional method of specifying tests in plain text, Testeranto
 
 ## the bad parts
 
-Testeranto is not designed to maximize performance. In dev mode, it runs multiple esbuild processes, electron, 1 node process for each node test and 1 chromium processes for each web test. 
+Testeranto is not designed to maximize performance.
 
-Testeranto does not (yet!) of a means of allowing non-coders to affect changes so, as they say, "get good 💪!" 
+Testeranto does not (yet!) of a means of allowing non-coders to affect changes so, as they say, "get good 💪!"
 
 Because Testeranto is so un-opinionated that it does not provide test infrastructure. You will need to find an existing recipe or implement it yourself, though a public repo of test interfaces exists.
 
 ## How it works
 
 Testeranto is comprised of 3 parts
-1) The build process reads a config and builds the docs folder, then launches 3 esbuild build processes. 
-  a) Build the features for the html report
-  b) Build the node-style tests
-  c) Build the web-style tests
-2) The test runner is an electron app which watches the output of those build processes and launches the tests as those files change. 
-3) A Report which links your features, your tests and the results of those tests into a handy website.
 
-## Electron aka Node vs Chromium
+1. The build process reads a config and builds the docs folder, then launches 3 esbuild build processes.
 
-At the heart of testeranto is the dual runtime provided by electron. The electron test runner creates an UtilityProcess for each node test and a BrowserWindow for each web test. Each of these processes can communicate to other artifacts over IPC. That is, a node test can invoke a web artifact and send it messages over the IPC channel, and vice-versa. Furthermore, node tests are provided with a puppeteer, providing it access to the web environment, while web tests are provided the electron BrowserWindow, which allows it to similarly bridge the gap between the web runtime and the node runtime.
+- Build the features for the html report
+- Build the node-style tests
+- Build the web-style tests
+
+2. The test runner watches the output of those build processes and launches the tests as those files change.
+3. A Report which links your features, your tests and the results of those tests into a handy website.
 
 ## Hybrid tests
 
@@ -106,8 +103,8 @@ Testeranto's main API interface is 2 functions, 1 for each run time. You must pa
 - The "shape" - a TS type signature to which the other arguments must conform.
 - The "input" - the test subject. The "thing that is to be tested"
 - the "specification" - This is the Cucumber-style Given/When/Then steps.
-- the "implementation" - This is the code which implements the "test specification" in code. 
-- the "interface" - The code which sets up the test. 
+- the "implementation" - This is the code which implements the "test specification" in code.
+- the "interface" - The code which sets up the test.
 
 This is designed so that each piece can be worked upon separately. You can think of each argument as the responsibility of a different member of your team.
 
@@ -115,3 +112,18 @@ This is designed so that each piece can be worked upon separately. You can think
 - "Product Manager" handles the "specification"
 - "Middle Engineer" handles the "interface"
 - "Junior Engineer" handles the "implementation"
+
+## CLI
+
+There are 3 commands you should add to your `package.json`
+
+```
+// build the tests once
+"testeranto-esbuild": "ts-node-esm testeranto.mts",
+
+// build the tests, watching for changes
+"testeranto-esbuild-dev": "ts-node-esm testeranto.mts",
+
+// run the tests
+"testeranto-puppeteer":"ts-node-esm node_modules/testeranto/dist/module/Puppeteer.js",
+```

package/dist/cjs-shim.js

@@ -3,8 +3,8 @@ import path from 'node:path';
 import url from 'node:url';
 
 // globalThis.require = createRequire(import.meta.url);
-// globalThis.__filename = url.fileURLToPath(import.meta.url);
-// globalThis.__dirname = path.dirname(__filename);
+globalThis.__filename = url.fileURLToPath(import.meta.url);
+globalThis.__dirname = path.dirname(__filename);
 
 // const p = `${import.meta.url}/..`;
 // globalThis.require = createRequire(`${import.meta.url}/..`);

package/dist/common/Node.js

@@ -3,64 +3,27 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const http_1 = __importDefault(require("http"));
-const puppeteer_core_1 = __importDefault(require("puppeteer-core"));
 const core_js_1 = __importDefault(require("./lib/core.js"));
 const index_js_1 = require("./lib/index.js");
-const NodeWriter_js_1 = require("./NodeWriter.js");
-const Types_js_1 = require("./Types.js");
-const readJson = async (port) => new Promise((resolve, reject) => {
-    let json = "";
-    const request = http_1.default.request({
-        host: "127.0.0.1",
-        path: "/json/version",
-        port,
-    }, (response) => {
-        response.on("error", reject);
-        response.on("data", (chunk) => {
-            json += chunk.toString();
-        });
-        response.on("end", () => {
-            resolve(JSON.parse(json));
-        });
-    });
-    request.on("error", reject);
-    request.end();
-});
+const node_js_1 = require("./PM/node.js");
 class NodeTesteranto extends core_js_1.default {
     constructor(input, testSpecification, testImplementation, testResourceRequirement, testInterface) {
-        super(input, testSpecification, testImplementation, testResourceRequirement, NodeWriter_js_1.NodeWriter, testInterface);
-        if (process.argv[2]) {
-            const testResourceArg = process.argv[2];
-            try {
-                const partialTestResource = JSON.parse(testResourceArg);
-                this.receiveTestResourceConfig(this.testJobs[0], partialTestResource);
-            }
-            catch (e) {
-                console.error(e);
-                // process.exit(-1);
-            }
-        }
-        else {
-            // no-op
-        }
+        super(input, testSpecification, testImplementation, testResourceRequirement, testInterface);
     }
-    async receiveTestResourceConfig(t, partialTestResource) {
-        const browser = await readJson("2999").then(async (json) => {
-            const b = await puppeteer_core_1.default.connect({
-                browserWSEndpoint: json.webSocketDebuggerUrl,
-                defaultViewport: null,
-            });
-            console.log("connected!", b.isConnected());
-            return b;
-        });
-        const { failed, artifacts, logPromise } = await t.receiveTestResourceConfig(partialTestResource, new Types_js_1.TBrowser(browser));
-        Promise.all([...artifacts, logPromise]).then(async () => {
-            // process.exit(await failed ? 1 : 0);
-        });
+    async receiveTestResourceConfig(
+    // t: ITestJob,
+    partialTestResource) {
+        console.log("receiveTestResourceConfig!!", this.testJobs[0].receiveTestResourceConfig);
+        const t = JSON.parse(partialTestResource);
+        const pm = new node_js_1.PM_Node(t);
+        const { failed, artifacts, logPromise } = await this.testJobs[0].receiveTestResourceConfig(pm);
+        console.log("test is done, awaiting test result write to fs");
+        pm.customclose();
+        // Promise.all([...artifacts, logPromise]).then(async () => {
+        //   // process.exit((await failed) ? 1 : 0);
+        // });
     }
 }
-;
 exports.default = async (input, testSpecification, testImplementation, testInterface, testResourceRequirement = index_js_1.defaultTestResourceRequirement) => {
     return new NodeTesteranto(input, testSpecification, testImplementation, testResourceRequirement, testInterface);
 };

package/dist/common/PM/index.js

@@ -0,0 +1,71 @@
+"use strict";
+// import {
+//   Browser,
+//   BrowserContext,
+//   BrowserContextOptions,
+//   DebugInfo,
+//   Page,
+//   PuppeteerNode,
+//   Target,
+// } from "puppeteer-core";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PM = void 0;
+const fPaths = [];
+class PM {
+}
+exports.PM = 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/common/PM/main.js

@@ -0,0 +1,361 @@
+"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 });
+exports.PM_Main = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const puppeteer_core_1 = __importDefault(require("puppeteer-core"));
+const index_js_1 = require("./index.js");
+const fPaths = [];
+const fileStreams3 = [];
+const screenshots3 = [];
+const doneFileStream3 = [];
+class PM_Main extends index_js_1.PM {
+    // testResourceConfiguration: ITTestResourceConfiguration;
+    constructor(configs
+    // testResourceConfig: ITTestResourceConfiguration
+    ) {
+        super();
+        this.launchNode = async (src, dest) => {
+            console.log("launchNode", src);
+            // childProcesses[src] = "running";
+            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];
+            console.log("mark22 testConfigResource", testConfigResource);
+            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);
+                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";
+            this.server[builtfile] = await Promise.resolve().then(() => __importStar(require(`${builtfile}?cacheBust=${Date.now()}`))).then((module) => {
+                return module.default.then((defaultModule) => {
+                    defaultModule
+                        .receiveTestResourceConfig(argz)
+                        .then((x) => {
+                        console.log("then", x);
+                        return x;
+                    })
+                        .catch((e) => {
+                        console.log("catch", e);
+                    });
+                });
+            });
+            for (let i = 0; i <= portsToUse.length; i++) {
+                this.ports[i] = true; //port is open again
+            }
+        };
+        this.launchWeb = (t, dest) => {
+            console.log("launchWeb", t, dest);
+            const testResourceConfiguration = this.testResourceConfiguration;
+            // childProcesses[t] = "running";
+            const destFolder = dest.replace(".mjs", "");
+            const webArgz = JSON.stringify({
+                name: dest,
+                ports: [].toString(),
+                fs: destFolder,
+                browserWSEndpoint: this.browser.wsEndpoint(),
+            });
+            const evaluation = `import('${dest}.mjs').then(async (x) => {
+      console.log("imported", x, (x.default));
+      try {
+        await (await x.default).receiveTestResourceConfig(${webArgz})
+      } catch (e) {
+        console.log("fail", e)
+      }
+    })`;
+            const fileStreams2 = [];
+            const screenshots2 = [];
+            const doneFileStream2 = [];
+            this.browser
+                .newPage()
+                .then((page) => {
+                page.exposeFunction("custom-screenshot", async (ssOpts) => {
+                    const p = ssOpts.path;
+                    console.log("custom-screenshot", ssOpts);
+                    const dir = path_1.default.dirname(p);
+                    console.log("dir", dir);
+                    fs_1.default.mkdirSync(dir, {
+                        recursive: true,
+                    });
+                    return page.screenshot(Object.assign(Object.assign({}, ssOpts), { path: p }));
+                    // screenshots.push(
+                    //   page.screenshot({
+                    //     ...ssOpts,
+                    //     path: ssOpts.path,
+                    //   })
+                    // );
+                    // const sPromise = page.screenshot({
+                    //   ...ssOpts,
+                    //   path: p,
+                    // });
+                    // await sPromise;
+                    // page.evaluate(`window["screenshot done"]`);
+                });
+                page.exposeFunction("writeFileSync", (fp, contents) => {
+                    console.log("writeFileSync", fp);
+                    // Create directories if they don't exist
+                    const dir = path_1.default.dirname(fp);
+                    console.log("dir", dir);
+                    fs_1.default.mkdirSync(dir, {
+                        recursive: true,
+                    });
+                    // return fs.writeFileSync(fp, contents);
+                    const p = new Promise(async (res, rej) => {
+                        fs_1.default.writeFileSync(fp, contents);
+                        res(fp);
+                    });
+                    doneFileStream2.push(p);
+                    return p;
+                });
+                page.exposeFunction("existsSync", (fp, contents) => {
+                    return fs_1.default.existsSync(fp);
+                });
+                page.exposeFunction("mkdirSync", (fp) => {
+                    console.log("mkdirsync", fp);
+                    if (!fs_1.default.existsSync(fp)) {
+                        return fs_1.default.mkdirSync(fp, {
+                            recursive: true,
+                        });
+                    }
+                    return false;
+                });
+                page.exposeFunction("createWriteStream", (fp) => {
+                    const f = fs_1.default.createWriteStream(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", () => {
+                    console.log("closing doneFileStream2", doneFileStream2);
+                    // console.log("closing doneFileStream2", doneFileStream2);
+                    Promise.all([...doneFileStream2, ...screenshots2]).then(() => {
+                        page.close();
+                    });
+                    // 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) => {
+                await page.goto(`file://${`${dest}.html`}`, {
+                // waitUntil: "load",
+                // timeout: 0,
+                });
+                page.evaluate(evaluation).finally(() => {
+                    console.log("evaluation failed.", dest);
+                });
+                return page;
+            })
+                .then((page) => {
+                // console.log("qwe", page);
+                // page.close();
+            });
+        };
+        // this.testResourceConfiguration = testResourceConfig;
+        // console.log("mkdirsync4", testResourceConfig);
+        this.server = {};
+        this.configs = configs;
+        this.ports = {};
+        this.configs.ports.forEach((element) => {
+            this.ports[element] = "true"; // set ports as open
+        });
+        globalThis["mkdirSync"] = (fp) => {
+            if (!fs_1.default.existsSync(fp)) {
+                return fs_1.default.mkdirSync(fp, {
+                    recursive: true,
+                });
+            }
+            return false;
+        };
+        globalThis["writeFileSync"] = (fp, contents) => {
+            // Create directories if they don't exist
+            const dir = path_1.default.dirname(fp.split("/").slice(0, -1).join("/"));
+            console.log("dir", dir);
+            fs_1.default.mkdirSync(dir, {
+                recursive: true,
+            });
+            return fs_1.default.writeFileSync(fp, contents);
+        };
+        globalThis["createWriteStream"] = (filepath) => {
+            const f = fs_1.default.createWriteStream(filepath);
+            fileStreams3.push(f);
+            return Object.assign(Object.assign({}, JSON.parse(JSON.stringify(f))), { uid: fileStreams3.length - 1 });
+        };
+        globalThis["write"] = (uid, contents) => {
+            console.log("write", uid, contents);
+            // process.exit();
+            fileStreams3[uid].write(contents);
+        };
+        globalThis["end"] = (uid) => {
+            fileStreams3[uid].end();
+        };
+        globalThis["customclose"] = () => {
+            // fileStreams3[uid].end();
+        };
+        // page.exposeFunction("customclose", () => {
+        //   console.log("closing doneFileStream2", doneFileStream2);
+        //   // console.log("closing doneFileStream2", doneFileStream2);
+        //   Promise.all([...doneFileStream2, ...screenshots2]).then(() => {
+        //     page.close();
+        //   });
+        //   // page.close();
+        //   // Promise.all(screenshots).then(() => {
+        //   //   page.close();
+        //   // });
+        //   // setTimeout(() => {
+        //   //   console.log("Delayed for 1 second.");
+        //   //   page.close();
+        //   // }, 5000);
+        //   // return page.close();
+        // });
+    }
+    async startPuppeteer(options, destfolder) {
+        this.browser = await puppeteer_core_1.default.launch(options);
+        return this.browser;
+    }
+    end(accessObject) {
+        throw new Error("Method not implemented.");
+    }
+    existsSync(destFolder) {
+        return fs_1.default.existsSync(destFolder);
+    }
+    async mkdirSync(fp) {
+        if (!fs_1.default.existsSync(fp)) {
+            return fs_1.default.mkdirSync(fp, {
+                recursive: true,
+            });
+        }
+        return false;
+    }
+    writeFileSync(fp, contents) {
+        fs_1.default.writeFileSync(fp, contents);
+    }
+    createWriteStream(filepath) {
+        return fs_1.default.createWriteStream(filepath);
+    }
+    testArtiFactoryfileWriter(tLog, callback) {
+        return (fPath, value) => {
+            callback(new Promise((res, rej) => {
+                tLog("testArtiFactory =>", fPath);
+                const cleanPath = path_1.default.resolve(fPath);
+                fPaths.push(cleanPath.replace(process.cwd(), ``));
+                const targetDir = cleanPath.split("/").slice(0, -1).join("/");
+                fs_1.default.mkdir(targetDir, { recursive: true }, async (error) => {
+                    if (error) {
+                        console.error(`❗️testArtiFactory failed`, targetDir, error);
+                    }
+                    fs_1.default.writeFileSync(path_1.default.resolve(targetDir.split("/").slice(0, -1).join("/"), "manifest"), fPaths.join(`\n`), {
+                        encoding: "utf-8",
+                    });
+                    if (Buffer.isBuffer(value)) {
+                        fs_1.default.writeFileSync(fPath, value, "binary");
+                        res();
+                    }
+                    else if (`string` === typeof value) {
+                        fs_1.default.writeFileSync(fPath, value.toString(), {
+                            encoding: "utf-8",
+                        });
+                        res();
+                    }
+                    else {
+                        /* @ts-ignore:next-line */
+                        const pipeStream = value;
+                        const myFile = fs_1.default.createWriteStream(fPath);
+                        pipeStream.pipe(myFile);
+                        pipeStream.on("close", () => {
+                            myFile.close();
+                            res();
+                        });
+                    }
+                });
+            }));
+        };
+    }
+    write(accessObject, contents) {
+        throw new Error("Method not implemented.");
+    }
+}
+exports.PM_Main = PM_Main;