testeranto 0.202.0 → 0.203.0

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

@@ -1,210 +0,0 @@
-"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 === "pitono") {
-            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

@@ -1,106 +0,0 @@
-"use strict";
-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];
-        // console.log("customScreenShot 2 opts", opts);
-        // console.log("customScreenShot 2 page", page);
-        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) {
-        // eslint-disable-next-line prefer-rest-params
-        // const z = arguments["0"];
-        // const filepath = z[0];
-        // const contents = z[1];
-        const filepath = arguments[0];
-        const contents = arguments[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

@@ -1,47 +0,0 @@
-"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

@@ -1,52 +0,0 @@
-"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);
-        // if (!this.testJobs || this.testJobs.length === 0) {
-        //   console.error(
-        //     "[ERROR] No test jobs available - checking specs:",
-        //     this.specs?.length
-        //   );
-        //   console.error("[ERROR] Test implementation:", this.testImplementation);
-        //   return {
-        //     failed: true,
-        //     fails: 1,
-        //     artifacts: [],
-        //     // logPromise: Promise.resolve(),
-        //     features: [],
-        //   };
-        // }
-        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

@@ -1,180 +0,0 @@
-"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");
-// Implementation for PureTesteranto tests
-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;
-        },
-    },
-};
-// Specification for PureTesteranto tests
-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)]),
-    }),
-];
-// Test adapter for PureTesteranto
-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,
-};
-// Export the test suite
-exports.default = (0, Pure_1.default)(null, // No initial input
-specification, implementation, testAdapter);

package/dist/common/src/PureSidecar.js

@@ -1,13 +0,0 @@
-"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/ReportServer.js

@@ -1 +0,0 @@
-"use strict";