testeranto 0.203.0 → 0.206.0

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

@@ -0,0 +1,217 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.puppeteerConfigs = exports.filesHash = exports.statusMessagePretty = void 0;
+exports.runtimeLogs = runtimeLogs;
+exports.createLogStreams = createLogStreams;
+exports.fileHash = fileHash;
+exports.writeFileAndCreateDir = writeFileAndCreateDir;
+exports.isValidUrl = isValidUrl;
+exports.pollForFile = pollForFile;
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const ansi_colors_1 = __importDefault(require("ansi-colors"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const node_crypto_1 = __importDefault(require("node:crypto"));
+function runtimeLogs(runtime, reportDest) {
+    const safeDest = reportDest || `testeranto/reports/default_${Date.now()}`;
+    try {
+        if (!fs_1.default.existsSync(safeDest)) {
+            fs_1.default.mkdirSync(safeDest, { recursive: true });
+        }
+        if (runtime === "node") {
+            return {
+                stdout: fs_1.default.createWriteStream(`${safeDest}/stdout.log`),
+                stderr: fs_1.default.createWriteStream(`${safeDest}/stderr.log`),
+                exit: fs_1.default.createWriteStream(`${safeDest}/exit.log`),
+            };
+        }
+        else if (runtime === "web") {
+            return {
+                info: fs_1.default.createWriteStream(`${safeDest}/info.log`),
+                warn: fs_1.default.createWriteStream(`${safeDest}/warn.log`),
+                error: fs_1.default.createWriteStream(`${safeDest}/error.log`),
+                debug: fs_1.default.createWriteStream(`${safeDest}/debug.log`),
+                exit: fs_1.default.createWriteStream(`${safeDest}/exit.log`),
+            };
+        }
+        else if (runtime === "pure") {
+            return {
+                exit: fs_1.default.createWriteStream(`${safeDest}/exit.log`),
+            };
+        }
+        else if (runtime === "python") {
+            return {
+                stdout: fs_1.default.createWriteStream(`${safeDest}/stdout.log`),
+                stderr: fs_1.default.createWriteStream(`${safeDest}/stderr.log`),
+                exit: fs_1.default.createWriteStream(`${safeDest}/exit.log`),
+            };
+        }
+        else if (runtime === "golang") {
+            return {
+                stdout: fs_1.default.createWriteStream(`${safeDest}/stdout.log`),
+                stderr: fs_1.default.createWriteStream(`${safeDest}/stderr.log`),
+                exit: fs_1.default.createWriteStream(`${safeDest}/exit.log`),
+            };
+        }
+        else {
+            throw `unknown runtime: ${runtime}`;
+        }
+    }
+    catch (e) {
+        console.error(`Failed to create log streams in ${safeDest}:`, e);
+        throw e;
+    }
+}
+function createLogStreams(reportDest, runtime) {
+    // Create directory if it doesn't exist
+    if (!fs_1.default.existsSync(reportDest)) {
+        fs_1.default.mkdirSync(reportDest, { recursive: true });
+    }
+    // const streams = {
+    //   exit: fs.createWriteStream(`${reportDest}/exit.log`),
+    const safeDest = reportDest || `testeranto/reports/default_${Date.now()}`;
+    try {
+        if (!fs_1.default.existsSync(safeDest)) {
+            fs_1.default.mkdirSync(safeDest, { recursive: true });
+        }
+        const streams = runtimeLogs(runtime, safeDest);
+        // const streams = {
+        //   exit: fs.createWriteStream(`${safeDest}/exit.log`),
+        //   ...(runtime === "node" || runtime === "pure"
+        //     ? {
+        //         stdout: fs.createWriteStream(`${safeDest}/stdout.log`),
+        //         stderr: fs.createWriteStream(`${safeDest}/stderr.log`),
+        //       }
+        //     : {
+        //         info: fs.createWriteStream(`${safeDest}/info.log`),
+        //         warn: fs.createWriteStream(`${safeDest}/warn.log`),
+        //         error: fs.createWriteStream(`${safeDest}/error.log`),
+        //         debug: fs.createWriteStream(`${safeDest}/debug.log`),
+        //       }),
+        // };
+        return Object.assign(Object.assign({}, streams), { closeAll: () => {
+                Object.values(streams).forEach((stream) => !stream.closed && stream.close());
+            }, writeExitCode: (code, error) => {
+                if (error) {
+                    streams.exit.write(`Error: ${error.message}\n`);
+                    if (error.stack) {
+                        streams.exit.write(`Stack Trace:\n${error.stack}\n`);
+                    }
+                }
+                streams.exit.write(`${code}\n`);
+            }, exit: streams.exit });
+    }
+    catch (e) {
+        console.error(`Failed to create log streams in ${safeDest}:`, e);
+        throw e;
+    }
+}
+async function fileHash(filePath, algorithm = "md5") {
+    return new Promise((resolve, reject) => {
+        const hash = node_crypto_1.default.createHash(algorithm);
+        const fileStream = fs_1.default.createReadStream(filePath);
+        fileStream.on("data", (data) => {
+            hash.update(data);
+        });
+        fileStream.on("end", () => {
+            const fileHash = hash.digest("hex");
+            resolve(fileHash);
+        });
+        fileStream.on("error", (error) => {
+            reject(`Error reading file: ${error.message}`);
+        });
+    });
+}
+const statusMessagePretty = (failures, test, runtime) => {
+    if (failures === 0) {
+        console.log(ansi_colors_1.default.green(ansi_colors_1.default.inverse(`${runtime} > ${test}`)));
+    }
+    else if (failures > 0) {
+        console.log(ansi_colors_1.default.red(ansi_colors_1.default.inverse(`${runtime} > ${test} failed ${failures} times (exit code: ${failures})`)));
+    }
+    else {
+        console.log(ansi_colors_1.default.red(ansi_colors_1.default.inverse(`${runtime} > ${test} crashed (exit code: -1)`)));
+    }
+};
+exports.statusMessagePretty = statusMessagePretty;
+async function writeFileAndCreateDir(filePath, data) {
+    const dirPath = path_1.default.dirname(filePath);
+    try {
+        await fs_1.default.promises.mkdir(dirPath, { recursive: true });
+        await fs_1.default.writeFileSync(filePath, data);
+    }
+    catch (error) {
+        console.error(`Error writing file: ${error}`);
+    }
+}
+const filesHash = async (files, algorithm = "md5") => {
+    return new Promise((resolve, reject) => {
+        resolve(files.reduce(async (mm, f) => {
+            return (await mm) + (await fileHash(f));
+        }, Promise.resolve("")));
+    });
+};
+exports.filesHash = filesHash;
+function isValidUrl(string) {
+    try {
+        new URL(string);
+        return true;
+    }
+    catch (err) {
+        return false;
+    }
+}
+// Wait for file to exist, checks every 2 seconds by default
+async function pollForFile(path, timeout = 2000) {
+    const intervalObj = setInterval(function () {
+        const file = path;
+        const fileExists = fs_1.default.existsSync(file);
+        if (fileExists) {
+            clearInterval(intervalObj);
+        }
+    }, timeout);
+}
+const executablePath = "/opt/homebrew/bin/chromium";
+exports.puppeteerConfigs = {
+    slowMo: 1,
+    waitForInitialPage: false,
+    executablePath,
+    headless: true,
+    defaultViewport: null, // Disable default 800x600 viewport
+    dumpio: false,
+    devtools: false,
+    args: [
+        "--allow-file-access-from-files",
+        "--allow-insecure-localhost",
+        "--allow-running-insecure-content",
+        "--auto-open-devtools-for-tabs",
+        "--disable-dev-shm-usage",
+        "--disable-extensions",
+        "--disable-features=site-per-process",
+        "--disable-gpu",
+        "--disable-setuid-sandbox",
+        "--disable-site-isolation-trials",
+        "--disable-web-security",
+        "--no-first-run",
+        "--no-sandbox",
+        "--no-startup-window",
+        "--reduce-security-for-testing",
+        "--remote-allow-origins=*",
+        "--start-maximized",
+        "--unsafely-treat-insecure-origin-as-secure=*",
+        `--remote-debugging-port=3234`,
+        // "--disable-features=IsolateOrigins,site-per-process",
+        // "--disable-features=IsolateOrigins",
+        // "--disk-cache-dir=/dev/null",
+        // "--disk-cache-size=1",
+        // "--no-zygote",
+        // "--remote-allow-origins=ws://localhost:3234",
+        // "--single-process",
+        // "--start-maximized",
+        // "--unsafely-treat-insecure-origin-as-secure",
+        // "--unsafely-treat-insecure-origin-as-secure=ws://192.168.0.101:3234",
+    ],
+};

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

@@ -0,0 +1,102 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PM_Web = void 0;
+const _1 = require(".");
+class PM_Web extends _1.PM {
+    constructor(t) {
+        super();
+        this.testResourceConfiguration = t;
+    }
+    start() {
+        return new Promise((r) => r());
+    }
+    stop() {
+        return new Promise((r) => r());
+    }
+    getInnerHtml(selector, page) {
+        throw new Error("web.ts getInnHtml not implemented");
+    }
+    pages() {
+        throw new Error("Method not implemented.");
+    }
+    waitForSelector(p, s) {
+        return window["waitForSelector"](p, s);
+    }
+    screencast(opts, page) {
+        return window["screencast"](Object.assign(Object.assign({}, opts), { path: this.testResourceConfiguration.fs + "/" + opts.path }), page.mainFrame()._id, 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);
+    }
+    getAttribute(selector, attribute) {
+        return window["getAttribute"](selector, attribute);
+    }
+    getValue(selector) {
+        return window["getValue"](selector);
+    }
+    focusOn(selector) {
+        return window["focusOn"](selector);
+    }
+    typeInto(value) {
+        return window["typeInto"](value);
+    }
+    async page(x) {
+        return window["page"](x);
+    }
+    click(selector) {
+        return window["click"](selector);
+    }
+    customScreenShot(x, y) {
+        const opts = x[0];
+        const page = x[1];
+        return window["customScreenShot"](Object.assign(Object.assign({}, opts), { path: this.testResourceConfiguration.fs + "/" + opts.path }), this.testResourceConfiguration.name, page);
+    }
+    existsSync(destFolder) {
+        return window["existsSync"](destFolder);
+    }
+    mkdirSync(x) {
+        return window["mkdirSync"](this.testResourceConfiguration.fs + "/");
+    }
+    write(uid, contents) {
+        return window["write"](uid, contents);
+    }
+    writeFileSync(x) {
+        const filepath = x[0];
+        const contents = x[1];
+        return window["writeFileSync"](this.testResourceConfiguration.fs + "/" + filepath, contents, this.testResourceConfiguration.name);
+    }
+    createWriteStream(filepath) {
+        return window["createWriteStream"](this.testResourceConfiguration.fs + "/" + filepath, this.testResourceConfiguration.name);
+    }
+    end(uid) {
+        return window["end"](uid);
+    }
+    customclose() {
+        window["customclose"](this.testResourceConfiguration.fs, this.testResourceConfiguration.name);
+    }
+    testArtiFactoryfileWriter(tLog, callback) {
+        return (fPath, value) => {
+            callback(new Promise((res, rej) => {
+                tLog("testArtiFactory =>", fPath);
+            }));
+        };
+    }
+}
+exports.PM_Web = PM_Web;

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

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PM_Web_Sidecar = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable prefer-rest-params */
+const net_1 = __importDefault(require("net"));
+const sidecar_1 = require("./sidecar");
+const fPaths = [];
+class PM_Web_Sidecar extends sidecar_1.PM_sidecar {
+    constructor(t) {
+        super();
+        this.testResourceConfiguration = t;
+    }
+    start() {
+        return new Promise((res) => {
+            process.on("message", (message) => {
+                if (message.path) {
+                    this.client = net_1.default.createConnection(message.path, () => {
+                        res();
+                    });
+                }
+            });
+        });
+    }
+    stop() {
+        throw new Error("stop not implemented.");
+    }
+    send(command, ...argz) {
+        return new Promise((res) => {
+            const key = Math.random().toString();
+            const myListener = (event) => {
+                const x = JSON.parse(event);
+                if (x.key === key) {
+                    process.removeListener("message", myListener);
+                    res(x.payload);
+                }
+            };
+            process.addListener("message", myListener);
+            this.client.write(JSON.stringify([command, ...argz, key]));
+        });
+    }
+}
+exports.PM_Web_Sidecar = PM_Web_Sidecar;

package/dist/common/src/Pure.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PureTesteranto = void 0;
+const index_js_1 = require("./lib/index.js");
+const Tiposkripto_js_1 = __importDefault(require("./lib/Tiposkripto.js"));
+const pure_js_1 = require("./PM/pure.js");
+class PureTesteranto extends Tiposkripto_js_1.default {
+    constructor(input, testSpecification, testImplementation, testResourceRequirement, testAdapter) {
+        super(input, testSpecification, testImplementation, testResourceRequirement, testAdapter, () => {
+            // no-op
+        });
+    }
+    async receiveTestResourceConfig(partialTestResource) {
+        const t = JSON.parse(partialTestResource);
+        const pm = new pure_js_1.PM_Pure(t);
+        try {
+            const result = this.testJobs[0].receiveTestResourceConfig(pm);
+            return result;
+        }
+        catch (e) {
+            console.error("[ERROR] Test job failed:", e);
+            return {
+                failed: true,
+                fails: -1,
+                artifacts: [],
+                // logPromise: Promise.resolve(),
+                features: [],
+            };
+        }
+    }
+}
+exports.PureTesteranto = PureTesteranto;
+exports.default = async (input, testSpecification, testImplementation, testAdapter, testResourceRequirement = index_js_1.defaultTestResourceRequirement) => {
+    return new PureTesteranto(input, testSpecification, testImplementation, testResourceRequirement, testAdapter);
+};

package/dist/common/src/Pure.test.js

@@ -0,0 +1,175 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Pure_1 = __importDefault(require("./Pure"));
+const mockPMBase_1 = require("./lib/pmProxy.test/mockPMBase");
+const implementation = {
+    suites: {
+        Default: "PureTesteranto Test Suite",
+    },
+    givens: {
+        Default: () => {
+            const pm = new mockPMBase_1.MockPMBase();
+            return {
+                pm,
+                config: {},
+                proxies: {
+                    butThenProxy: (pm, path) => (Object.assign(Object.assign({}, pm), { writeFileSync: (p, c) => {
+                            return pm.writeFileSync(`${path}/butThen/${p}`, c);
+                        } })),
+                    andWhenProxy: (pm, path) => (Object.assign(Object.assign({}, pm), { writeFileSync: (p, c) => {
+                            return pm.writeFileSync(`${path}/andWhen/${p}`, c);
+                        } })),
+                    beforeEachProxy: (pm, suite) => (Object.assign(Object.assign({}, pm), { writeFileSync: (p, c) => {
+                            return pm.writeFileSync(`suite-${suite}/beforeEach/${p}`, c);
+                        } })),
+                },
+            };
+        },
+    },
+    whens: {
+        applyProxy: (proxyType) => async (store, tr, utils) => {
+            switch (proxyType) {
+                case "invalidConfig":
+                    throw new Error("Invalid configuration");
+                case "missingProxy":
+                    return Object.assign(Object.assign({}, store), { pm: {} }); // Break proxy chain
+                case "largePayload":
+                    return Object.assign(Object.assign({}, store), { largePayload: true, pm: Object.assign(Object.assign({}, store.pm), { writeFileSync: async (p, c) => {
+                                if (c.length > 1e6) {
+                                    return true;
+                                }
+                                throw new Error("Payload too small");
+                            } }) });
+                case "resourceConfig":
+                    return Object.assign(Object.assign({}, store), { pm: Object.assign(Object.assign({}, store.pm), { testResourceConfiguration: { name: "test-resource" } }) });
+                default:
+                    return store;
+            }
+        },
+        addArtifact: (artifact) => async (store) => {
+            return Object.assign(Object.assign({}, store), { artifacts: [...(store.artifacts || []), artifact] });
+        },
+        setTestJobs: (jobs) => async (store) => {
+            return Object.assign(Object.assign({}, store), { testJobs: jobs });
+        },
+        modifySpecs: (modifier) => async (store) => {
+            return Object.assign(Object.assign({}, store), { specs: modifier(store.specs || []) });
+        },
+    },
+    thens: {
+        initializedProperly: () => async (store, tr, utils) => {
+            if (!store.pm) {
+                throw new Error("PM not initialized");
+            }
+            return store;
+        },
+        specsGenerated: () => async (store, tr, utils) => {
+            return store;
+        },
+        jobsCreated: () => async (store, tr, utils) => {
+            return store;
+        },
+        artifactsTracked: () => async (store, tr, utils) => {
+            return store;
+        },
+        testRunSuccessful: () => async (store, tr, utils) => {
+            return store;
+        },
+        specsModified: (expectedCount) => async (store, tr, utils) => {
+            return store;
+        },
+        verifyProxy: (expectedPath) => async (store, tr, utils) => {
+            return store;
+        },
+        verifyNoProxy: () => async (store, tr, utils) => {
+            return store;
+        },
+        verifyError: (expectedError) => async (store, tr, utils) => {
+            return store;
+        },
+        verifyResourceConfig: () => async (store, tr, utils) => {
+            return store;
+        },
+        verifyLargePayload: () => async (store, tr, utils) => {
+            return store;
+        },
+        verifyTypeSafety: () => async (store, tr, utils) => {
+            return store;
+        },
+    },
+};
+const specification = (Suite, Given, When, Then) => [
+    Suite.Default("Core Functionality", {
+        initializationTest: Given.Default(["Should initialize with default configuration"], [], [Then.verifyNoProxy()]),
+        resourceConfigTest: Given.Default(["Should handle test resource configuration"], [When.applyProxy("resourceConfig")], [Then.verifyResourceConfig()]),
+    }),
+    Suite.Default("Proxy Integration", {
+        butThenProxyTest: Given.Default(["Should integrate with butThenProxy"], [When.applyProxy("butThenProxy")], [Then.verifyProxy("test/path/butThen/expected")]),
+        andWhenProxyTest: Given.Default(["Should integrate with andWhenProxy"], [When.applyProxy("andWhenProxy")], [Then.verifyProxy("test/path/andWhen/expected")]),
+        beforeEachProxyTest: Given.Default(["Should integrate with beforeEachProxy"], [When.applyProxy("beforeEachProxy")], [Then.verifyProxy("suite-1/beforeEach/expected")]),
+    }),
+    Suite.Default("Error Handling", {
+        invalidConfigTest: Given.Default(["Should handle invalid configuration"], [When.applyProxy("invalidConfig")], [Then.verifyError("Invalid configuration")]),
+        missingProxyTest: Given.Default(["Should handle missing proxy"], [When.applyProxy("missingProxy")], [Then.verifyError("Proxy not found")]),
+    }),
+    Suite.Default("Performance", {
+        multipleProxiesTest: Given.Default(["Should handle multiple proxies efficiently"], [
+            When.applyProxy("butThenProxy"),
+            When.applyProxy("andWhenProxy"),
+            When.applyProxy("beforeEachProxy"),
+        ], [
+            Then.verifyProxy("test/path/butThen/expected"),
+            Then.verifyProxy("test/path/andWhen/expected"),
+            Then.verifyProxy("suite-1/beforeEach/expected"),
+        ]),
+        largePayloadTest: Given.Default(["Should handle large payloads"], [When.applyProxy("largePayload")], [Then.verifyLargePayload()]),
+    }),
+    Suite.Default("Cross-Component Verification", {
+        proxyChainTest: Given.Default(["Proxies should chain correctly"], [When.applyProxy("butThenProxy"), When.applyProxy("andWhenProxy")], [Then.verifyProxy("test/path/andWhen/butThen/expected")]),
+        errorPropagationTest: Given.Default(["Errors should propagate across components"], [When.applyProxy("invalidConfig")], [Then.verifyError("Invalid configuration")]),
+        resourceSharingTest: Given.Default(["Resources should be shared correctly"], [When.applyProxy("resourceConfig")], [Then.verifyResourceConfig()]),
+    }),
+    Suite.Default("Type Safety", {
+        strictTypeTest: Given.Default(["Should enforce type safety"], [When.applyProxy("typeSafe")], [Then.verifyTypeSafety()]),
+        invalidTypeTest: Given.Default(["Should reject invalid types"], [When.applyProxy("invalidType")], [Then.verifyError("Type mismatch")]),
+    }),
+    Suite.Default("Integration Tests", {
+        // Verify builders work together
+        builderIntegration: Given.Default(["BaseBuilder and ClassBuilder should integrate properly"], [], [
+            Then.initializedProperly(),
+            Then.specsGenerated(),
+            Then.jobsCreated(),
+            Then.artifactsTracked(),
+        ]),
+        // Verify PM proxy integration
+        pmProxyIntegration: Given.Default(["PM proxies should work with test runners"], [When.applyProxy("butThenProxy")], [Then.verifyProxy("test/path/butThen/expected")]),
+        // Verify full test lifecycle
+        fullLifecycle: Given.Default(["Should complete full test lifecycle"], [
+            When.addArtifact(Promise.resolve("test")),
+            When.setTestJobs([]),
+            When.modifySpecs((specs) => [...specs]),
+        ], [Then.testRunSuccessful(), Then.artifactsTracked(), Then.specsModified(0)]),
+    }),
+];
+const testAdapter = {
+    beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
+        const initialized = initializer();
+        return { pm: initialized.pm };
+    },
+    andWhen: async (store, whenCB, testResource, pm) => {
+        const result = await whenCB(store, testResource, pm);
+        return result;
+    },
+    butThen: async (store, thenCB, testResource, pm) => {
+        const result = await thenCB(store, testResource, pm);
+        return result;
+    },
+    afterEach: async (store, key, pm) => store,
+    afterAll: async (store, pm) => { },
+    beforeAll: async (input, testResource, pm) => ({}),
+    assertThis: (x) => x,
+};
+exports.default = (0, Pure_1.default)(null, specification, implementation, testAdapter);

package/dist/common/src/PureSidecar.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PureSideCar = void 0;
+const Sidecar_1 = require("./lib/Sidecar");
+class PureSideCar extends Sidecar_1.Sidecar {
+    start(t) {
+        throw new Error("Method not implemented.");
+    }
+    stop() {
+        throw new Error("Method not implemented.");
+    }
+}
+exports.PureSideCar = PureSideCar;

package/dist/common/src/Types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/common/src/Web.js

@@ -0,0 +1,27 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebTesteranto = void 0;
+const web_1 = require("./PM/web");
+const Tiposkripto_1 = __importDefault(require("./lib/Tiposkripto"));
+const index_js_1 = require("./lib/index.js");
+class WebTesteranto extends Tiposkripto_1.default {
+    constructor(input, testSpecification, testImplementation, testResourceRequirement, testAdapter) {
+        super(input, testSpecification, testImplementation, testResourceRequirement, testAdapter, (cb) => {
+            // todo
+        });
+    }
+    async receiveTestResourceConfig(partialTestResource) {
+        const t = partialTestResource; //JSON.parse(partialTestResource);
+        const pm = new web_1.PM_Web(t);
+        return await this.testJobs[0].receiveTestResourceConfig(pm);
+    }
+}
+exports.WebTesteranto = WebTesteranto;
+exports.default = async (input, testSpecification, testImplementation, testAdapter, testResourceRequirement = index_js_1.defaultTestResourceRequirement) => {
+    return new WebTesteranto(input, testSpecification, testImplementation, testResourceRequirement, testAdapter);
+};

package/dist/common/src/WebSidecar.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSideCar = void 0;
+const Sidecar_1 = require("./lib/Sidecar");
+class WebSideCar extends Sidecar_1.Sidecar {
+    start(t) {
+        throw new Error("Method not implemented.");
+    }
+    stop() {
+        throw new Error("Method not implemented.");
+    }
+}
+exports.WebSideCar = WebSideCar;

package/dist/common/src/app/FileService.js

@@ -0,0 +1,25 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileService = exports.FileService_methods = void 0;
+exports.FileService_methods = [
+    "writeFile_send",
+    "writeFile_receive",
+    "readFile_receive",
+    "readFile_send",
+    "createDirectory_receive",
+    "createDirectory_send",
+    "deleteFile_receive",
+    "deleteFile_send",
+    "files_send",
+    "files_receive",
+    "projects_send",
+    "projects_receive",
+    "tests_send",
+    "tests_receive",
+    "report_send",
+    "report_receive",
+];
+class FileService {
+}
+exports.FileService = FileService;